1_cnn_cifar_data.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "e8aebb21",
      "metadata": {
        "id": "e8aebb21"
      },
      "source": [
        "# Stage 1: Create intermediate datasets (CIFAR-10 and CIFAR-100)\n",
        "\n",
        "**Rui Filipe Martins Monteiro (R20170796) | MSc in Data Science and Advanced Analytics**\n",
        "\n",
        "<br>\n",
        "\n",
        "This notebook creates the intermediate datasets for CIFAR-10 and CIFAR-100. This means training a CNN on a dataset, removing the fully-connected layers and producing the (flattened) output from the last convolutional layers. This output is then referred to as the intermediate dataset and saved for future reuse.\n",
        "\n",
        "The intermediate datasets from this notebook are created imported images. In this case, either CIFAR-10 or CIFAR-100 is used.\n",
        "\n",
        "<br>\n",
        "\n",
        "This code is heavily inspired by: Jonathan Janke (https://github.com/novajon/classy-conv-features)\n",
        "\n",
        "Code changed and improved by: Rui Monteiro"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install ann_visualizer"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Li26TqDfAzKQ",
        "outputId": "e79a42c9-1cde-4e1e-d5c8-792cca332189"
      },
      "id": "Li26TqDfAzKQ",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting ann_visualizer\n",
            "  Downloading ann_visualizer-2.5.tar.gz (4.7 kB)\n",
            "Building wheels for collected packages: ann-visualizer\n",
            "  Building wheel for ann-visualizer (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for ann-visualizer: filename=ann_visualizer-2.5-py3-none-any.whl size=4168 sha256=4816e7f6b202a85ba4a15adc3fd5e645f3b6c1a3955932757cebb1b3df7f3373\n",
            "  Stored in directory: /root/.cache/pip/wheels/1b/fc/58/2ab1c3b30350105929308becddda4fb59b1358e54f985e1f4a\n",
            "Successfully built ann-visualizer\n",
            "Installing collected packages: ann-visualizer\n",
            "Successfully installed ann-visualizer-2.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "981b77ae",
      "metadata": {
        "id": "981b77ae"
      },
      "outputs": [],
      "source": [
        "# Imports\n",
        "from __future__ import print_function\n",
        "\n",
        "import json\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "import os\n",
        "import datetime\n",
        "from tensorflow.keras.preprocessing.image import load_img\n",
        "from tensorflow.keras.preprocessing.image import img_to_array\n",
        "from tensorflow.keras.applications.imagenet_utils import decode_predictions\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow.keras as keras\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Dropout, Flatten, Activation, InputLayer, Conv2D, MaxPooling2D\n",
        "from tensorflow.keras.layers import BatchNormalization\n",
        "from keras.layers.advanced_activations import LeakyReLU\n",
        "from tensorflow.keras.initializers import glorot_normal, RandomNormal, Zeros\n",
        "\n",
        "from keras.datasets import cifar10\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "from keras.layers import Conv2D, MaxPooling2D, BatchNormalization\n",
        "from keras import optimizers\n",
        "from keras.layers.core import Lambda\n",
        "from keras import backend as K\n",
        "from keras import regularizers\n",
        "\n",
        "import math\n",
        "from tensorflow.keras.datasets import cifar10, cifar100\n",
        "from scipy.cluster.vq import whiten\n",
        "\n",
        "import glob\n",
        "\n",
        "from tensorflow.keras.applications import InceptionV3, Xception, InceptionResNetV2\n",
        "from tensorflow.keras import Model\n",
        "\n",
        "from ann_visualizer.visualize import ann_viz\n",
        "\n",
        "from keras.utils.vis_utils import plot_model\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "f4347e68",
      "metadata": {
        "id": "f4347e68"
      },
      "outputs": [],
      "source": [
        "def show_image_classes(images, classes, prefix, suffix=\"\"):\n",
        "    \"\"\"Save input images in folder structure and output them\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    images : array, e.g. numpy array\n",
        "        images to show\n",
        "\n",
        "    classes : list\n",
        "        [not used]\n",
        "\n",
        "    prefix : string\n",
        "        prefix to add to output name\n",
        "\n",
        "    suffix : string\n",
        "        suffix to add to output name\n",
        "    \"\"\"\n",
        "    for cl in np.unique(y_train):\n",
        "        for ind, el in enumerate(y_train):\n",
        "            if el == cl:\n",
        "                class_pos = ind\n",
        "                break\n",
        "        plt.figure()\n",
        "        plt.imshow(np.uint8(x_train[class_pos]))\n",
        "        plt.axis('off')\n",
        "        path = \"sample_images/\" + prefix + \"/\"\n",
        "        if not os.path.exists(path):\n",
        "            os.makedirs(path)\n",
        "        plt.savefig(path + input_path.split(\"/\")[1].split(\"_\")[0] + \"_\" + str(cl) + \"_sample_image_\" + suffix)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "e832b301",
      "metadata": {
        "id": "e832b301"
      },
      "outputs": [],
      "source": [
        "def normalize_production(x, cifar_version):\n",
        "    \"\"\"This function is used to normalize instances in production according to saved training set statistics\n",
        "    (from https://github.com/geifmany/cifar-vgg)\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X_train : array, e.g., numpy array\n",
        "        training data set\n",
        "\n",
        "    X_test : array, e.g., numpy array\n",
        "        test data set\n",
        "    \n",
        "    cifar_version : string\n",
        "        the version of CIFAR that's being used - either 'cifar10' or 'cifar100'\n",
        "\n",
        "    Returns: normalized training set and test set according to preset constants.\n",
        "    \"\"\"\n",
        "    # These values are produced during first training and are general for the standard CIFAR training set normalization\n",
        "    if cifar_version == 'cifar10':\n",
        "        mean = 120.707\n",
        "        std = 64.15\n",
        "        return (x-mean)/(std+1e-7)\n",
        "\n",
        "    if cifar_version == 'cifar100':\n",
        "        mean = 121.936\n",
        "        std = 68.389\n",
        "        return (x-mean)/(std+1e-7)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "8f86fdf4",
      "metadata": {
        "id": "8f86fdf4"
      },
      "outputs": [],
      "source": [
        "def normalize_data(x_train, x_test, cifar_version):\n",
        "    \"\"\"Format the input data by normalizing it\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    x_train : array, e.g., numpy array\n",
        "        training data to transform\n",
        "        \n",
        "    x_test : array, e.g., numpy array\n",
        "        test data to transform\n",
        "        \n",
        "    cifar_version : string\n",
        "        the version of CIFAR that's being used - either 'cifar10' or 'cifar100'\n",
        "    \"\"\"\n",
        "    x_train = x_train.astype('float32')\n",
        "    x_test = x_test.astype('float32')\n",
        "    x_train = normalize_production(x_train, cifar_version)\n",
        "    x_test = normalize_production(x_test, cifar_version)\n",
        "    \n",
        "    return x_train, x_test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "2e3471a2",
      "metadata": {
        "id": "2e3471a2"
      },
      "outputs": [],
      "source": [
        "def create_CNN_1(input_shape):\n",
        "    \"\"\"Create CNN with predefined structure.\n",
        "    This was manually designed by: Jonathan Janke (from https://github.com/novajon/classy-conv-features)\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    input_shape : tuple\n",
        "        shape of the input data\n",
        "    \"\"\"\n",
        "    model = Sequential()\n",
        "\n",
        "    model.add(Conv2D(128, (3, 3), padding='same',\n",
        "            input_shape=x_train.shape[1:]))\n",
        "    model.add(Activation('elu'))\n",
        "\n",
        "    model.add(Conv2D(128, (3, 3)))\n",
        "    model.add(Activation('elu'))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Dropout(0.1))\n",
        "\n",
        "    model.add(Conv2D(256, (3, 3), padding='same'))\n",
        "    model.add(Activation('elu'))\n",
        "\n",
        "    model.add(Conv2D(256, (3, 3)))\n",
        "    model.add(Activation('elu'))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Dropout(0.25))\n",
        "\n",
        "    model.add(Conv2D(512, (3, 3), padding='same'))\n",
        "    model.add(Activation('elu'))\n",
        "\n",
        "    model.add(Conv2D(512, (3, 3)))\n",
        "    model.add(Activation('elu'))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    model.add(Flatten())\n",
        "\n",
        "    model.add(Dense(1024))\n",
        "    model.add(Activation('elu'))\n",
        "    model.add(Dropout(0.5))\n",
        "    \n",
        "    model.add(Dense(num_classes))\n",
        "    model.add(Activation('softmax'))\n",
        "    \n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def create_CNN_2(input_shape):\n",
        "    \"\"\"Create CNN with predefined structure.\n",
        "    This was manually designed by: Jonathan Janke (from https://github.com/novajon/classy-conv-features)\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    input_shape : tuple\n",
        "        shape of the input data\n",
        "    \"\"\"\n",
        "    model = Sequential()\n",
        "\n",
        "    model.add(Conv2D(32, (3, 3), padding='same', input_shape=x_train.shape[1:]))\n",
        "    model.add(Activation('relu'))\n",
        "\n",
        "    model.add(Conv2D(32, (3, 3)))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Dropout(0.25))\n",
        "\n",
        "    model.add(Conv2D(64, (3, 3), padding='same'))\n",
        "    model.add(Activation('relu'))\n",
        "\n",
        "    model.add(Conv2D(64, (3, 3)))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "    model.add(Dropout(0.25))\n",
        "\n",
        "    model.add(Flatten())\n",
        "\n",
        "    model.add(Dense(512))\n",
        "    model.add(Activation('relu'))\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    model.add(Dense(num_classes))\n",
        "    model.add(Activation('softmax'))\n",
        "    \n",
        "    return model"
      ],
      "metadata": {
        "id": "HfdNO4xgmr6P"
      },
      "id": "HfdNO4xgmr6P",
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class cifar10vgg:\n",
        "    \"\"\"Create VGG-16 model (from https://github.com/geifmany/cifar-vgg)\n",
        "\n",
        "    Reference:\n",
        "    - Simonyan, K., & Zisserman, A. (2014). Very Deep Convolutional Networks for Large-Scale Image Recognition.\n",
        "    \"\"\"\n",
        "    def __init__(self,train=True):\n",
        "        \"\"\"Initialize VGG-16\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        train : boolean\n",
        "            determines if weights should be loaded or retrained\n",
        "        \"\"\"\n",
        "        self.num_classes = 10\n",
        "        self.weight_decay = 0.0005\n",
        "        self.x_shape = [32,32,3]\n",
        "\n",
        "        self.model = self.build_model()\n",
        "        if train:\n",
        "            # Train model\n",
        "            self.model = self.train(self.model)\n",
        "        else:\n",
        "            # Location where saved weights are stored\n",
        "            self.model.load_weights('model_weights_cifarvgg/cifar10vgg.h5')\n",
        "\n",
        "    def build_model(self):\n",
        "        \"\"\"Create CNN with predefined structure\n",
        "        \"\"\"\n",
        "        # Build the network of vgg for 10 classes with massive dropout and weight decay as described in the paper.\n",
        "\n",
        "        model = Sequential()\n",
        "        weight_decay = self.weight_decay\n",
        "\n",
        "        model.add(Conv2D(64, (3, 3), padding='same',\n",
        "                         input_shape=self.x_shape,kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.3))\n",
        "\n",
        "        model.add(Conv2D(64, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "        model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(128, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(256, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "        model.add(Dropout(0.4))\n",
        "\n",
        "        model.add(Conv2D(512, (3, 3), padding='same',kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "\n",
        "        model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "        model.add(Dropout(0.5))\n",
        "\n",
        "        model.add(Flatten())\n",
        "        model.add(Dense(512,kernel_regularizer=regularizers.l2(weight_decay)))\n",
        "        model.add(Activation('relu'))\n",
        "        model.add(BatchNormalization())\n",
        "\n",
        "        model.add(Dropout(0.5))\n",
        "        model.add(Dense(self.num_classes))\n",
        "        model.add(Activation('softmax'))\n",
        "        return model\n",
        "\n",
        "    def normalize(self,X_train,X_test):\n",
        "        \"\"\"This function normalizes inputs for zero mean and unit variance.\n",
        "        It is used when training a model.\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        X_train : array, e.g., numpy array\n",
        "            training data set\n",
        "        X_test : array, e.g., numpy array\n",
        "            test data set\n",
        "\n",
        "        Returns: normalized training set and test set according to the training set statistics.\n",
        "        \"\"\"\n",
        "        mean = np.mean(X_train,axis=(0,1,2,3))\n",
        "        std = np.std(X_train, axis=(0,1,2,3))\n",
        "        X_train = (X_train-mean)/(std+1e-7)\n",
        "        X_test = (X_test-mean)/(std+1e-7)\n",
        "        return X_train, X_test\n",
        "    \n",
        "    def normalize_production(self,x):\n",
        "        \"\"\"This function is used to normalize instances in production according to saved training set statistics\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        X_train : array, e.g., numpy array\n",
        "            training data set\n",
        "        X_test : array, e.g., numpy array\n",
        "            test data set\n",
        "\n",
        "        Returns: normalized training set and test set according to preset constants.\n",
        "        \"\"\"\n",
        "        # These values produced during first training and are general for the standard CIFAR-10 training set normalization\n",
        "        mean = 120.707\n",
        "        std = 64.15\n",
        "        return (x-mean)/(std+1e-7)\n",
        "\n",
        "    def predict(self,x,normalize=True,batch_size=50):\n",
        "        \"\"\"Makes a prediction using the trained model\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        X : array, e.g., numpy array\n",
        "            data to make prediction on\n",
        "        normalize : boolean\n",
        "            determines if dataset should be normalized before making a prediction\n",
        "        batch_size : int\n",
        "            determines the batch size per prediction batch\n",
        "\n",
        "        Returns : predictions\n",
        "        \"\"\"\n",
        "        if normalize:\n",
        "            x = self.normalize_production(x)\n",
        "        return self.model.predict(x,batch_size)\n",
        "\n",
        "    def train(self,model):\n",
        "        \"\"\"Trains the model\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        model : Model\n",
        "            model to be trained\n",
        "        \"\"\"\n",
        "        # Training parameters\n",
        "        batch_size = 128\n",
        "        maxepoches = 250\n",
        "        learning_rate = 0.1\n",
        "        lr_decay = 1e-6\n",
        "        lr_drop = 20\n",
        "\n",
        "        # The data, shuffled and split between train and test sets:\n",
        "        (x_train, y_train), (x_test, y_test) = cifar10.load_data()\n",
        "        x_train = x_train.astype('float32')\n",
        "        x_test = x_test.astype('float32')\n",
        "        x_train, x_test = self.normalize(x_train, x_test)\n",
        "\n",
        "        y_train = keras.utils.to_categorical(y_train, self.num_classes)\n",
        "        y_test = keras.utils.to_categorical(y_test, self.num_classes)\n",
        "\n",
        "        def lr_scheduler(epoch):\n",
        "            return learning_rate * (0.5 ** (epoch // lr_drop))\n",
        "        reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)\n",
        "\n",
        "        # Data augmentation\n",
        "        datagen = ImageDataGenerator(\n",
        "            featurewise_center=False,  # set input mean to 0 over the dataset\n",
        "            samplewise_center=False,  # set each sample mean to 0\n",
        "            featurewise_std_normalization=False,  # divide inputs by std of the dataset\n",
        "            samplewise_std_normalization=False,  # divide each input by its std\n",
        "            zca_whitening=False,  # apply ZCA whitening\n",
        "            rotation_range=15,  # randomly rotate images in the range (degrees, 0 to 180)\n",
        "            width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)\n",
        "            height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)\n",
        "            horizontal_flip=True,  # randomly flip images\n",
        "            vertical_flip=False)  # randomly flip images\n",
        "\n",
        "        # (std, mean, and principal components if ZCA whitening is applied).\n",
        "        datagen.fit(x_train)\n",
        "\n",
        "        # Optimization details\n",
        "        sgd = optimizers.SGD(lr=learning_rate, decay=lr_decay, momentum=0.9, nesterov=True)\n",
        "        model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy'])\n",
        "\n",
        "        # Training process in a for loop with learning rate drop every 25 epoches.\n",
        "        historytemp = model.fit_generator(datagen.flow(x_train, y_train,\n",
        "                                         batch_size=batch_size),\n",
        "                            steps_per_epoch=x_train.shape[0] // batch_size,\n",
        "                            epochs=maxepoches,\n",
        "                            validation_data=(x_test, y_test),callbacks=[reduce_lr],verbose=2)\n",
        "        model.save_weights('cifar10vgg.h5')\n",
        "        return model"
      ],
      "metadata": {
        "id": "rueV8y-IujK5"
      },
      "id": "rueV8y-IujK5",
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def cut_model(input_model):\n",
        "    \"\"\"Removes fully-connected layer from the end of a CNN model\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    input_model : Model\n",
        "        model to cut\n",
        "    \"\"\"\n",
        "    dense_layer_count = 0\n",
        "    count = False\n",
        "    model_length = len(input_model.layers)\n",
        "    output_model = Sequential()\n",
        "    output_config = []\n",
        "\n",
        "    for index in range(model_length):\n",
        "        if count == True:\n",
        "            output_config.append(layer.get_config())\n",
        "            input_model.pop()\n",
        "        else:\n",
        "            layer = input_model.layers[index]\n",
        "        if layer.name.startswith('flatten'):\n",
        "            count = True\n",
        "            output_model.add(InputLayer(input_shape=layer.output_shape))          \n",
        "    # return output_model"
      ],
      "metadata": {
        "id": "SiZ_at8_M1yT"
      },
      "id": "SiZ_at8_M1yT",
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_output_files(x_train, x_test, y_train, y_test, prefix, suffix = \"\"):\n",
        "    \"\"\"Create the output files to save intermediate datasets for further use\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    x_train : array, e.g., numpy array\n",
        "        training input data\n",
        "\n",
        "    x_test : array, e.g., numpy array\n",
        "        testing input data\n",
        "\n",
        "    y_train : list\n",
        "        training target data\n",
        "\n",
        "    y_test : list\n",
        "        test target data\n",
        "\n",
        "    prefix : string\n",
        "        prefix to add to output file name\n",
        "\n",
        "    suffix : string\n",
        "        suffix to add to output file name\n",
        "    \"\"\"\n",
        "    for i, model in enumerate(models):\n",
        "        pred_train = model.predict(x_train)\n",
        "        pred_test = model.predict(x_test)\n",
        "        pred_train_with_target = np.array([np.array([preds, y_train[i]]) for i, preds in enumerate(pred_train)])\n",
        "        pred_test_with_target = np.array([np.array([preds, y_test[i]]) for i, preds in enumerate(pred_test)])\n",
        "        path = input_path + \"intermediate/\" + prefix + \"/\" + model_names[i]\n",
        "        \n",
        "        if not os.path.exists(path):\n",
        "            os.makedirs(path)\n",
        "            \n",
        "        np.save(path + \"/train\" + suffix, pred_train_with_target)\n",
        "        np.save(path + \"/test\" + suffix, pred_test_with_target)"
      ],
      "metadata": {
        "id": "bbuVeAN6PLzo"
      },
      "id": "bbuVeAN6PLzo",
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_model_stats(hist):\n",
        "    \"\"\"Plot model statistics after the learning procedure, e.g. accuracy development over time (epochs)\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    hist : Histogram\n",
        "        model statistics to plot\n",
        "    \"\"\"\n",
        "    # Summarize history for accuracy\n",
        "    plt.plot(hist.history['accuracy'])\n",
        "    plt.plot(hist.history['val_accuracy'])\n",
        "    plt.title('Model Accuracy')\n",
        "    plt.ylabel('accuracy')\n",
        "    plt.xlabel('epoch')\n",
        "    plt.legend(['train', 'test'], loc='upper left')\n",
        "    plt.show()\n",
        "    \n",
        "    # Summarize history for loss\n",
        "    plt.plot(hist.history['loss'])\n",
        "    plt.plot(hist.history['val_loss'])\n",
        "    plt.title('Model Loss')\n",
        "    plt.ylabel('loss')\n",
        "    plt.xlabel('epoch')\n",
        "    plt.legend(['train', 'test'], loc='upper left')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "D0AxQUAnQLpE"
      },
      "id": "D0AxQUAnQLpE",
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "71d704da",
      "metadata": {
        "id": "71d704da"
      },
      "source": [
        "## 1. Data Exploration"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "3830c382",
      "metadata": {
        "id": "3830c382",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b55ed42-795b-4e35-e03c-0fa262acb1a8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
            "170500096/170498071 [==============================] - 2s 0us/step\n",
            "170508288/170498071 [==============================] - 2s 0us/step\n"
          ]
        }
      ],
      "source": [
        "# Load dataset\n",
        "cifar_version = 'cifar10'\n",
        "input_path = \"data/cifar10_filtered/\"\n",
        "(x_train, y_train), (x_test, y_test) = cifar10.load_data()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "1d09e5cd",
      "metadata": {
        "id": "1d09e5cd"
      },
      "outputs": [],
      "source": [
        "# cifar_version = 'cifar100'\n",
        "# input_path = \"data/cifar100_filtered/\"\n",
        "# (x_train, y_train), (x_test, y_test) = cifar100.load_data()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "ad5a0d4d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ad5a0d4d",
        "outputId": "c9033165-ecbc-4b7b-f669-6fad64d53237"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "num_classes = len(np.unique(y_train))\n",
        "num_classes"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Shape of x_train is', x_train.shape)\n",
        "print('Shape of y_train is', y_train.shape)\n",
        "print()\n",
        "print('Shape of x_test  is', x_test.shape)\n",
        "print('Shape of y_test  is', y_test.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SEZHUniydR64",
        "outputId": "9b2e5e09-c6a6-4fad-dd9b-65cd03a70e01"
      },
      "id": "SEZHUniydR64",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape of x_train is (50000, 32, 32, 3)\n",
            "Shape of y_train is (50000, 1)\n",
            "\n",
            "Shape of x_test  is (10000, 32, 32, 3)\n",
            "Shape of y_test  is (10000, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "14abb956",
      "metadata": {
        "id": "14abb956"
      },
      "outputs": [],
      "source": [
        "treat_data = \"normalize\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "9fb9e85c",
      "metadata": {
        "id": "9fb9e85c"
      },
      "outputs": [],
      "source": [
        "# Produce a timestamp to attach to future outputs\n",
        "now = datetime.datetime.now()\n",
        "prefix = now.strftime(\"%Y%m%d_%H%M\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "id": "f4ff1fd5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "f4ff1fd5",
        "outputId": "f031770d-e2f3-429a-bc80-a97e279c7c6a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Show the images to get a visual understanding of the classes\n",
        "show_image_classes(x_train, y_train, prefix, \"raw\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "id": "00025523",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "00025523",
        "outputId": "85e7570d-2701-4570-d752-a8d1fee8003d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Check the first \"n_images\" images of class number \"class_n\"\n",
        "n_images = 6\n",
        "class_n = 0\n",
        "if cifar_version == 'cifar10':\n",
        "    class_n = 1\n",
        "\n",
        "class_n_pos = [ind for ind, el in enumerate(y_train) if el == class_n]\n",
        "\n",
        "for img in class_n_pos[:n_images]:\n",
        "    plt.figure()\n",
        "    plt.imshow(np.uint8(x_train[img]))\n",
        "    plt.axis('off')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d17b6c0b",
      "metadata": {
        "id": "d17b6c0b"
      },
      "source": [
        "## 2. Data Transformation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "id": "325e3b58",
      "metadata": {
        "id": "325e3b58"
      },
      "outputs": [],
      "source": [
        "# Preprocess data through normalization\n",
        "# Normalisation of data according to predefined normalize_data method\n",
        "if treat_data == \"normalize\":\n",
        "    x_train, x_test = normalize_data(x_train, x_test, cifar_version=cifar_version)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "id": "fc467e0f",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "fc467e0f",
        "outputId": "6dd57dbe-4a2f-44b7-9b2c-b868c79f053b"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAGEklEQVR4nO3dy27DSBJFQWsw///L7u1gYKbbaYo+lCK2BMWHdFFApary8fn5+QH0/OevbwD4mnBClHBClHBClHBC1H+/Of6SU7mP4dj0wNN58wXXZ35tmmE/+1r8a7+ofHz5pRk5IUo4IUo4IUo4IUo4IUo4Ieq7UsqtHRYVhnLDYyqmjHWWC0sYb1guuXqBxmPxjrcluiNGTogSTogSTogSTogSTogSToh6fDNFfetVKZvpcJ7v7vtWrX5XwzN/WpUC9yKcECWcECWcECWcEHX7P76bj/07d5h1nWZWt/d/dN7Zv0UjJ0QJJ0QJJ0QJJ0QJJ0QJJ0TdvpRyuhu0OtgWMDZ3f3255Ogut2WP/Z38+FrDsc27N3JClHBClHBClHBClHBClHBC1O1LKfP09dHRYaXCeLEnFDEurM5UtosaV4ocnbN8UZmVM4teDUZOiBJOiBJOiBJOiBJOiBJOiBpLKWd36n1G1WC5VuHku9hbrRRZX63z3Fd5xgZf57f5+Po+jJwQJZwQJZwQJZwQJZwQJZwQNZZSzt6waDR+4PHB45Un127uNGrsC5YxlTCu7EZe73xu5IQo4YQo4YQo4YQo4YSo5+whtJoFq0ytXuvspx4XK0zfS2Zq+2ulLhmHna2XFYcjRk6IEk6IEk6IEk6IEk6IEk6I2pdSTp+/Pn+vl1f1nMrBuR2lt46/6kuXYYy2rSF+ysgJUcIJUcIJUcIJUcIJUcIJUXM7hktnqN+zXHJ2AWNbcPg8PHj1SpafdyPfekarhjMZOSFKOCFKOCFKOCFKOCFKOCHqORt8HRl3abruNt7X1NbiyNDu4lf3cl+fB0/+GOtYNviClyGcECWcECWcECWcECWcEPVNKWVb3/h6TnleMTGumVjex/uZ3mNni6yNXQfzS7tXn3wtIydECSdECSdECSdECSdECSdE7VelDPPXCh//59IaxvHFrurx8er0SoE3J5wQJZwQJZwQJZwQde0eQoPC9vd/YdPJ+XOaLRwPbaaNp5nJJyxWOPjz+Hyl3bXWv7mLJr2NnBAlnBAlnBAlnBAlnBAlnBCVKaW8trPLRMPnHbeong7tqgPPqKScfNZULrl0f6EFIydECSdECSdECSdECSdECSdErUsp77mG5A62ZZaDbs2rbtjfrJxZ/Xqm+9jtZ1Uvsxg5IUo4IUo4IUo4IUo4IUo4IWpdSilMNX983GNjsE7P7s0GX8teEgelme8+8vwmH43f6YaRE6KEE6KEE6KEE6KEE6KEE6K+KaVsWzIfndeY1h7vYiwRnd+i+rCAcYMS0dxFezhresdnP3anjvVjRk6IEk6IEk6IEk6IEk6I+kU7hsW/l6c/Q4+G/WOGmb/DGc/1pHFjtrljePfjTO7yD/Mn6yw6+JqRE6KEE6KEE6KEE6KEE6KEE6K+KaVMf1AepoYPTzv783bGS0WqJasS0eV25ZJ5+cBmL6Nj41lj2ebvfwhGTogSTogSTogSTogSTogSToj6xaqUwWYLoSfUMHaT8u3p9Y+P52yLc/6T7fYX+vmn/ergsdULObfEZeSEKOGEKOGEKOGEKOGEKOGEqH0ppbJ8Y3Jwj49xVccNnmtZTKl0Iz9fZZXOuYycECWcECWcECWcECWcECWcEPWcVSl1Ny8pTH1IXtWNG1SvGTkhSjghSjghSjghSjgh6j1na+GjP2lv5IQo4YQo4YQo4YQo4YQo4YQopZSoTvfqV7atpVzz3Rg5IUo4IUo4IUo4IUo4IUo4IUop5cW8bsuF92PkhCjhhCjhhCjhhCjhhCjhhCilFG7v+vLR0fXOXa1i5IQo4YQo4YQo4YQo4YQo4YSofSll2oDqZVdGTFPl5z7z/Apf9f3yv4ycECWcECWcECWcECWcECWcEDWWUqZ+HS9bLbmoD8b313vZF/wC9EqBtyacECWcECWcECWcEPWLP74Pxx7nzkDuZ4031zNLSoORE6KEE6KEE6KEE6KEE6KEE6LGUsq6qHBYSdntwaNb8w+85d5Or8nICVHCCVHCCVHCCVHCCVHCCVGPacUH8HeMnBAlnBAlnBAlnBAlnBAlnBD1D+pw8w8vYFd4AAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Show normalized data\n",
        "if treat_data == \"normalize\": \n",
        "    show_image_classes(x_train, y_train, prefix, \"normalized\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "id": "9de3cf89",
      "metadata": {
        "id": "9de3cf89"
      },
      "outputs": [],
      "source": [
        "# One-hot encoding: make target values categorical\n",
        "y_train_categorical = to_categorical(y_train)\n",
        "y_test_categorical = to_categorical(y_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "12f25ac9",
      "metadata": {
        "id": "12f25ac9"
      },
      "source": [
        "## 3. Neural Network Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "ab8431a2",
      "metadata": {
        "id": "ab8431a2"
      },
      "outputs": [],
      "source": [
        "datagen = keras.preprocessing.image.ImageDataGenerator(featurewise_center=False, \n",
        "                                                       samplewise_center=False, \n",
        "                                                       featurewise_std_normalization=False, \n",
        "                                                       samplewise_std_normalization=False, \n",
        "                                                       zca_whitening=False, \n",
        "                                                       zca_epsilon=1e-06, \n",
        "                                                       rotation_range=0.0, \n",
        "                                                       width_shift_range=0.0, \n",
        "                                                       height_shift_range=0.0, \n",
        "                                                       brightness_range=None, \n",
        "                                                       shear_range=0.0, \n",
        "                                                       zoom_range=0.0, \n",
        "                                                       channel_shift_range=0.0, \n",
        "                                                       fill_mode='nearest', \n",
        "                                                       cval=0.0, \n",
        "                                                       horizontal_flip=False, \n",
        "                                                       vertical_flip=False, \n",
        "                                                       rescale=None, \n",
        "                                                       preprocessing_function=None, \n",
        "                                                       data_format=None, \n",
        "                                                       validation_split=0.0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "665387f4",
      "metadata": {
        "id": "665387f4"
      },
      "outputs": [],
      "source": [
        "# Compute quantities required for featurewise normalization\n",
        "# (std, mean, and principal components if ZCA whitening is applied)\n",
        "datagen.fit(x_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "id": "b145972c",
      "metadata": {
        "id": "b145972c"
      },
      "outputs": [],
      "source": [
        "models = []\n",
        "model_names = []\n",
        "input_shape = x_train[0].shape\n",
        "batch_size = 100\n",
        "epochs = 80"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "id": "1324150d",
      "metadata": {
        "id": "1324150d"
      },
      "outputs": [],
      "source": [
        "# Create neural network models\n",
        "models.append(create_CNN_1(input_shape))\n",
        "model_names.append(\"CNN_Input_1\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "models.append(create_CNN_2(input_shape))\n",
        "model_names.append(\"CNN_Input_2\")"
      ],
      "metadata": {
        "id": "DIrF6V1no_N3"
      },
      "id": "DIrF6V1no_N3",
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "id": "0a96da50",
      "metadata": {
        "id": "0a96da50"
      },
      "outputs": [],
      "source": [
        "history = []\n",
        "lr = 0.0001\n",
        "\n",
        "for model in models:\n",
        "    model.compile(loss=keras.losses.categorical_crossentropy,\n",
        "                  optimizer=tf.keras.optimizers.Adam(lr=lr),\n",
        "                  metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "id": "90ef67b9",
      "metadata": {
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "90ef67b9",
        "outputId": "2ef0aff0-7955-4450-f474-6dfbca9a3aef"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/80\n",
            "500/500 [==============================] - 40s 54ms/step - loss: 1.5235 - accuracy: 0.4530 - val_loss: 1.1471 - val_accuracy: 0.5961\n",
            "Epoch 2/80\n",
            "500/500 [==============================] - 27s 53ms/step - loss: 1.1318 - accuracy: 0.6023 - val_loss: 1.0253 - val_accuracy: 0.6435\n",
            "Epoch 3/80\n",
            "500/500 [==============================] - 27s 55ms/step - loss: 0.9998 - accuracy: 0.6540 - val_loss: 0.8907 - val_accuracy: 0.6943\n",
            "Epoch 4/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.9131 - accuracy: 0.6851 - val_loss: 0.8558 - val_accuracy: 0.7073\n",
            "Epoch 5/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.8458 - accuracy: 0.7088 - val_loss: 0.8171 - val_accuracy: 0.7179\n",
            "Epoch 6/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.7906 - accuracy: 0.7255 - val_loss: 0.8093 - val_accuracy: 0.7211\n",
            "Epoch 7/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.7404 - accuracy: 0.7421 - val_loss: 0.7270 - val_accuracy: 0.7486\n",
            "Epoch 8/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.6843 - accuracy: 0.7646 - val_loss: 0.7156 - val_accuracy: 0.7596\n",
            "Epoch 9/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.6471 - accuracy: 0.7756 - val_loss: 0.7052 - val_accuracy: 0.7626\n",
            "Epoch 10/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.6110 - accuracy: 0.7880 - val_loss: 0.6883 - val_accuracy: 0.7684\n",
            "Epoch 11/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.5658 - accuracy: 0.8036 - val_loss: 0.7186 - val_accuracy: 0.7599\n",
            "Epoch 12/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.5351 - accuracy: 0.8120 - val_loss: 0.6791 - val_accuracy: 0.7772\n",
            "Epoch 13/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.5028 - accuracy: 0.8227 - val_loss: 0.6503 - val_accuracy: 0.7860\n",
            "Epoch 14/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.4689 - accuracy: 0.8365 - val_loss: 0.6979 - val_accuracy: 0.7820\n",
            "Epoch 15/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.4420 - accuracy: 0.8449 - val_loss: 0.6765 - val_accuracy: 0.7847\n",
            "Epoch 16/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.4189 - accuracy: 0.8520 - val_loss: 0.6868 - val_accuracy: 0.7897\n",
            "Epoch 17/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.4020 - accuracy: 0.8591 - val_loss: 0.6825 - val_accuracy: 0.7885\n",
            "Epoch 18/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.3684 - accuracy: 0.8694 - val_loss: 0.6765 - val_accuracy: 0.7923\n",
            "Epoch 19/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.3461 - accuracy: 0.8769 - val_loss: 0.7097 - val_accuracy: 0.7948\n",
            "Epoch 20/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.3270 - accuracy: 0.8835 - val_loss: 0.6878 - val_accuracy: 0.8024\n",
            "Epoch 21/80\n",
            "500/500 [==============================] - 28s 55ms/step - loss: 0.3090 - accuracy: 0.8900 - val_loss: 0.7003 - val_accuracy: 0.7982\n",
            "Epoch 22/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2941 - accuracy: 0.8961 - val_loss: 0.7028 - val_accuracy: 0.7999\n",
            "Epoch 23/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2780 - accuracy: 0.9021 - val_loss: 0.7780 - val_accuracy: 0.7903\n",
            "Epoch 24/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2616 - accuracy: 0.9066 - val_loss: 0.7583 - val_accuracy: 0.7939\n",
            "Epoch 25/80\n",
            "500/500 [==============================] - 28s 55ms/step - loss: 0.2446 - accuracy: 0.9130 - val_loss: 0.7255 - val_accuracy: 0.8062\n",
            "Epoch 26/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2371 - accuracy: 0.9170 - val_loss: 0.7436 - val_accuracy: 0.8016\n",
            "Epoch 27/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2252 - accuracy: 0.9189 - val_loss: 0.7498 - val_accuracy: 0.8058\n",
            "Epoch 28/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2116 - accuracy: 0.9252 - val_loss: 0.7449 - val_accuracy: 0.8063\n",
            "Epoch 29/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.2048 - accuracy: 0.9276 - val_loss: 0.7277 - val_accuracy: 0.8050\n",
            "Epoch 30/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1909 - accuracy: 0.9329 - val_loss: 0.7615 - val_accuracy: 0.8061\n",
            "Epoch 31/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.1862 - accuracy: 0.9333 - val_loss: 0.7511 - val_accuracy: 0.8098\n",
            "Epoch 32/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1772 - accuracy: 0.9385 - val_loss: 0.7609 - val_accuracy: 0.8107\n",
            "Epoch 33/80\n",
            "500/500 [==============================] - 28s 55ms/step - loss: 0.1707 - accuracy: 0.9389 - val_loss: 0.7519 - val_accuracy: 0.8106\n",
            "Epoch 34/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1596 - accuracy: 0.9443 - val_loss: 0.7244 - val_accuracy: 0.8066\n",
            "Epoch 35/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1548 - accuracy: 0.9454 - val_loss: 0.7383 - val_accuracy: 0.8175\n",
            "Epoch 36/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.1519 - accuracy: 0.9472 - val_loss: 0.8079 - val_accuracy: 0.8137\n",
            "Epoch 37/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.1436 - accuracy: 0.9490 - val_loss: 0.7722 - val_accuracy: 0.8121\n",
            "Epoch 38/80\n",
            "500/500 [==============================] - 28s 55ms/step - loss: 0.1423 - accuracy: 0.9507 - val_loss: 0.8497 - val_accuracy: 0.8141\n",
            "Epoch 39/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1321 - accuracy: 0.9538 - val_loss: 0.7703 - val_accuracy: 0.8160\n",
            "Epoch 40/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1296 - accuracy: 0.9544 - val_loss: 0.8572 - val_accuracy: 0.8121\n",
            "Epoch 41/80\n",
            "500/500 [==============================] - 28s 55ms/step - loss: 0.1263 - accuracy: 0.9552 - val_loss: 0.8064 - val_accuracy: 0.8109\n",
            "Epoch 42/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1212 - accuracy: 0.9575 - val_loss: 0.8497 - val_accuracy: 0.8146\n",
            "Epoch 43/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1158 - accuracy: 0.9590 - val_loss: 0.8883 - val_accuracy: 0.8094\n",
            "Epoch 44/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1130 - accuracy: 0.9596 - val_loss: 0.8209 - val_accuracy: 0.8164\n",
            "Epoch 45/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1079 - accuracy: 0.9620 - val_loss: 0.8689 - val_accuracy: 0.8132\n",
            "Epoch 46/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1099 - accuracy: 0.9603 - val_loss: 0.9247 - val_accuracy: 0.8165\n",
            "Epoch 47/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.1088 - accuracy: 0.9612 - val_loss: 0.9000 - val_accuracy: 0.8132\n",
            "Epoch 48/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0980 - accuracy: 0.9662 - val_loss: 0.8193 - val_accuracy: 0.8209\n",
            "Epoch 49/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.1028 - accuracy: 0.9646 - val_loss: 0.8427 - val_accuracy: 0.8222\n",
            "Epoch 50/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0991 - accuracy: 0.9648 - val_loss: 0.8088 - val_accuracy: 0.8167\n",
            "Epoch 51/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0940 - accuracy: 0.9671 - val_loss: 0.8295 - val_accuracy: 0.8226\n",
            "Epoch 52/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0923 - accuracy: 0.9684 - val_loss: 0.8224 - val_accuracy: 0.8208\n",
            "Epoch 53/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0950 - accuracy: 0.9682 - val_loss: 0.8664 - val_accuracy: 0.8208\n",
            "Epoch 54/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0858 - accuracy: 0.9702 - val_loss: 0.8782 - val_accuracy: 0.8205\n",
            "Epoch 55/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0911 - accuracy: 0.9679 - val_loss: 0.8551 - val_accuracy: 0.8205\n",
            "Epoch 56/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0810 - accuracy: 0.9722 - val_loss: 0.8919 - val_accuracy: 0.8169\n",
            "Epoch 57/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0812 - accuracy: 0.9721 - val_loss: 0.9160 - val_accuracy: 0.8239\n",
            "Epoch 58/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0802 - accuracy: 0.9721 - val_loss: 0.8706 - val_accuracy: 0.8222\n",
            "Epoch 59/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0785 - accuracy: 0.9728 - val_loss: 0.9518 - val_accuracy: 0.8186\n",
            "Epoch 60/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0765 - accuracy: 0.9738 - val_loss: 0.8585 - val_accuracy: 0.8258\n",
            "Epoch 61/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0759 - accuracy: 0.9741 - val_loss: 0.9010 - val_accuracy: 0.8225\n",
            "Epoch 62/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0738 - accuracy: 0.9736 - val_loss: 0.8801 - val_accuracy: 0.8249\n",
            "Epoch 63/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0675 - accuracy: 0.9761 - val_loss: 0.8953 - val_accuracy: 0.8265\n",
            "Epoch 64/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0700 - accuracy: 0.9756 - val_loss: 0.9742 - val_accuracy: 0.8249\n",
            "Epoch 65/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0673 - accuracy: 0.9764 - val_loss: 0.8872 - val_accuracy: 0.8246\n",
            "Epoch 66/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0664 - accuracy: 0.9772 - val_loss: 0.9159 - val_accuracy: 0.8303\n",
            "Epoch 67/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0662 - accuracy: 0.9782 - val_loss: 0.9284 - val_accuracy: 0.8297\n",
            "Epoch 68/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0672 - accuracy: 0.9775 - val_loss: 0.8584 - val_accuracy: 0.8246\n",
            "Epoch 69/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0653 - accuracy: 0.9777 - val_loss: 0.8656 - val_accuracy: 0.8328\n",
            "Epoch 70/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0651 - accuracy: 0.9775 - val_loss: 0.8820 - val_accuracy: 0.8259\n",
            "Epoch 71/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0598 - accuracy: 0.9798 - val_loss: 0.9158 - val_accuracy: 0.8230\n",
            "Epoch 72/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0613 - accuracy: 0.9787 - val_loss: 0.8856 - val_accuracy: 0.8289\n",
            "Epoch 73/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0606 - accuracy: 0.9791 - val_loss: 0.9285 - val_accuracy: 0.8258\n",
            "Epoch 74/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0601 - accuracy: 0.9799 - val_loss: 0.9053 - val_accuracy: 0.8297\n",
            "Epoch 75/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0588 - accuracy: 0.9803 - val_loss: 0.9390 - val_accuracy: 0.8269\n",
            "Epoch 76/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0563 - accuracy: 0.9809 - val_loss: 0.9273 - val_accuracy: 0.8247\n",
            "Epoch 77/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0588 - accuracy: 0.9808 - val_loss: 0.9604 - val_accuracy: 0.8306\n",
            "Epoch 78/80\n",
            "500/500 [==============================] - 28s 56ms/step - loss: 0.0597 - accuracy: 0.9793 - val_loss: 0.9904 - val_accuracy: 0.8276\n",
            "Epoch 79/80\n",
            "500/500 [==============================] - 29s 57ms/step - loss: 0.0538 - accuracy: 0.9821 - val_loss: 0.9164 - val_accuracy: 0.8285\n",
            "Epoch 80/80\n",
            "500/500 [==============================] - 28s 57ms/step - loss: 0.0522 - accuracy: 0.9817 - val_loss: 0.9235 - val_accuracy: 0.8334\n",
            "Model success\n",
            "Epoch 1/80\n",
            "500/500 [==============================] - 7s 12ms/step - loss: 1.8432 - accuracy: 0.3276 - val_loss: 1.5218 - val_accuracy: 0.4603\n",
            "Epoch 2/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 1.5034 - accuracy: 0.4552 - val_loss: 1.3566 - val_accuracy: 0.5156\n",
            "Epoch 3/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 1.3779 - accuracy: 0.5028 - val_loss: 1.2532 - val_accuracy: 0.5553\n",
            "Epoch 4/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 1.2957 - accuracy: 0.5362 - val_loss: 1.1858 - val_accuracy: 0.5852\n",
            "Epoch 5/80\n",
            "500/500 [==============================] - 6s 11ms/step - loss: 1.2337 - accuracy: 0.5615 - val_loss: 1.1314 - val_accuracy: 0.6019\n",
            "Epoch 6/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 1.1724 - accuracy: 0.5819 - val_loss: 1.0759 - val_accuracy: 0.6212\n",
            "Epoch 7/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 1.1245 - accuracy: 0.6011 - val_loss: 1.0296 - val_accuracy: 0.6390\n",
            "Epoch 8/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 1.0789 - accuracy: 0.6187 - val_loss: 0.9983 - val_accuracy: 0.6504\n",
            "Epoch 9/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 1.0322 - accuracy: 0.6365 - val_loss: 0.9612 - val_accuracy: 0.6639\n",
            "Epoch 10/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.9992 - accuracy: 0.6478 - val_loss: 0.9377 - val_accuracy: 0.6762\n",
            "Epoch 11/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.9596 - accuracy: 0.6619 - val_loss: 0.8952 - val_accuracy: 0.6898\n",
            "Epoch 12/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.9357 - accuracy: 0.6699 - val_loss: 0.8787 - val_accuracy: 0.6931\n",
            "Epoch 13/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.9079 - accuracy: 0.6815 - val_loss: 0.8592 - val_accuracy: 0.7017\n",
            "Epoch 14/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.8785 - accuracy: 0.6919 - val_loss: 0.8274 - val_accuracy: 0.7152\n",
            "Epoch 15/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.8535 - accuracy: 0.7003 - val_loss: 0.8134 - val_accuracy: 0.7167\n",
            "Epoch 16/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.8303 - accuracy: 0.7079 - val_loss: 0.7985 - val_accuracy: 0.7211\n",
            "Epoch 17/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.8028 - accuracy: 0.7201 - val_loss: 0.7771 - val_accuracy: 0.7298\n",
            "Epoch 18/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.7865 - accuracy: 0.7243 - val_loss: 0.7888 - val_accuracy: 0.7273\n",
            "Epoch 19/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.7587 - accuracy: 0.7355 - val_loss: 0.7534 - val_accuracy: 0.7398\n",
            "Epoch 20/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.7440 - accuracy: 0.7380 - val_loss: 0.7501 - val_accuracy: 0.7430\n",
            "Epoch 21/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.7267 - accuracy: 0.7439 - val_loss: 0.7327 - val_accuracy: 0.7484\n",
            "Epoch 22/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.7101 - accuracy: 0.7513 - val_loss: 0.7236 - val_accuracy: 0.7510\n",
            "Epoch 23/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.6912 - accuracy: 0.7570 - val_loss: 0.7175 - val_accuracy: 0.7527\n",
            "Epoch 24/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.6766 - accuracy: 0.7641 - val_loss: 0.7029 - val_accuracy: 0.7564\n",
            "Epoch 25/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.6618 - accuracy: 0.7699 - val_loss: 0.6976 - val_accuracy: 0.7566\n",
            "Epoch 26/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.6459 - accuracy: 0.7737 - val_loss: 0.6981 - val_accuracy: 0.7593\n",
            "Epoch 27/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.6296 - accuracy: 0.7791 - val_loss: 0.6791 - val_accuracy: 0.7661\n",
            "Epoch 28/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.6201 - accuracy: 0.7830 - val_loss: 0.6714 - val_accuracy: 0.7691\n",
            "Epoch 29/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.6026 - accuracy: 0.7886 - val_loss: 0.6756 - val_accuracy: 0.7658\n",
            "Epoch 30/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.5905 - accuracy: 0.7921 - val_loss: 0.6678 - val_accuracy: 0.7727\n",
            "Epoch 31/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.5791 - accuracy: 0.7965 - val_loss: 0.6759 - val_accuracy: 0.7705\n",
            "Epoch 32/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.5681 - accuracy: 0.8011 - val_loss: 0.6500 - val_accuracy: 0.7770\n",
            "Epoch 33/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.5582 - accuracy: 0.8034 - val_loss: 0.6508 - val_accuracy: 0.7767\n",
            "Epoch 34/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.5475 - accuracy: 0.8078 - val_loss: 0.6514 - val_accuracy: 0.7766\n",
            "Epoch 35/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.5320 - accuracy: 0.8131 - val_loss: 0.6544 - val_accuracy: 0.7770\n",
            "Epoch 36/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.5208 - accuracy: 0.8167 - val_loss: 0.6439 - val_accuracy: 0.7799\n",
            "Epoch 37/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.5087 - accuracy: 0.8204 - val_loss: 0.6384 - val_accuracy: 0.7849\n",
            "Epoch 38/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.5034 - accuracy: 0.8235 - val_loss: 0.6444 - val_accuracy: 0.7794\n",
            "Epoch 39/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4902 - accuracy: 0.8275 - val_loss: 0.6306 - val_accuracy: 0.7837\n",
            "Epoch 40/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4761 - accuracy: 0.8320 - val_loss: 0.6277 - val_accuracy: 0.7860\n",
            "Epoch 41/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4704 - accuracy: 0.8326 - val_loss: 0.6245 - val_accuracy: 0.7874\n",
            "Epoch 42/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4590 - accuracy: 0.8383 - val_loss: 0.6316 - val_accuracy: 0.7871\n",
            "Epoch 43/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.4510 - accuracy: 0.8409 - val_loss: 0.6402 - val_accuracy: 0.7847\n",
            "Epoch 44/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.4453 - accuracy: 0.8420 - val_loss: 0.6229 - val_accuracy: 0.7862\n",
            "Epoch 45/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.4328 - accuracy: 0.8486 - val_loss: 0.6282 - val_accuracy: 0.7856\n",
            "Epoch 46/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4283 - accuracy: 0.8498 - val_loss: 0.6229 - val_accuracy: 0.7884\n",
            "Epoch 47/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4171 - accuracy: 0.8514 - val_loss: 0.6272 - val_accuracy: 0.7853\n",
            "Epoch 48/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.4127 - accuracy: 0.8535 - val_loss: 0.6253 - val_accuracy: 0.7897\n",
            "Epoch 49/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.4016 - accuracy: 0.8586 - val_loss: 0.6308 - val_accuracy: 0.7874\n",
            "Epoch 50/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3952 - accuracy: 0.8585 - val_loss: 0.6285 - val_accuracy: 0.7899\n",
            "Epoch 51/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3887 - accuracy: 0.8628 - val_loss: 0.6218 - val_accuracy: 0.7849\n",
            "Epoch 52/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3819 - accuracy: 0.8632 - val_loss: 0.6266 - val_accuracy: 0.7868\n",
            "Epoch 53/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3743 - accuracy: 0.8672 - val_loss: 0.6195 - val_accuracy: 0.7939\n",
            "Epoch 54/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3691 - accuracy: 0.8668 - val_loss: 0.6245 - val_accuracy: 0.7907\n",
            "Epoch 55/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3646 - accuracy: 0.8702 - val_loss: 0.6265 - val_accuracy: 0.7925\n",
            "Epoch 56/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3523 - accuracy: 0.8740 - val_loss: 0.6272 - val_accuracy: 0.7907\n",
            "Epoch 57/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3490 - accuracy: 0.8762 - val_loss: 0.6178 - val_accuracy: 0.7956\n",
            "Epoch 58/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3428 - accuracy: 0.8756 - val_loss: 0.6291 - val_accuracy: 0.7930\n",
            "Epoch 59/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3373 - accuracy: 0.8791 - val_loss: 0.6309 - val_accuracy: 0.7925\n",
            "Epoch 60/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3348 - accuracy: 0.8803 - val_loss: 0.6333 - val_accuracy: 0.7968\n",
            "Epoch 61/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3283 - accuracy: 0.8837 - val_loss: 0.6304 - val_accuracy: 0.7949\n",
            "Epoch 62/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3201 - accuracy: 0.8860 - val_loss: 0.6370 - val_accuracy: 0.7948\n",
            "Epoch 63/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3166 - accuracy: 0.8854 - val_loss: 0.6268 - val_accuracy: 0.7948\n",
            "Epoch 64/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.3056 - accuracy: 0.8900 - val_loss: 0.6427 - val_accuracy: 0.7941\n",
            "Epoch 65/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.3051 - accuracy: 0.8909 - val_loss: 0.6382 - val_accuracy: 0.7964\n",
            "Epoch 66/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2979 - accuracy: 0.8943 - val_loss: 0.6485 - val_accuracy: 0.7980\n",
            "Epoch 67/80\n",
            "500/500 [==============================] - 6s 13ms/step - loss: 0.2952 - accuracy: 0.8954 - val_loss: 0.6489 - val_accuracy: 0.7936\n",
            "Epoch 68/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2922 - accuracy: 0.8951 - val_loss: 0.6366 - val_accuracy: 0.7966\n",
            "Epoch 69/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2849 - accuracy: 0.8975 - val_loss: 0.6498 - val_accuracy: 0.7960\n",
            "Epoch 70/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2799 - accuracy: 0.8998 - val_loss: 0.6461 - val_accuracy: 0.7930\n",
            "Epoch 71/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2761 - accuracy: 0.9010 - val_loss: 0.6355 - val_accuracy: 0.7958\n",
            "Epoch 72/80\n",
            "500/500 [==============================] - 5s 11ms/step - loss: 0.2774 - accuracy: 0.9007 - val_loss: 0.6355 - val_accuracy: 0.7990\n",
            "Epoch 73/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2634 - accuracy: 0.9059 - val_loss: 0.6443 - val_accuracy: 0.7985\n",
            "Epoch 74/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2652 - accuracy: 0.9058 - val_loss: 0.6479 - val_accuracy: 0.7979\n",
            "Epoch 75/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2591 - accuracy: 0.9066 - val_loss: 0.6410 - val_accuracy: 0.7988\n",
            "Epoch 76/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2579 - accuracy: 0.9080 - val_loss: 0.6421 - val_accuracy: 0.7996\n",
            "Epoch 77/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2522 - accuracy: 0.9105 - val_loss: 0.6430 - val_accuracy: 0.7995\n",
            "Epoch 78/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2519 - accuracy: 0.9090 - val_loss: 0.6565 - val_accuracy: 0.7961\n",
            "Epoch 79/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2458 - accuracy: 0.9121 - val_loss: 0.6486 - val_accuracy: 0.8001\n",
            "Epoch 80/80\n",
            "500/500 [==============================] - 6s 12ms/step - loss: 0.2454 - accuracy: 0.9121 - val_loss: 0.6615 - val_accuracy: 0.7976\n",
            "Model success\n"
          ]
        }
      ],
      "source": [
        "path = os.getcwd() + '/models/h5files/'\n",
        "\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "# Fit neural network models to training data\n",
        "for model_ind, model in enumerate(models):  \n",
        "    history.append(\n",
        "      model.fit_generator(\n",
        "          datagen.flow(x_train, y_train_categorical, batch_size=batch_size),\n",
        "          steps_per_epoch=len(x_train)/batch_size,\n",
        "          epochs=epochs,\n",
        "          verbose=1,\n",
        "          validation_data = (x_test, y_test_categorical)))\n",
        "    \n",
        "    model.save_weights(path + prefix + '_' + model_names[model_ind] + \".h5\")\n",
        "    \n",
        "    print (\"Model success\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "id": "96cb20b2",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "96cb20b2",
        "outputId": "9858305d-d761-4de3-9659-501c66d777e8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CNN_Input_1 # of Parameters: 6684810\n",
            "\n",
            "\n",
            "CNN_Input_2 # of Parameters: 1250858\n",
            "\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Print the number of model parameters\n",
        "for model in models:\n",
        "    print(f'{model_names[models.index(model)]} # of Parameters:', model.count_params())\n",
        "    print('\\n')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "e22ddd99",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e22ddd99",
        "outputId": "3f9a0149-3612-4c14-edd9-f9febb67b02c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CNN_Input_1 Absolute Error: 0.167\n",
            "\n",
            "\n",
            "CNN_Input_2 Absolute Error: 0.202\n",
            "\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Print the absolute error\n",
        "for model in models:\n",
        "    # The absolute error is X, thus the accuracy is 1-X\n",
        "    predicted_x = model.predict(x_test)\n",
        "    residuals = np.argmax(predicted_x, 1)!=np.argmax(y_test_categorical, 1)\n",
        "\n",
        "    loss = sum(residuals)/len(residuals)\n",
        "    print(f'{model_names[models.index(model)]} Absolute Error:', round(loss, 3))\n",
        "    print('\\n')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get metrics for models on unseen data\n",
        "for model in models:\n",
        "    score = model.evaluate(x_test, y_test_categorical, verbose=0)\n",
        "    print(f'{model_names[models.index(model)]} Test loss:', round(score[0], 3))\n",
        "    print(f'{model_names[models.index(model)]} Test accuracy:', round(score[1], 3))\n",
        "    print('\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FRC-nrRU0Efm",
        "outputId": "a5f38f59-183b-4ed3-91fb-2f3fa225bcc6"
      },
      "id": "FRC-nrRU0Efm",
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CNN_Input_1 Test loss: 0.923\n",
            "CNN_Input_1 Test accuracy: 0.833\n",
            "\n",
            "\n",
            "CNN_Input_2 Test loss: 0.662\n",
            "CNN_Input_2 Test accuracy: 0.798\n",
            "\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "id": "e008eeff",
      "metadata": {
        "id": "e008eeff"
      },
      "outputs": [],
      "source": [
        "path = os.getcwd() + '/models/viz/'\n",
        "\n",
        "if not os.path.exists(path):\n",
        "    os.makedirs(path)\n",
        "\n",
        "# Visualize the CNN model architectures\n",
        "for i, model in enumerate(models):\n",
        "    plot_model(model, \n",
        "               path + prefix + '_' + model_names[i] + '.png', \n",
        "               show_shapes=True)\n",
        "    \n",
        "    ann_viz(model, \n",
        "            filename=path + prefix + '_' + model_names[i] + '.gv', \n",
        "            title='Visualisation of ' + model_names[i])"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Summarize models\n",
        "for i, model in enumerate(models):\n",
        "    model.summary()\n",
        "    print('\\n'*2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MZNSh3wce8Wi",
        "outputId": "11e813dc-545a-4286-f16c-51ff2a2b9989"
      },
      "id": "MZNSh3wce8Wi",
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 32, 32, 128)       3584      \n",
            "                                                                 \n",
            " activation (Activation)     (None, 32, 32, 128)       0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 30, 30, 128)       147584    \n",
            "                                                                 \n",
            " activation_1 (Activation)   (None, 30, 30, 128)       0         \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 15, 15, 128)      0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 15, 15, 128)       0         \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 15, 15, 256)       295168    \n",
            "                                                                 \n",
            " activation_2 (Activation)   (None, 15, 15, 256)       0         \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 13, 13, 256)       590080    \n",
            "                                                                 \n",
            " activation_3 (Activation)   (None, 13, 13, 256)       0         \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 6, 6, 256)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 6, 6, 256)         0         \n",
            "                                                                 \n",
            " conv2d_4 (Conv2D)           (None, 6, 6, 512)         1180160   \n",
            "                                                                 \n",
            " activation_4 (Activation)   (None, 6, 6, 512)         0         \n",
            "                                                                 \n",
            " conv2d_5 (Conv2D)           (None, 4, 4, 512)         2359808   \n",
            "                                                                 \n",
            " activation_5 (Activation)   (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 2, 2, 512)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_2 (Dropout)         (None, 2, 2, 512)         0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 2048)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1024)              2098176   \n",
            "                                                                 \n",
            " activation_6 (Activation)   (None, 1024)              0         \n",
            "                                                                 \n",
            " dropout_3 (Dropout)         (None, 1024)              0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 10)                10250     \n",
            "                                                                 \n",
            " activation_7 (Activation)   (None, 10)                0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 6,684,810\n",
            "Trainable params: 6,684,810\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "\n",
            "\n",
            "\n",
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_6 (Conv2D)           (None, 32, 32, 32)        896       \n",
            "                                                                 \n",
            " activation_8 (Activation)   (None, 32, 32, 32)        0         \n",
            "                                                                 \n",
            " conv2d_7 (Conv2D)           (None, 30, 30, 32)        9248      \n",
            "                                                                 \n",
            " activation_9 (Activation)   (None, 30, 30, 32)        0         \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 15, 15, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_4 (Dropout)         (None, 15, 15, 32)        0         \n",
            "                                                                 \n",
            " conv2d_8 (Conv2D)           (None, 15, 15, 64)        18496     \n",
            "                                                                 \n",
            " activation_10 (Activation)  (None, 15, 15, 64)        0         \n",
            "                                                                 \n",
            " conv2d_9 (Conv2D)           (None, 13, 13, 64)        36928     \n",
            "                                                                 \n",
            " activation_11 (Activation)  (None, 13, 13, 64)        0         \n",
            "                                                                 \n",
            " max_pooling2d_4 (MaxPooling  (None, 6, 6, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_5 (Dropout)         (None, 6, 6, 64)          0         \n",
            "                                                                 \n",
            " flatten_1 (Flatten)         (None, 2304)              0         \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 512)               1180160   \n",
            "                                                                 \n",
            " activation_12 (Activation)  (None, 512)               0         \n",
            "                                                                 \n",
            " dropout_6 (Dropout)         (None, 512)               0         \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 10)                5130      \n",
            "                                                                 \n",
            " activation_13 (Activation)  (None, 10)                0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,250,858\n",
            "Trainable params: 1,250,858\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "\n",
            "\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3.1. VGG-16 Intermediate Dataset"
      ],
      "metadata": {
        "id": "ZQKb53OFI0-7"
      },
      "id": "ZQKb53OFI0-7"
    },
    {
      "cell_type": "code",
      "source": [
        "# Upload h5 files with VGG-16's weights and unzip\n",
        "!unzip model_weights_cifarvgg.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cfdzTjvN_VI9",
        "outputId": "13a73203-aef3-424e-e38a-fc3ff2737545"
      },
      "id": "cfdzTjvN_VI9",
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Archive:  model_weights_cifarvgg.zip\n",
            "  inflating: model_weights_cifarvgg/cifar100vgg.h5  \n",
            "  inflating: model_weights_cifarvgg/cifar10vgg.h5  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Remove zip file with the weights\n",
        "!rm model_weights_cifarvgg.zip"
      ],
      "metadata": {
        "id": "T_trPuB_7Xnc"
      },
      "id": "T_trPuB_7Xnc",
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# The weights for VGG-16 trained on CIFAR are available online\n",
        "# Therefore, this model does not need to be retrained\n",
        "# The pretrained weights can be found on https://github.com/geifmany/cifar-vgg\n",
        "vgg_16 = cifar10vgg(train=False)"
      ],
      "metadata": {
        "id": "E1zxGroBABOL"
      },
      "id": "E1zxGroBABOL",
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('VGG-16 # of Parameters:', vgg_16.model.count_params())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WDXXqhjTJCFX",
        "outputId": "02b0d4fd-3005-4f89-f00b-eb6598bf4aa7"
      },
      "id": "WDXXqhjTJCFX",
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "VGG-16 # of Parameters: 15001418\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The absolute error is X, thus the accuracy is 1-X\n",
        "predicted_x = vgg_16.predict(x_test, normalize=False)\n",
        "residuals = np.argmax(predicted_x, 1)!=np.argmax(y_test_categorical, 1)\n",
        "\n",
        "loss = sum(residuals)/len(residuals)\n",
        "print('VGG-16 Absolute Error:', round(loss, 3))\n",
        "# An absolute error of 0.064 represents an accuracy of 0.936"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EYGycnGFJB-t",
        "outputId": "2aa50ab7-25d3-404a-9d80-ce3608412f88"
      },
      "id": "EYGycnGFJB-t",
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "VGG-16 Absolute Error: 0.064\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Add VGG-16 to model list\n",
        "models.append(keras.models.clone_model(vgg_16.model))\n",
        "model_names.append('VGG_16')\n",
        "models[model_names.index('VGG_16')].set_weights(vgg_16.model.get_weights())"
      ],
      "metadata": {
        "id": "uCqeAfRNAsnR"
      },
      "id": "uCqeAfRNAsnR",
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# # Visualize VGG-16 model architectures\n",
        "# ann_viz(vgg_16.model, \n",
        "#         filename=path + prefix + '_VGG_16.gv',\n",
        "#         title='Visualization of VGG-16')"
      ],
      "metadata": {
        "id": "dH3QNUPlDabi"
      },
      "id": "dH3QNUPlDabi",
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Summarize VGG-16 model\n",
        "vgg_16.model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NInf8Bx-d6EU",
        "outputId": "5bb3ebf8-1f21-4017-d17f-d46950b00c70"
      },
      "id": "NInf8Bx-d6EU",
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_10 (Conv2D)          (None, 32, 32, 64)        1792      \n",
            "                                                                 \n",
            " activation_14 (Activation)  (None, 32, 32, 64)        0         \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 32, 32, 64)       256       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " dropout_7 (Dropout)         (None, 32, 32, 64)        0         \n",
            "                                                                 \n",
            " conv2d_11 (Conv2D)          (None, 32, 32, 64)        36928     \n",
            "                                                                 \n",
            " activation_15 (Activation)  (None, 32, 32, 64)        0         \n",
            "                                                                 \n",
            " batch_normalization_1 (Batc  (None, 32, 32, 64)       256       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_5 (MaxPooling  (None, 16, 16, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_12 (Conv2D)          (None, 16, 16, 128)       73856     \n",
            "                                                                 \n",
            " activation_16 (Activation)  (None, 16, 16, 128)       0         \n",
            "                                                                 \n",
            " batch_normalization_2 (Batc  (None, 16, 16, 128)      512       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " dropout_8 (Dropout)         (None, 16, 16, 128)       0         \n",
            "                                                                 \n",
            " conv2d_13 (Conv2D)          (None, 16, 16, 128)       147584    \n",
            "                                                                 \n",
            " activation_17 (Activation)  (None, 16, 16, 128)       0         \n",
            "                                                                 \n",
            " batch_normalization_3 (Batc  (None, 16, 16, 128)      512       \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_6 (MaxPooling  (None, 8, 8, 128)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_14 (Conv2D)          (None, 8, 8, 256)         295168    \n",
            "                                                                 \n",
            " activation_18 (Activation)  (None, 8, 8, 256)         0         \n",
            "                                                                 \n",
            " batch_normalization_4 (Batc  (None, 8, 8, 256)        1024      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " dropout_9 (Dropout)         (None, 8, 8, 256)         0         \n",
            "                                                                 \n",
            " conv2d_15 (Conv2D)          (None, 8, 8, 256)         590080    \n",
            "                                                                 \n",
            " activation_19 (Activation)  (None, 8, 8, 256)         0         \n",
            "                                                                 \n",
            " batch_normalization_5 (Batc  (None, 8, 8, 256)        1024      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " dropout_10 (Dropout)        (None, 8, 8, 256)         0         \n",
            "                                                                 \n",
            " conv2d_16 (Conv2D)          (None, 8, 8, 256)         590080    \n",
            "                                                                 \n",
            " activation_20 (Activation)  (None, 8, 8, 256)         0         \n",
            "                                                                 \n",
            " batch_normalization_6 (Batc  (None, 8, 8, 256)        1024      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_7 (MaxPooling  (None, 4, 4, 256)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_17 (Conv2D)          (None, 4, 4, 512)         1180160   \n",
            "                                                                 \n",
            " activation_21 (Activation)  (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            " batch_normalization_7 (Batc  (None, 4, 4, 512)        2048      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " dropout_11 (Dropout)        (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            " conv2d_18 (Conv2D)          (None, 4, 4, 512)         2359808   \n",
            "                                                                 \n",
            " activation_22 (Activation)  (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            " batch_normalization_8 (Batc  (None, 4, 4, 512)        2048      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " dropout_12 (Dropout)        (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            " conv2d_19 (Conv2D)          (None, 4, 4, 512)         2359808   \n",
            "                                                                 \n",
            " activation_23 (Activation)  (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            " batch_normalization_9 (Batc  (None, 4, 4, 512)        2048      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " max_pooling2d_8 (MaxPooling  (None, 2, 2, 512)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_20 (Conv2D)          (None, 2, 2, 512)         2359808   \n",
            "                                                                 \n",
            " activation_24 (Activation)  (None, 2, 2, 512)         0         \n",
            "                                                                 \n",
            " batch_normalization_10 (Bat  (None, 2, 2, 512)        2048      \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_13 (Dropout)        (None, 2, 2, 512)         0         \n",
            "                                                                 \n",
            " conv2d_21 (Conv2D)          (None, 2, 2, 512)         2359808   \n",
            "                                                                 \n",
            " activation_25 (Activation)  (None, 2, 2, 512)         0         \n",
            "                                                                 \n",
            " batch_normalization_11 (Bat  (None, 2, 2, 512)        2048      \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_14 (Dropout)        (None, 2, 2, 512)         0         \n",
            "                                                                 \n",
            " conv2d_22 (Conv2D)          (None, 2, 2, 512)         2359808   \n",
            "                                                                 \n",
            " activation_26 (Activation)  (None, 2, 2, 512)         0         \n",
            "                                                                 \n",
            " batch_normalization_12 (Bat  (None, 2, 2, 512)        2048      \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_9 (MaxPooling  (None, 1, 1, 512)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout_15 (Dropout)        (None, 1, 1, 512)         0         \n",
            "                                                                 \n",
            " flatten_2 (Flatten)         (None, 512)               0         \n",
            "                                                                 \n",
            " dense_4 (Dense)             (None, 512)               262656    \n",
            "                                                                 \n",
            " activation_27 (Activation)  (None, 512)               0         \n",
            "                                                                 \n",
            " batch_normalization_13 (Bat  (None, 512)              2048      \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_16 (Dropout)        (None, 512)               0         \n",
            "                                                                 \n",
            " dense_5 (Dense)             (None, 10)                5130      \n",
            "                                                                 \n",
            " activation_28 (Activation)  (None, 10)                0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 15,001,418\n",
            "Trainable params: 14,991,946\n",
            "Non-trainable params: 9,472\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Remove the Fully-connected layers"
      ],
      "metadata": {
        "id": "PqA28l6ZUW1W"
      },
      "id": "PqA28l6ZUW1W"
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "id": "421f9786",
      "metadata": {
        "id": "421f9786"
      },
      "outputs": [],
      "source": [
        "# Cut the models to remove everything after the flattening layer (remove fully-connected layers)\n",
        "# output_models = []\n",
        "for model in models:\n",
        "    cut_model(model)\n",
        "    # output_models.append(out)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "id": "47fe2a1e",
      "metadata": {
        "id": "47fe2a1e"
      },
      "outputs": [],
      "source": [
        "# Create output files\n",
        "now = datetime.datetime.now()\n",
        "prefix = now.strftime(\"%Y%m%d_%H%M\")\n",
        "create_output_files(x_train, \n",
        "                    x_test, \n",
        "                    y_train, \n",
        "                    y_test, \n",
        "                    prefix, \n",
        "                    suffix = \"_\" + treat_data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "id": "80855dfe",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 590
        },
        "id": "80855dfe",
        "outputId": "40e02ed0-08d4-4a9d-ae39-ef354da614a7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: CNN_Input_1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Plot history of model training\n",
        "index = 0\n",
        "print(f'Model: {model_names[index]}')\n",
        "\n",
        "plot_model_stats(history[index])"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "index = 1\n",
        "print(f'Model: {model_names[index]}')\n",
        "\n",
        "plot_model_stats(history[index])"
      ],
      "metadata": {
        "id": "yB4wq739QJOR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 590
        },
        "outputId": "f939e18c-8867-4964-e601-e0ca6a489398"
      },
      "id": "yB4wq739QJOR",
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: CNN_Input_2\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU1fn48c+TPSEhO2sIAWRfBIy4L7iCUNTar+JuW6WLtnZXvlVr7be/Lt/W2n5rbXFpte570aIsilrc2BUISyAEkrBlh+zLPL8/zgQmCxA1k5lknvfrNa/MvffMnWcmyX3uPefcc0RVMcYYE7rCAh2AMcaYwLJEYIwxIc4SgTHGhDhLBMYYE+IsERhjTIizRGCMMSHOEoEJCSKSJSIqIhGdKHuTiKzojriMCQaWCEzQEZF8EWkQkbQ269d5D+ZZgYmsVSzxIlIlIm8EOhZjvihLBCZY7QSublkQkYlAXODCaecKoB64UEQGdOcbd+aqxpjPwhKBCVb/BG7wWb4ReMK3gIgkisgTIlIsIrtE5C4RCfNuCxeR34lIiYjkAbM6eO2jIrJXRIpE5H9EJPwzxHcj8FfgU+C6Nvs+U0Q+EJEKESkQkZu862NF5PfeWCtFZIV33bkiUthmH/kicoH3+b0i8qKIPCkiB4GbRGSaiHzofY+9IvJnEYnyef14EVkqImUisl9E/ltEBohIjYik+pSb6v3+Ij/DZze9jCUCE6w+AvqKyFjvAXou8GSbMv8HJALDgXNwieOr3m23ALOBKUA28JU2r/0H0ASc4C1zEXBzZwITkaHAucBT3scNbba94Y0tHZgMrPdu/h1wEnA6kAL8BPB05j2BS4EXgSTvezYD3wfSgNOA84Fve2NIAJYBbwKDvJ/xLVXdB7wDXOmz3+uBZ1W1sZNxmN5IVe1hj6B6APnABcBdwK+AGcBSIAJQIAsIBxqAcT6v+wbwjvf528A3fbZd5H1tBNAfV60T67P9amC59/lNwIpjxHcXsN77fDDuoDzFuzwfeKWD14QBtcCJHWw7Fyjs6DvwPr8XeO8439n3Wt7X+1nWHaXcVcD73ufhwD5gWqB/5/YI7MPqGk0w+yfwHjCMNtVCuDPhSGCXz7pduAMzuDPhgjbbWgz1vnaviLSsC2tT/lhuAB4GUNUiEXkXV1W0DhgC7OjgNWlAzFG2dUar2ERkFHA/7monDpfg1ng3Hy0GgH8BfxWRYcBooFJVV37OmEwvYVVDJmip6i5co/ElwMttNpcAjbiDeotMoMj7fC/ugOi7rUUB7oogTVWTvI++qjr+eDGJyOnASGC+iOwTkX3AKcA13kbcAmBEBy8tAeqOsq0an4Zwb1VYepsybYcJfgjYAoxU1b7AfwMtWa0AV13WjqrWAc/j2jWuxyVbE+IsEZhg93XgPFWt9l2pqs24A9ovRSTBWzf/A460IzwPfFdEMkQkGbjT57V7gSXA70Wkr4iEicgIETmnE/HciKumGoer/58MTABigZm4+vsLRORKEYkQkVQRmayqHuAx4H4RGeRtzD5NRKKBbUCMiMzyNtreBUQfJ44E4CBQJSJjgG/5bHsdGCgi3xORaO/3c4rP9idw1V9zsERgsERggpyq7lDV1UfZ/B3c2XQesAJ4GnewBVd1sxj4BFhL+yuKG4AoIAcoxzXEDjxWLCISg2to/T9V3efz2Ik7oN6oqrtxVzA/BMpwDcUnenfxI2ADsMq77TdAmKpW4hp6H8Fd0VQDrXoRdeBHwDXAIe9nfa5lg6oeAi4EvoRrA8gFpvtsfx/XSL3We9VlQpyo2sQ0xoQaEXkbeFpVHwl0LCbwLBEYE2JE5GRc9dYQ79WDCXFWNWRMCBGRx3H3GHzPkoBpYVcExhgT4uyKwBhjQlyPu6EsLS1Ns7KyAh2GMcb0KGvWrClR1bb3pwA9MBFkZWWxevXRehMaY4zpiIgctauwVQ0ZY0yIs0RgjDEhzhKBMcaEuB7XRtCRxsZGCgsLqaurC3QofhUTE0NGRgaRkTaHiDGm6/SKRFBYWEhCQgJZWVn4DCvcq6gqpaWlFBYWMmzYsECHY4zpRXpF1VBdXR2pqam9NgkAiAipqam9/qrHGNP9ekUiAHp1EmgRCp/RGNP9ekXVkDHG9Baqytb9h1iRW8LBuibCBMJECBM4d3Q/JgxO7PL3tETQBSoqKnj66af59re//Zled8kll/D000+TlJTkp8iMMcGitqGZHcVVrNtdzrqCCtbvruBgXSNDUuIYmhJHZmof9lbU8l5uMfsP1ne4j6S4qJ6XCERkBvBH3CTZj6jqr9tsH4qbSCQdN1HHdap6vAk5gk5FRQV/+ctf2iWCpqYmIiKO/hUvWrTI36EZY/ykrrGZt7cc4GBtI2FhQri36raytpGKmgbKahoorWqgqKKWovJaSqsbDr82LT6aKZlJpPaJYndZDavyy/nXJ3tIiI7grJHpnD0qjbNHpTMwMRZVxaPgUSXMT9XDfksE3nlXH8TNlFQIrBKRhaqa41Psd8ATqvq4iJwH/Ao3j2qPcuedd7Jjxw4mT55MZGQkMTExJCcns2XLFrZt28Zll11GQUEBdXV13H777cybNw84MlxGVVUVM2fO5Mwzz+SDDz5g8ODB/Otf/yI2NjbAn8wY01ZlTSNPfryLv7+fT0lVx2fuIpAUG0lynygGJ8UyflBfMpLjGJoax+QhSQxOim3X5tfQ5CE8TAgPkzb7EsIFwvFfG6E/rwimAdtVNQ9ARJ4FLsVNDdhiHG6eWYDlwKtf9E1//tomcvYc/KK7aWXcoL787EtHn9f817/+NRs3bmT9+vW88847zJo1i40bNx7u5vnYY4+RkpJCbW0tJ598MldccQWpqamt9pGbm8szzzzDww8/zJVXXslLL73Edddd16WfwxhzdHWNzeTsPciOA1XsP1jH3so69h+so67RQ1REGFHhYYjAu9uKqWlo5uxR6dxy1jBGpMfjUcXjAUXpGxNJ39jIdgf044mKCFzfHX8mgsFAgc9yIXBKmzKfAF/GVR9dDiSISKqqlvoWEpF5wDyAzMxMvwXcVaZNm9aqr/+f/vQnXnnlFQAKCgrIzc1tlwiGDRvG5MmTATjppJPIz8/vtniNCTWNzR627jvEuoIKPi2oYENRJbkHqmj2HJmfJTkukv59Y4iLCqei1kNDk4fGZmXG+AHccvZwxg7sG8BP0LUC3Vj8I+DPInIT8B5u4u7mtoVUdQGwACA7O/uYM+kc68y9u/Tp0+fw83feeYdly5bx4YcfEhcXx7nnntvhvQDR0dGHn4eHh1NbW9stsRrTW6gqO4qreHdbCQVlNRw4VEfxoXpKqxsIFyE6MoyYiHAaPcqWvQepb/IAkNIniomDE7lwXH8mDE5kdP8EBiTGEBMZHuBP1H38mQiKgCE+yxnedYep6h7cFQEiEg9coaoVfozJLxISEjh0qONZ/yorK0lOTiYuLo4tW7bw0UcfdXN0xvQuqkpVfRNl1Q2UVjdQfKiej/PKeGvLfnaV1gCQEB1Bet9o+iVEM3ZgXzwepb7JQ11jM5EK154ylMmZSUwZkkRGcvv6+lDjz0SwChgpIsNwCWAucI1vARFJA8pU1QPMx/Ug6nFSU1M544wzmDBhArGxsfTv3//wthkzZvDXv/6VsWPHMnr0aE499dQARmpMz1V8qJ4X1xTy3Krd5HsP+C2iIsI4fUQqN581nPPG9GNwknW0+Cz8OmexiFwCPIDrPvqYqv5SRO4DVqvqQhH5Cq6nkOKqhm5V1Y6b4b2ys7O17cQ0mzdvZuzYsX75DMEmlD6rCR2qyp7KOjYUVrKxqJKC8hpiI8OJi4qgT3Q42w9UsTRnP00eZdqwFM4b04+0+GhS46NI7RPFCf3iiYsKdE13cBORNaqa3dE2v35zqroIWNRm3T0+z18EXvRnDMaY4FRZ08i7ucW8vXk/K7aXUFLl+tmHhwmDkmJoaPJQU99MdUMTSXFRfPWMLOZOy2REenyAI+99LIUaY/yqtqGZj3aWsqukmn0H69l/sI7dZTWsL6ig2aOk9IninFHpTMlMYuLgRMYO7Nuqobal1iLU6/H9yRKBMeYLKatuYGNRJeU1DcRHRxAfHUGf6Ag27alkac4BVmwvpq7R9dCJDBf6JcQwMDGGb54znPPG9GfykKRj9rm3BOB/lgiMMZ/JgUN1LN60n/dzS9hQVElRxdG7Og9OiuWq7CGcP7Y/4wb1JSUuirDPeKOV8T9LBMaY4yooq2Fpzn7e2LiX1bvKUYUhKbFMyUzihtOGMjEjkX4J0VTVN1Nd38ShuiaGpMQybmBfO6PvASwRGGNoaPKwZlc5jc0eYiLDiYkMo77Jw3vbilmas58t+9x9MmMGJPC980dxycQBjOyfEOCoTVexRNAFPu8w1AAPPPAA8+bNIy4uzg+RGXN0Ho/y8c4yFn6yhzc27qWiprFdmTCB7KwUfnrJWM4f24/h1mOnV7JE0AWONgx1ZzzwwANcd911lgiM39Q1NvPW5gO8vLaQ/NJq6ho91Dc1U13fTG1jM3FR4Vw4rj+zJg4kpU8UdY3uDlwFsocmk9wnKtAfwfiZJYIu4DsM9YUXXki/fv14/vnnqa+v5/LLL+fnP/851dXVXHnllRQWFtLc3Mzdd9/N/v372bNnD9OnTyctLY3ly5cH+qOYHiyvuIrV+eVuQUCATwsrWfjJHiprGxmYGMOUzCRv1U84sZHhnDgkiQvG9rObsUJc7/vtv3En7NvQtfscMBFm/vqom32HoV6yZAkvvvgiK1euRFWZM2cO7733HsXFxQwaNIh///vfgBuDKDExkfvvv5/ly5eTlpbWtTGbkKCqfLCjlEdX7OTtLQfabY+OCGPGhAF85aQMTh+R9pmHRjahofclggBbsmQJS5YsYcqUKQBUVVWRm5vLWWedxQ9/+EPuuOMOZs+ezVlnnRXgSE1P1NjsIa+4mpy9leTsOch/ckvYsu8QqX2iuP38kVw2ZTBREWF4vMMpJ/eJIj7a/s3NsfW+v5BjnLl3B1Vl/vz5fOMb32i3be3atSxatIi77rqL888/n3vuuaeDPZhQ5vEoJdX17KusY1+lmxxld1kN+SXV5JdWU1BWS0OzuzkrKiKM8YP68tuvTGLOiYNCathk07V6XyIIAN9hqC+++GLuvvturr32WuLj4ykqKiIyMpKmpiZSUlK47rrrSEpK4pFHHmn1WqsaCm0ej/LS2kL+d/FWDhxqPe5ibGQ4Q1PjGNkvgQvG9WfsgL6MG9SX4Wl9iAgP3KxWpvewRNAFfIehnjlzJtdccw2nnXYaAPHx8Tz55JNs376dH//4x4SFhREZGclDDz0EwLx585gxYwaDBg2yxuIQtW53Ofe+lsMnBRVMHpLEbeedwIC+MQxMjKV/YjTp8dF2U5bxK78OQ+0PNgx16HzW3qasuoHV+WVsL66i5FADJVWuCmhlfhnpCdHcOWMMl08ZbEMwGL8I2DDUxoS6j/JKeWVtEat2lZFXXH14fVxUOGnx0aQnRHPb9BP45rkjrFHXBIz95RnjBx/llfLAsm18lFdG35gITs5K4SsnZZA9NIVxg/raQd8ElV7z16iqvb4etadV44WCkqp63tq8n7LqRmoamqiqb2LTnoOs3Omqe+6ZPY5rTsm0Hj0mqPWKRBATE0NpaSmpqam9NhmoKqWlpcTExAQ6lJDn8Sjv7yjh2ZUFLMnZR2OzS9BhAn2iIkizBGB6mF6RCDIyMigsLKS4uDjQofhVTEwMGRkZgQ4jZOXuP8S/1u/h1fVFFJbXkhwXyQ2nZfFf2RkMTelDTGRYrz0RMb1br0gEkZGRDBs2LNBhmF7G41Fy9h7k3W3FvP7pXjbvPUiYwBknpPGTGWO4eHx/oiPsjN/0fL0iERjTVSprGnlry36Wby3m/e0llFW7CdUnD0ni3i+NY9akQaQnRAc4SmO6liUCE/JKq+pZkrOfNzbu44PtJTR5lPSEaM4dnc5ZI9M444Q0+iVY24zpvSwRmJBUWF7D4k37WbxpH6vzy/AoZKbE8fWzhjFzwkBOzEi0+n4TMiwRmJChqqzYXsKC9/L4T24JAKP7J3DbeSO5eHx/m1/XhCxLBKbXa2jy8MbGvfzt3Txy9h4kPSGaH100itmTBpGV1ifQ4RkTcH5NBCIyA/gjEA48oqq/brM9E3gcSPKWuVNVF/kzJhM6th+o4vnVBby0ppDS6gZGpPfht1dM4tIpg6y3jzE+/JYIRCQceBC4ECgEVonIQlXN8Sl2F/C8qj4kIuOARUCWv2IyvZeqUlRRy6eFlXxaWMnKnaWs3V1BRJhw/th+zD05k3NGpduAbsZ0wJ9XBNOA7aqaByAizwKXAr6JQIG+3ueJwB4/xmN6oaKKWp5duZsXVhey72AdAJHhwtiBfZk/cwxfnpph3T1N11CFAznQUA2RcRAVB1Hx7hEZC77tS421UF0CtWVQW37kUV8FEgZh4e5nwgAYfi7EJLZ+n6K1sHkhRPWBjJNh8NTWZbqYPxPBYKDAZ7kQOKVNmXuBJSLyHaAPcEFHOxKRecA8gMzMzC4P1PQsTc0e3tlazNMrd/PO1gMocO6odG6dPoJJGUmMGZhgVT/drbkJPE0Q2YlutiXbYdsbEJcK6WMgfbQ74H1WqnCwCPash5JtUJYHZTuhcjcMmgpTrocR091BtyXGPWth7ycQEQ3RCRCVAPH9oP/4I+V8VZdC3nLY/hbseAuq9ncci4S5fUXGQv1BaKzp/OcIi4ChZ8CoGS5ZbHgByndCWKT7TlFA3Hc1fT6Mu/SzflPHFejG4quBf6jq70XkNOCfIjJBVT2+hVR1AbAA3HwEAYjTBIHtB6p4YU0BL68tovhQPf0Sorl1+glcdfIQMpLjAh1ez1ZXCeufgcQMGHY2xPRtvV0VmhshIqr1+kP7YPVj7lFbDgMmQeapMGQaJA9zB/jIOHew2/YmrH8aCj5q//59B7uDs4QdeeBzhh0W4c6IY/q6n9UlsHc9VPsMK9OnH6QMd0lg53uQ8yr0zXAHzrI8yF8BDYc6/vwxie5zDzsH4lJg1weQ/z4Ub3bbY5Nh+HQ44XyIHwCN1dBQAw1V7gqh/tCR5zGJLsnFpbp9xaZ4fya770M97uHxuAS27U3YthgWz3efe9jZcPaPYMxsd5VRtBYKV0Phys+XMDvBbxPTeA/s96rqxd7l+QCq+iufMpuAGapa4F3OA05V1QNH229HE9OY3knVDfGwLOcAyzbvZ0NRJeFhwnlj+nFl9hDOHZ1OZChP1ajqDkBtD9otassBgdikY+8j51V4406o2ufWhUXAkFMh8xR3Bly8zR2w6iogcQikjYS00VBTAptedWetoy52Z6yFq6FoDTTVdvx+aaNg8jUw4Suu+qR4MxRvdQdqT5P3ANnsfvpqbnRn2nWV7hGdAIOmwMDJMGgy9Bvr1rVoqoeti2DtP2HH25AyzB3kh5/rkpSn2X139YegYhfsfBfy3oVKbyVGVDwMOQWyzoCss13VTEdXDF2pYjeER0NCf7/s/lgT0/gzEUQA24DzgSJgFXCNqm7yKfMG8Jyq/kNExgJvAYP1GEFZIuj9KmsaefT9nby4uoA9lXWIwJQhScyYMIDLpwRpnb/H4w6alQXuZ1gEhEe5s9yYJFf9ER7ZuX2pugNv/gpXlZF6gjsbHTAJwsJcdcWnz7qDXPFmSBh45KAYl+I9g1wFpbkuholXwqnfhAETW79HWR68eSfkLnH7nvV7aG6A7cvcY98GiO/vDt5pI90Zd1mei60k1x0Yp1wHJ98MqSOO7LupAfZvcFcLDTXu7LmxFgZnQ0Z267r07tBU734Px9PyndQfhP4TITzQFSZdKyCJwPvGlwAP4LqGPqaqvxSR+4DVqrrQ21PoYSAeVxH2E1Vdcqx9WiLovSprGnl0RR5/fz+fQ/VNTB+dzsyJAzlvTD/S4rvp4N/c5OqvwyJh5EXuwNtW3UFXLbFnnauf3vepO5trbjj6fiNiYOCJMPgkV2VQsQvKd0F5vntdVLy3zroPFG85UuURk+TOxMG9rt842P0ReBrdvkZeBKU7XDwluYBCn3TXwJiRDQf3uOqYxhrIOssd0A9scQmktty97/SfwrR57Q98TQ3tq4JaeLzVG73sYNmbBSwR+IMlgt6l2aN8nFfK6xv28tr6PRyqb2LmhAF89/yRjB14lCoPf6gthzWPw8qH4WChW5c+Bs76IYz/MqDuLHndk64+19PoyiRlugN8ynD3PDHTXdp7mt0BvrkBqg64pFG0xiWOplp3sE7OgqShroGxocpbVVEFyUNd42HWmW6/Vfsh7x3YsdwlneHnuobQ/uNaf4Y6b9VJYkbrs+6aMlj7BKx6xJ3tpo91Vyj9xsLYOZA42O9frwk8SwQm6Gw/cIjHP9jFGxv3UlLVQFxUOBeO6883zxnRPQmgpRpg53uQ/x/Y+oY7ax52NpzyLff8vd+5M+ekod7ugAfcAXzSVa43ysAp0Cf1s71vcxM01/ut0e+4VLu/asYEBZu83gSNTwsr+MvyHSzO2UdUeBjnj+3H7EmDmD66H7FRn7MxbvdH8O5v3Fl9eLSrzgiPAgk/0mcboKkOGuvcGfnBvXDIe9tK/ACYcAWc8o3W9ejjv+waHD/+q+sJMvlaGHlh5+v6OxIeEdjqFEsCpgOWCIzfHaxrZFnOfl5eW8SK7SUkxERw2/QTuOn0LFI7W/dfvM31Dx8wyfX7Blcvv/RnsOll12Daf4I7225qcFUs6gFtdmfBqq7BMDLW1bunDIfM09wVQOoJHR8gw8Jg7Gz3MKYXs0Rg/KLZo7y5cR+vrCvivW3FNDR7GJwUyx0zxnDdqZkkxLQ5q25ucvXbbata6iph+f+DlQuOdClMGOjq73d94M74z7kTzvhu4KpbjOnhLBGYLtXsUV7/dA9/fCuXvOJqBvSN4frThjJr0kCmDElqPcxz8TZ312beu66evqUhc+SFrjfMob2w5C7X2Jr9VdewuX+TazDdvwnGXw7n3+0aR40xn5slAtMlVN0VwO+WbGVHcTWj+yfw0LVTuXj8gPYDvVXshjfnw5bX3XJyljuoJw91SeGjh+CDP7ltg6bA1c+4rpLgGmmNMV3KEoH5wgrKarj7Xxt5Z2sxo/rH8+A1U5k5oYME0FgHH/wf/Of3bnn6T2HSlS4RtDjrh64bZd477k7TsXP8f0enMSHOEoH53BqbPTy6YicPLNtGuAj3zB7HjadnEe6bACoLXa+eXR9A7lLX4Dt2Dlz8/yBpSMc7jk6AsV/qng9hjLFEYD67Zo/y2id7+NNbueSVVHPlqDB+OiyXxO1/hrVF3pEoG92t/bVl7kVR8W6Mlzl/hBHnBfYDGGNasURgOq3Zo7y5Koc33v0P0RU7mZdQyoxB20ja/Qnsxg1/MPgkNzxDWLgbbyd9tOum2X+CDUdgTJCy/0xzdKpu7PaCj6nctoL6nR8yy1PMLIAo0MYIJHoCnHe3G+o3bWSgIzbGfA6WCEx7zU1uaOIVf4D9GwGo1RQ+DRvDoPE3MW5iNmHpI5GkzC92l60xJihYIjBH1JS5BPD+n6B8J9V9R/BQ9K28XDma00+azF2zxpIUd5TRKI0xPZYlglC3Z70bT2f7MjeOPUpV6iT+knQ3D+0bzZCUeH79tQmcPSo90JEaY/zEEkEo++RZeOUbqIRRmz6F3BO+ycsHx/L47lT6JcRw32UjuSp7CFERITwLmDEhwBJBqNq2BH312+RET+bmmtvYu9vN+dsvIZr5M4dxw2lZn380UGNMj2KJIBQVrESfv4FcyeKm2u8x6+RRTB2azJQhSWQkx7YeD8gY0+tZIujNasrgjTvc4G0Z2ZAxDWKT8Tw9lz3NSdziuZO/fv0cThqaEuhIjTEBZImgtypcAy/c6KY57DfOjfHjaQKgjGRu4af88eaLmDwkKcCBGmMCzRJBb6Pq5t1d/N9u3P6vLUYHTWFD/n5WfvA2+3PX8KGcyP/ePIcJgxMDHa0xJghYIugtGmth8+uw5h+wawWMmgGXPcSLm2v463Pvsf1AFVERyVw07lr+cP5IRvZPCHTExpggYYmgJ1J18/OW50PFLshfARtecLN5JQ2FGb+BafN4alUBP31lI5MyEvnVlydyycSBJMbancDGmNYsEfQ0m1+Dhd89MqonuAnbx82BKddD1lkQFsbCT/Zw16sbOW9MP/52/UlEhtu9AMaYjlki6EmK1sBLt7jB3c76oZvQJXmom4jdZ77et7fs5wfPrefkrBT+cu1USwLGmGOyRNBTVBbCM1dDfDpc97L72YEVuSV868m1jB3Yl0dvzCYm0m4KM8Ycm19PFUVkhohsFZHtInJnB9v/ICLrvY9tIlLhz3h6rPoqeGYuNNTA1c91mATqGpv5n9dzuP6xj8lMieMfXz2ZhBhrDzDGHJ/frghEJBx4ELgQKARWichCVc1pKaOq3/cp/x1gir/i6bGam+DlebB/E1zzAvQf167Iml3l/PiFT8grqeb6U4dy58wx9Im2iz1jTOf482gxDdiuqnkAIvIscCmQc5TyVwM/82M8Pc/BvfDS12HX+zDzf2HkBa02NzZ7eGDZNh56ZwcDE2N56uZTOOOEtAAFa4zpqfyZCAYDBT7LhcApHRUUkaHAMODto2yfB8wDyMzM7Noog9WO5fDSzdBYA5cvgBOvarW5sLyG7z6zjrW7K7gyO4O7Z4+zqiBjzOcSLPUHc4EXVbW5o42qugBYAJCdna3dGVi3K9sJax+HFQ+4+X7/63HoN6ZVkTc27OWOlz7Fo/Cnq6cw58RBAQrWGNMb+DMRFAFDfJYzvOs6Mhe41Y+xBLeitbDxJdi2GEpz3boTr4FZv2vVLVRV+f2Sbfx5+XZOzEjkT1dPYWhqn6Ps1BhjOsefiWAVMFJEhuESwFzgmraFRGQMkAx86MdYglf+CnjiUpBwyDoTTr4ZRl4IqSNaFWv2KHe9upFnVu7mquwh/OKyCTZhjDGmS/gtEahqk4jcBiwGwoHHVHWTiNwHrFbVhd6ic4FnVbV3V/l0pCwPnrvO3RD2tcUQ1/Fw0HWNzXzv2fW8uWkft04fwY8uGm1zBhhjuoxf2whUdRGwqM26e3jgZl8AABhrSURBVNos3+vPGIJWXSU87W0AvvrZoyaBqvombnl8NR/mlXL37HF8/cxh3RikMSYUBEtjcWhpboIXbnJXBDf8q101UIuahia+9o9VrNlVzh+uOpHLp2R0b5zGmJDQqUpmEXlZRGaJiFVKf1Gq8OYdsONtmP0H1y7QgbrGZm5+fDWr88v4w1WTLQkYY/ymswf2v+AaenNF5NciMtqPMfVu7/4GVj0Cp38Hpt7QYZG6xmZuecJVB/3uv0607qHGGL/qVCJQ1WWqei0wFcgHlonIByLyVRGxu5g66+O/wTu/gsnXwoW/6LDIwbpGvvXkGv6TW8JvvjyJL0+1KwFjjH91uo1ARFKB64DrgXXAU8CZwI3Auf4Irlf59Hl44ycwZjZ86U/QQa+fj/NK+cHzn7C3spZfXj6BK08e0sGOjDGma3UqEYjIK8Bo4J/Al1R1r3fTcyKy2l/B9RrblsAr33STxlzxKIS3/trrm5q5f+k2FryXR2ZKHC9+63SmZiYHKFhjTKjp7BXBn1R1eUcbVDW7C+PpffZtcD2EBkyAuU9DZEyrzTUNTVzz8MesL6jg6mmZ3DVrrI0caozpVp1tLB4nIkktCyKSLCLf9lNMvcehffD0XIhNgmueh5i+rTarKj9+4VM+LazgwWum8qsvT7QkYIzpdp1NBLeo6uFJY1S1HLjFPyH1Eo21bkax2nJ3w1jCgHZF/vLODv69YS93zBjDrEkDAxCkMcZ0vmooXESkZRgI76QzUf4Lq4fzeFybwJ51MPcpGDipXZG3t+znd0u2MufEQcw7e3gAgjTGGKezieBNXMPw37zL3/CuM22pwtK7IedV10V0zKx2RXYUV3H7M+sZN7Avv7liko0bZIwJqM4mgjtwB/9veZeXAo/4JaKeTBWW3AUf/hmmfcPdNNbGnopavvr3VURGhPG3608iNsomlzfGBFanEoGqeoCHvA/TkVZJYB7M/E27ewUKy2u4+uGPqKhu5ImvTyMjOS5AwRpjzBGdvY9gJPArYBxwuP+jqlrlNnSQBH7bLgkUlLkkUFnbyJM3n8KJQ5KOsjNjjOlene019Hfc1UATMB14AnjSX0H1OKseOW4SmLvgIw7WNvKUJQFjTJDpbCKIVdW3AFHVXd45BNq3goaiykJYdi8Mn95hEmhq9vCtp9ZQVd/E07ecyqQMSwLGmODS2cbieu8Q1LneWceKgHj/hdVDqMK/fwjqgS890OH4QY+9v5ONRQf5y7VTmTA4MQBBGmPMsXX2iuB2IA74LnASbvC5G/0VVI+x6RXY9iZM/ykkZ7XbvLu0hvuXbuOCsf2ZOaH9DWXGGBMMjntF4L157CpV/RFQBXzV71H1BDVlbjTRQVPglG+226yq/PcrG4gIC+MXl423ewWMMUHruFcEqtqMG27a+Fpyt0sGc/6v3WiiAC+tLWLF9hLumDmGgYmxAQjQGGM6p7NtBOtEZCHwAlDdslJVX/ZLVMEufwWsfxLO/AEMmNhuc0lVPf/z7xyyhyZz7bTMAARojDGd19lEEAOUAuf5rFMg9BJBcxMs+gkkZsI5P+mwyM9fy6G6volffXkiYWFWJWSMCW6dvbPY2gVarH4UDmyCq56EyPZVPktz9vPaJ3v4wYWjGNk/IQABGmPMZ9PZO4v/jrsCaEVVv9blEQWz6hJY/kt3z8CY2e02H6xr5K5XNzBmQALfPGdEAAI0xpjPrrNVQ6/7PI8BLgf2dH04Qe6tn0NDdYc3jgH8atEWig/Vs+D6bKIiOtsz1xhjAquzVUMv+S6LyDPAiuO9TkRmAH8EwoFHVPXXHZS5ErgXd8Xxiape05mYul3RGlj7TzjtVkgf1W7zhztKeWblbuadPdyGkDDG9Cifd17EkUC/YxXw3n/wIHAhUAisEpGFqprjU2YkMB84Q1XLReSY+wwYT7NrII7vB+fc0W5zbUMz81/+lKGpcXz/gvZJwhhjglln2wgO0bqNYB9ujoJjmQZsV9U87z6eBS4FcnzK3AI86J36ElU90Mm4u9dHD0HRarh8Qbt5hwEeXL6d/NIanr7lFJtfwBjT43S2aujzdH8ZDBT4LBcCp7QpMwpARN7HVR/dq6rtZj4TkXnAPIDMzG7ul39gC7x1H4yeBZOubLc5v6SaBe/lcfmUwZw+Iq17YzPGmC7QqRZNEblcRBJ9lpNE5LIueP8IXDXTucDVwMMi0q6CXVUXqGq2qmanp6d3wdt2UnMjvPINiI4/6qByv3g9h8hwYf7MMd0XlzHGdKHOdm35mapWtiyoagXws+O8pggY4rOc4V3nqxBYqKqNqroT2IZLDMHhP/fD3vUw+w+ufaCNt7fs560tB7j9gpH06xvTwQ6MMSb4dTYRdFTueNVKq4CRIjJMRKKAucDCNmVexV0NICJpuKqivE7G5F971sF7v4WJV8K4S9ttrm9q5r7Xchie3oebTh8WgACNMaZrdDYRrBaR+0VkhPdxP7DmWC9Q1SbgNmAxsBl4XlU3ich9IjLHW2wxUCoiOcBy4MeqWvr5PkoXUoWF34E+6XDJbzss8sh/dpJfWsO9Xxpv9wwYY3q0znYf/Q5wN/AcrvfQUuDW471IVRcBi9qsu8fnuQI/8D6CR+Fq2LfBjSwam9xu897KWv789nYuHt+fs0d1Y5uFMcb4QWd7DVUDd/o5luCx7p8QGQfjL+9w8/8u3kqzKnfNGtfNgRljTNfrbK+hpb69eUQkWUQW+y+sAGqoho0vuyQQ3b7X7IbCSl5eW8RXz8hiSEpcAAI0xpiu1dnK7TRvTyEAvDeABeddwF/U5teg4RBMvrbdJlXlf/6dQ0qfKG6dfkIAgjPGmK7X2UTgEZHDd3KJSBYdjEbaK6x7ElKGw9DT221amrOfj3eW8f0LRtI3JjIAwRljTNfrbGPxT4EVIvIuIMBZeO/07VXKdkL+f+C8u9rdPNbQ5OFXb2xhRHofrrZZx4wxvUhnG4vfFJFs3MF/Ha7/f60/AwuI9U8DAie2HwD1qY93sbOkmsduyiYi3LqLGmN6j84OOnczcDvu7uD1wKnAh7SeurJn8zS7RDDiPEgc3GpTVX0Tf3wrlzNOSGX66N7ZNGKMCV2dPbW9HTgZ2KWq04EpQMWxX9LD5L0DBwthynXtNj2/qoCKmkZ+dNFopIPxhowxpifrbCKoU9U6ABGJVtUtwGj/hRUA65+GmCQYfUmr1U3NHh5dsZOTs5KZktn+5jJjjOnpOttYXOi9j+BVYKmIlAO7/BdWN2tuhNwlMG4ORLYePO7NTfsoqqjlni/ZzWPGmN6ps43FLbfY3isiy4FEoN28AT1WwUqoPwgjL261WlV5+D87yUqN44Kx/QMUnDHG+NdnnqpSVd/1RyABlbsEwiJg+LmtVq/eVc4nBRX84rIJhIdZ24AxpneyfpAA25dB5mntpqFc8F4eyXGRfGVqRoACM8YY/7NEUFkE+zfCCRe0Wr2zpJplm/dz3alDbR5iY0yvZolg+zL3c+RFrVY/uiKPyLAwbjgtq/tjMsaYbmSJYPtS6DsY+o09vKqmoYmX1xZx6eRBpCdEBzA4Y4zxv9BOBE0NsOMdGHlhq7GF3t5ygJqGZi6fOvjorzXGmF4itBNBwcduyOkTLmy1+vVP9pKeEM0pw1IDFJgxxnSf0E4EuUsgLBKGn3N41aG6RpZvPcCsiQOty6gxJiSEdiLYvgyGntZqJrJlm/dT3+Rh9qSBAQzMGGO6T+gmgspCOJDTYbXQwMQYptq4QsaYEBG6iSB3qfvp0220sqaR93KLmT1pIGFWLWSMCRGhmwh2vue6jaYfGUR1cc4+GpuV2ZMGBTAwY4zpXqGbCPashcEnteo2+tone8hMiWNSRmIAAzPGmO7l10QgIjNEZKuIbBeROzvYfpOIFIvIeu/jZn/Gc1hNGZTnw+Cph1eVVtXzwY5SZk8aaJPPGGNCymcefbSzRCQceBC4ECgEVonIQlXNaVP0OVW9zV9xdGjPWvdz0JFE8OamfTR7rFrIGBN6/HlFMA3Yrqp5qtoAPAtc6sf367w969zPQZMPr3pz4z6Gp/dh7MCEo7zIGGN6J38mgsFAgc9yoXddW1eIyKci8qKIDPFjPEcUrYPUEyDGtQU0NHlYlV/G2SPTrVrIGBNyAt1Y/BqQpaqTgKXA4x0VEpF5IrJaRFYXFxd/8Xfds7ZVtdDGPZXUNXqYNizli+/bGGN6GH8mgiLA9ww/w7vuMFUtVdV67+IjwEkd7UhVF6hqtqpmp6enf7GoDu6FQ3tbNRSv2lkGwMlZlgiMMaHHn4lgFTBSRIaJSBQwF1joW0BEfMdxmANs9mM8zuH2AZ9EkF/G8LQ+NuS0MSYk+a3XkKo2ichtwGIgHHhMVTeJyH3AalVdCHxXROYATUAZcJO/4jlsz1qQcBgwEQCPR1mVX86M8QP8/tbGGBOM/JYIAFR1EbCozbp7fJ7PB+b7M4Z2ita6SWii4gDIPVBFZW0jJ1v7gDEmRAW6sbh7qXobiqccXrVyZykAp1giMMaEqNBKBOX5UFveqqF4ZX45A/rGkJEcG7i4jDEmgEIrERxuKHZXBKrKqp1lnDwsxe4fMMaErBBLBGshPAr6jQegsLyWfQfr7P4BY0xIC61EULTO9RaKiALgY+/9A9Ps/gFjTAgLnUTgaYa961vfP7CzjMTYSEb2iw9gYMYYE1ihkwhKt0NDVes7ivPLODkr2WYjM8aEtNBJBEUtQ0+7huLiQ/XklVRb+4AxJuSFTiIQgYEnQtoowF0NgI0vZIwxfr2zOKicONc9vNbsKicmMowJg21aSmNMaAudK4I2isprGZIcR2R4yH4FxhgDhHAiKKmqJy3eRhs1xpjQTgQ27LQxxoRyImggLT4q0GEYY0zAhWQiqGtspqq+yaqGjDGGEE0ExYfc7JjplgiMMSY0E0FJlUsEqVY1ZIwxoZkISqsaAKxqyBhjCNFE0HJFYL2GjDEmxBNBah+rGjLGmBBNBA0kxEQQExke6FCMMSbgQjIRFFfVW48hY4zxCslEUHLIhpcwxpgWIZkISqsbrOuoMcZ4hWQisAHnjDHmCL8mAhGZISJbRWS7iNx5jHJXiIiKSLY/4wFobPZQUdNoicAYY7z8lghEJBx4EJgJjAOuFpFxHZRLAG4HPvZXLL4O30yWYFVDxhgD/r0imAZsV9U8VW0AngUu7aDcL4DfAHV+jOWwwzeT2RWBMcYA/k0Eg4ECn+VC77rDRGQqMERV/32sHYnIPBFZLSKri4uLv1BQxZYIjDGmlYA1FotIGHA/8MPjlVXVBaqararZ6enpX+h9j4wzZFVDxhgD/k0ERcAQn+UM77oWCcAE4B0RyQdOBRb6u8HYqoaMMaY1fyaCVcBIERkmIlHAXGBhy0ZVrVTVNFXNUtUs4CNgjqqu9mNMlByqJzYynD7REf58G2OM6TH8lghUtQm4DVgMbAaeV9VNInKfiMzx1/sej5ur2KqFjDGmhV9Pi1V1EbCozbp7jlL2XH/G0sLNVWzVQsYY0yLk7iy2u4qNMaY1SwTGGBPiQioRNHuUsuoG6zpqjDE+QioRlNc04FHrOmqMMb5CKhHYPQTGGNNeaCWCQ3ZXsTHGtBVaiaDliiDBrgiMMaZFaCYCqxoyxpjDQiwRNBAVHkbfGBtewhhjWoRYIqgnNT4KEQl0KMYYEzRCLhFYtZAxxrQWgonAegwZY4yv0EoEh2zAOWOMaStkEoGqUlpdb11HjTGmjZBJBAdrm2hsVrsiMMaYNkImERyZtN7aCIwxxlfIJAK7mcwYYzpmicAYY0Jc6CSCQ1Y1ZIwxHQmZRDAoKZaLxvUnOc4SgTHG+AqZQXcuGj+Ai8YPCHQYxhgTdELmisAYY0zHLBEYY0yIs0RgjDEhzhKBMcaEOL8mAhGZISJbRWS7iNzZwfZvisgGEVkvIitEZJw/4zHGGNOe3xKBiIQDDwIzgXHA1R0c6J9W1YmqOhn4LXC/v+IxxhjTMX9eEUwDtqtqnqo2AM8Cl/oWUNWDPot9APVjPMYYYzrgz/sIBgMFPsuFwCltC4nIrcAPgCjgvI52JCLzgHkAmZmZXR6oMcaEsoDfUKaqDwIPisg1wF3AjR2UWQAsABCRYhHZ9TnfLg0o+byx+lmwxhascUHwxhascUHwxhascUHviW3o0Tb4MxEUAUN8ljO8647mWeCh4+1UVdM/b0AislpVsz/v6/0pWGML1rggeGML1rggeGML1rggNGLzZxvBKmCkiAwTkShgLrDQt4CIjPRZnAXk+jEeY4wxHfDbFYGqNonIbcBiIBx4TFU3ich9wGpVXQjcJiIXAI1AOR1UCxljjPEvv7YRqOoiYFGbdff4PL/dn+/fgQXd/H6fRbDGFqxxQfDGFqxxQfDGFqxxQQjEJqrWY9MYY0KZDTFhjDEhzhKBMcaEuJBJBMcb96ibY3lMRA6IyEafdSkislREcr0/kwMQ1xARWS4iOSKySURuD4bYRCRGRFaKyCfeuH7uXT9MRD72/k6f8/ZOCwgRCReRdSLyerDEJiL5PmN5rfauC/jfmTeOJBF5UUS2iMhmETkt0LGJyGjvd9XyOCgi3wt0XD7xfd/7979RRJ7x/l90yd9ZSCSCTo571J3+Acxos+5O4C1VHQm85V3ubk3AD1V1HHAqcKv3ewp0bPXAeap6IjAZmCEipwK/Af6gqifgep19vZvj8nU7sNlnOVhim66qk336mgf6d9nij8CbqjoGOBH33QU0NlXd6v2uJgMnATXAK4GOC0BEBgPfBbJVdQKuJ+ZcuurvTFV7/QM4DVjsszwfmB/gmLKAjT7LW4GB3ucDga1B8L39C7gwmGID4oC1uOFKSoCIjn7H3RxTBu4AcR7wOiDBEBuQD6S1WRfw3yWQCOzE21klmGLzieUi4P1giYsjQ/ak4Hp7vg5c3FV/ZyFxRUDH4x4NDlAsR9NfVfd6n+8D+gcyGBHJAqYAHxMEsXmrXtYDB4ClwA6gQlWbvEUC+Tt9APgJ4PEupxIcsSmwRETWeMfrgiD4XQLDgGLg797qtEdEpE+QxNZiLvCM93nA41LVIuB3wG5gL1AJrKGL/s5CJRH0KOrSe8D69YpIPPAS8D1tPUJswGJT1WZ1l+wZuJFtx3R3DB0RkdnAAVVdE+hYOnCmqk7FVYneKiJn+24M4N9ZBDAVeEhVpwDVtKluCeT/gLeefQ7wQtttgYrL2y5xKS6JDsKN1ty2evlzC5VE8FnHPQqE/SIyEMD780AgghCRSFwSeEpVXw6m2ABUtQJYjrsMThKRlpsiA/U7PQOYIyL5uPGyzsPVfwc8Nu9ZJKp6AFfXPY3g+F0WAoWq+rF3+UVcYgiG2MAlzrWqut+7HAxxXQDsVNViVW0EXsb97XXJ31moJILjjnsUBBZyZIiNG3H1891KRAR4FNisqr6TBAU0NhFJF5Ek7/NYXLvFZlxC+Eqg4gJQ1fmqmqGqWbi/q7dV9dpAxyYifUQkoeU5rs57I0Hwd6aq+4ACERntXXU+kBMMsXldzZFqIQiOuHYDp4pInPf/tOU765q/s0A1xgSgseUSYBuubvmnAY7lGVw9XyPu7OjruHrlt3AD7y0DUgIQ15m4y95PgfXexyWBjg2YBKzzxrURuMe7fjiwEtiOu4yPDvDv9Vzg9WCIzfv+n3gfm1r+5gP9u/SJbzKw2vs7fRVIDobYcFUupUCiz7qAx+WN4+fAFu//wD+B6K76O7MhJowxJsSFStWQMcaYo7BEYIwxIc4SgTHGhDhLBMYYE+IsERhjTIizRGBMNxKRc1tGKDUmWFgiMMaYEGeJwJgOiMh13jkQ1ovI37yD3lWJyB+8Y8K/JSLp3rKTReQjEflURF5pGa9eRE4QkWXeeRTWisgI7+7jfcbif8p7p6gxAWOJwJg2RGQscBVwhrqB7pqBa3F3na5W1fHAu8DPvC95ArhDVScBG3zWPwU8qG4ehdNxd5ODG9X1e7i5MYbjxowxJmAijl/EmJBzPm5iklXek/VY3EBjHuA5b5kngZdFJBFIUtV3vesfB17wjvMzWFVfAVDVOgDv/laqaqF3eT1ubooV/v9YxnTMEoEx7QnwuKrOb7VS5O425T7v+Cz1Ps+bsf9DE2BWNWRMe28BXxGRfnB4nt+huP+XlpEerwFWqGolUC4iZ3nXXw+8q6qHgEIRucy7j2gRievWT2FMJ9mZiDFtqGqOiNyFm90rDDdK7K24CVSmebcdwLUjgBv+96/eA30e8FXv+uuBv4nIfd59/Fc3fgxjOs1GHzWmk0SkSlXjAx2HMV3NqoaMMSbE2RWBMcaEOLsiMMaYEGeJwBhjQpwlAmOMCXGWCIwxJsRZIjDGmBD3/wH/yZGVJQSJRgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "id": "c3880feb",
      "metadata": {
        "id": "c3880feb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b6d316a-f588-444f-a1c6-d2f71db4192a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  adding: content/ (stored 0%)\n",
            "  adding: content/.config/ (stored 0%)\n",
            "  adding: content/.config/.last_survey_prompt.yaml (stored 0%)\n",
            "  adding: content/.config/.last_opt_in_prompt.yaml (stored 0%)\n",
            "  adding: content/.config/configurations/ (stored 0%)\n",
            "  adding: content/.config/configurations/config_default (deflated 15%)\n",
            "  adding: content/.config/active_config (stored 0%)\n",
            "  adding: content/.config/.last_update_check.json (deflated 22%)\n",
            "  adding: content/.config/config_sentinel (stored 0%)\n",
            "  adding: content/.config/logs/ (stored 0%)\n",
            "  adding: content/.config/logs/2022.08.15/ (stored 0%)\n",
            "  adding: content/.config/logs/2022.08.15/13.44.12.999341.log (deflated 86%)\n",
            "  adding: content/.config/logs/2022.08.15/13.43.32.260465.log (deflated 91%)\n",
            "  adding: content/.config/logs/2022.08.15/13.44.40.370262.log (deflated 55%)\n",
            "  adding: content/.config/logs/2022.08.15/13.43.53.840714.log (deflated 53%)\n",
            "  adding: content/.config/logs/2022.08.15/13.44.20.441098.log (deflated 54%)\n",
            "  adding: content/.config/logs/2022.08.15/13.44.41.125604.log (deflated 54%)\n",
            "  adding: content/.config/gce (stored 0%)\n",
            "  adding: content/data/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/VGG_16/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/VGG_16/train_normalize.npy (deflated 16%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/VGG_16/test_normalize.npy (deflated 16%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/CNN_Input_1/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/CNN_Input_1/train_normalize.npy (deflated 51%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/CNN_Input_1/test_normalize.npy (deflated 51%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/CNN_Input_2/ (stored 0%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/CNN_Input_2/train_normalize.npy (deflated 50%)\n",
            "  adding: content/data/cifar10_filtered/intermediate/20220816_2014/CNN_Input_2/test_normalize.npy (deflated 50%)\n",
            "  adding: content/models/ (stored 0%)\n",
            "  adding: content/models/viz/ (stored 0%)\n",
            "  adding: content/models/viz/20220816_1854_CNN_Input_1.gv.pdf (deflated 6%)\n",
            "  adding: content/models/viz/20220816_1854_CNN_Input_2.gv.pdf (deflated 6%)\n",
            "  adding: content/models/viz/20220816_1854_CNN_Input_1.gv (deflated 83%)\n",
            "  adding: content/models/viz/20220816_1854_CNN_Input_1.png (deflated 14%)\n",
            "  adding: content/models/viz/20220816_1854_CNN_Input_2.gv (deflated 81%)\n",
            "  adding: content/models/viz/20220816_1854_CNN_Input_2.png (deflated 18%)\n",
            "  adding: content/models/h5files/ (stored 0%)\n",
            "  adding: content/models/h5files/20220816_1854_CNN_Input_1.h5 (deflated 7%)\n",
            "  adding: content/models/h5files/20220816_1854_CNN_Input_2.h5 (deflated 8%)\n",
            "  adding: content/sample_images/ (stored 0%)\n",
            "  adding: content/sample_images/20220816_1854/ (stored 0%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_1_sample_image_raw.png (deflated 20%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_5_sample_image_normalized.png (deflated 37%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_3_sample_image_normalized.png (deflated 42%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_9_sample_image_normalized.png (deflated 36%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_9_sample_image_raw.png (deflated 19%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_2_sample_image_normalized.png (deflated 37%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_6_sample_image_raw.png (deflated 19%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_8_sample_image_raw.png (deflated 21%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_7_sample_image_raw.png (deflated 19%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_2_sample_image_raw.png (deflated 20%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_1_sample_image_normalized.png (deflated 40%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_0_sample_image_normalized.png (deflated 43%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_7_sample_image_normalized.png (deflated 37%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_5_sample_image_raw.png (deflated 19%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_6_sample_image_normalized.png (deflated 37%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_3_sample_image_raw.png (deflated 22%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_0_sample_image_raw.png (deflated 19%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_4_sample_image_normalized.png (deflated 37%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_8_sample_image_normalized.png (deflated 40%)\n",
            "  adding: content/sample_images/20220816_1854/cifar10_4_sample_image_raw.png (deflated 20%)\n",
            "  adding: content/model_weights_cifarvgg/ (stored 0%)\n",
            "  adding: content/model_weights_cifarvgg/cifar10vgg.h5 (deflated 7%)\n",
            "  adding: content/model_weights_cifarvgg/cifar100vgg.h5 (deflated 7%)\n",
            "  adding: content/sample_data/ (stored 0%)\n",
            "  adding: content/sample_data/anscombe.json (deflated 83%)\n",
            "  adding: content/sample_data/README.md (deflated 42%)\n",
            "  adding: content/sample_data/california_housing_test.csv (deflated 76%)\n",
            "  adding: content/sample_data/california_housing_train.csv (deflated 79%)\n",
            "  adding: content/sample_data/mnist_test.csv (deflated 88%)\n",
            "  adding: content/sample_data/mnist_train_small.csv (deflated 88%)\n"
          ]
        }
      ],
      "source": [
        "!zip -r /content/file.zip /content"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "Vv7Gihzx8bvw"
      },
      "id": "Vv7Gihzx8bvw",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.12"
    },
    "colab": {
      "name": "1_cnn_cifar_data.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}