Jupyter Notebook Block 5 - Object Detection and Segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dWyPGNkCGhIX"
   },
   "source": [
    "# Part I : Create Your Own Dataset and Train it with ConvNets\n",
    "\n",
    "In this part of the notebook, you will set up your own dataset for image classification. Please specify \n",
    "under `queries` the image categories you are interested in. Under `limit` specify the number of images \n",
    "you want to download for each image category. \n",
    "\n",
    "You do not need to understand the class `simple_image_download`, just execute the cell after you have specified \n",
    "the download folder.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8rckz3ZuGhIc",
    "outputId": "6f615f06-759a-4eea-839e-658155df8d36"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import urllib\n",
    "import requests\n",
    "from urllib.parse import quote\n",
    "import array as arr\n",
    "\n",
    "\n",
    "# Specifiy the queries\n",
    "queries = \"brad pitt, johnny depp, leonardo dicaprio, robert de niro, angelina jolie, sandra bullock, catherine deneuve, marion cotillard\"\n",
    "limit = 10\n",
    "download_folder = \"./train/\"\n",
    "\n",
    "\n",
    "class simple_image_download:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def urls(self, keywords, limit, download_folder):\n",
    "        keyword_to_search = [str(item).strip() for item in keywords.split(',')]\n",
    "        i = 0\n",
    "        links = []\n",
    "        while i < len(keyword_to_search):\n",
    "            url = 'https://www.google.com/search?q=' + quote(\n",
    "                keyword_to_search[i].encode(\n",
    "                    'utf-8')) + '&biw=1536&bih=674&tbm=isch&sxsrf=ACYBGNSXXpS6YmAKUiLKKBs6xWb4uUY5gA:1581168823770&source=lnms&sa=X&ved=0ahUKEwioj8jwiMLnAhW9AhAIHbXTBMMQ_AUI3QUoAQ'\n",
    "            raw_html = self._download_page(url)\n",
    "\n",
    "            end_object = -1;\n",
    "\n",
    "            j = 0\n",
    "            while j < limit:\n",
    "                while (True):\n",
    "                    try:\n",
    "                        new_line = raw_html.find('\"https://', end_object + 1)\n",
    "                        end_object = raw_html.find('\"', new_line + 1)\n",
    "\n",
    "                        buffor = raw_html.find('\\\\', new_line + 1, end_object)\n",
    "                        if buffor != -1:\n",
    "                            object_raw = (raw_html[new_line + 1:buffor])\n",
    "                        else:\n",
    "                            object_raw = (raw_html[new_line + 1:end_object])\n",
    "\n",
    "                        if '.jpg' in object_raw or 'png' in object_raw or '.ico' in object_raw or '.gif' in object_raw or '.jpeg' in object_raw:\n",
    "                            break\n",
    "\n",
    "                    except Exception as e:\n",
    "                        print(e)\n",
    "                        break\n",
    "\n",
    "                links.append(object_raw)\n",
    "                j += 1\n",
    "\n",
    "            i += 1\n",
    "        return(links)\n",
    "\n",
    "\n",
    "    def download(self, keywords, limit, download_folder):\n",
    "        keyword_to_search = [str(item).strip() for item in keywords.split(',')]\n",
    "        main_directory = download_folder\n",
    "        i = 0\n",
    "\n",
    "        while i < len(keyword_to_search):\n",
    "            self._create_directories(main_directory, keyword_to_search[i])\n",
    "            url = 'https://www.google.com/search?q=' + quote(\n",
    "                keyword_to_search[i].encode('utf-8')) + '&biw=1536&bih=674&tbm=isch&sxsrf=ACYBGNSXXpS6YmAKUiLKKBs6xWb4uUY5gA:1581168823770&source=lnms&sa=X&ved=0ahUKEwioj8jwiMLnAhW9AhAIHbXTBMMQ_AUI3QUoAQ'\n",
    "            raw_html = self._download_page(url)\n",
    "\n",
    "            end_object = -1;\n",
    "\n",
    "            j = 0\n",
    "            while j < limit:\n",
    "                while (True):\n",
    "                    try:\n",
    "                        new_line = raw_html.find('\"https://', end_object + 1)\n",
    "                        end_object = raw_html.find('\"', new_line + 1)\n",
    "\n",
    "                        buffor = raw_html.find('\\\\', new_line + 1, end_object)\n",
    "                        if buffor != -1:\n",
    "                            object_raw = (raw_html[new_line+1:buffor])\n",
    "                        else:\n",
    "                            object_raw = (raw_html[new_line+1:end_object])\n",
    "\n",
    "                        if '.jpg' in object_raw or 'png' in object_raw or '.ico' in object_raw or '.gif' in object_raw or '.jpeg' in object_raw:\n",
    "                            break\n",
    "\n",
    "                    except Exception as e:\n",
    "                        print(e)\n",
    "                        break\n",
    "\n",
    "                path = main_directory + keyword_to_search[i]\n",
    "\n",
    "                #print(object_raw)\n",
    "\n",
    "                if not os.path.exists(path):\n",
    "                    os.makedirs(path)\n",
    "\n",
    "                filename = str(keyword_to_search[i]) + \"_\" + str(j + 1) + \".jpg\"\n",
    "\n",
    "                try:\n",
    "                    r = requests.get(object_raw, allow_redirects=True)\n",
    "                    open(os.path.join(path, filename), 'wb').write(r.content)\n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "                    j -= 1\n",
    "                j += 1\n",
    "\n",
    "            i += 1\n",
    "\n",
    "\n",
    "    def _create_directories(self, main_directory, name):\n",
    "        try:\n",
    "            if not os.path.exists(main_directory):\n",
    "                os.makedirs(main_directory)\n",
    "                time.sleep(0.2)\n",
    "                path = (name)\n",
    "                sub_directory = os.path.join(main_directory, path)\n",
    "                if not os.path.exists(sub_directory):\n",
    "                    os.makedirs(sub_directory)\n",
    "            else:\n",
    "                path = (name)\n",
    "                sub_directory = os.path.join(main_directory, path)\n",
    "                if not os.path.exists(sub_directory):\n",
    "                    os.makedirs(sub_directory)\n",
    "\n",
    "        except OSError as e:\n",
    "            if e.errno != 17:\n",
    "                raise\n",
    "            pass\n",
    "        return\n",
    "\n",
    "    def _download_page(self,url):\n",
    "\n",
    "        try:\n",
    "            headers = {}\n",
    "            headers['User-Agent'] = \"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.87 Safari/537.36\"\n",
    "            req = urllib.request.Request(url, headers=headers)\n",
    "            resp = urllib.request.urlopen(req)\n",
    "            respData = str(resp.read())\n",
    "            return respData\n",
    "\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "            exit(0)\n",
    "            \n",
    "response = simple_image_download\n",
    "response().download(queries, limit, download_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CRHl9UX6GhIs"
   },
   "source": [
    "Please check carefully the downloaded images, there may be a lot of garbage! You definitely need to \n",
    "clean the data.\n",
    "\n",
    "In the following, you will apply data augmentation to your data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3SX21FtcGhIu"
   },
   "outputs": [],
   "source": [
    "# General imports\n",
    "import tensorflow as tf\n",
    "tf.compat.v1.enable_eager_execution(\n",
    "    config=None, device_policy=None, execution_mode=None\n",
    ")\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Shortcuts to keras if (however from tensorflow)\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D\n",
    "from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense\n",
    "from tensorflow.keras.callbacks import TensorBoard \n",
    "\n",
    "# Shortcut for displaying images\n",
    "def plot_img(img):\n",
    "    plt.imshow(img, cmap='gray')\n",
    "    plt.axis(\"off\")\n",
    "    plt.show()\n",
    "    \n",
    "# The target image size can be fixed here (quadratic)\n",
    "# the ImageDataGenerator() automatically scales the images accordingly (aspect ratio is changed)\n",
    "image_size = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rN_Mp1rmGhI1",
    "outputId": "6417b1f9-e7d4-4d56-a213-191f9d17524a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 70 images belonging to 8 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/PIL/Image.py:952: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
      "  \"Palette images with Transparency expressed in bytes should be \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 2., 2., 2., 2., 2., 2., 2.,\n",
       "       2., 2., 2., 3., 3., 3., 3., 3.], dtype=float32)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# These are the class names; this defines the ordering of the classes\n",
    "class_names = [\"brad pitt\", \"johnny deep\", \"leonardo dicaprio\", \"robert de niro\",\n",
    "           \"angelina jolie\", \"sandra bullock\", \"catherine deneuve\", \"marion cotillard\"]\n",
    "\n",
    "\n",
    "# Class ImageDataGenerator() returns an iterator holding one batch of images\n",
    "# the constructor takes arguments defining the different image transformations\n",
    "# for augmentation purposes (rotation, x-/y-shift, intensity scaling - here 1./255 \n",
    "# to scale range to [0, 1], shear, zoom, flip, ... )\n",
    "train_datagen = ImageDataGenerator(\n",
    "        rotation_range=10,\n",
    "        width_shift_range=0.2,\n",
    "        height_shift_range=0.2,\n",
    "        rescale=1./255,\n",
    "        shear_range=0.2,\n",
    "        zoom_range=0.2,\n",
    "        horizontal_flip=True,\n",
    "        fill_mode='nearest')\n",
    "\n",
    "\n",
    "dir_iter = train_datagen.flow_from_directory('./brandnew_images/', \n",
    "                                         target_size=(image_size, image_size),\n",
    "                                         classes=class_names,\n",
    "                                         batch_size=25, class_mode='sparse', shuffle=False)\n",
    "\n",
    "plot_img(dir_iter[0][0][0,...])\n",
    "dir_iter[0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yw30IIEeGhI9",
    "outputId": "efd081d3-d8d9-4429-e6f9-573778f3391e"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_img(dir_iter[0][0][0,...])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "V2fYccc8GhJF"
   },
   "source": [
    "Before you continue, you need to split the downloaded images into a `train` folder and into a `validation` folder."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "colab_type": "raw",
    "id": "VamXG4FoGhJH"
   },
   "source": [
    "./\n",
    "├── train\n",
    "│   ├── brad pitt\n",
    "│   └── johnny deep\n",
    "|   ├── leonardo di caprio\n",
    "|   └── ...\n",
    "│       \n",
    "└── validation\n",
    "    ├── brad pitt\n",
    "    ├── johnny deep\n",
    "    ├── leonardo di caprio\n",
    "    └── ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9322su6vGhJJ"
   },
   "source": [
    "If you want to use the example of this jupyter notebook, then download `celebrity-faces-train-validation-dataset.zip` from Ilias and unzip it in the folder of your jupyter notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xPqJWgeAGhJL"
   },
   "source": [
    "## Define a ConvNet Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UuJV4JBKGhJO"
   },
   "outputs": [],
   "source": [
    "batch_size = 20\n",
    "num_train_images = 480\n",
    "num_valid_images = 80\n",
    "num_classes = 8\n",
    "\n",
    "model_scratch = Sequential()\n",
    "model_scratch.add(Conv2D(32, (3, 3), input_shape=(image_size, image_size, 3)))\n",
    "model_scratch.add(Activation('relu'))\n",
    "model_scratch.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model_scratch.add(Conv2D(32, (3, 3)))\n",
    "model_scratch.add(Activation('relu'))\n",
    "model_scratch.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model_scratch.add(Conv2D(64, (3, 3)))\n",
    "model_scratch.add(Activation('relu'))\n",
    "model_scratch.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "# this converts our 3D feature maps to 1D feature vectors\n",
    "model_scratch.add(Flatten())  \n",
    "model_scratch.add(Dense(64))\n",
    "model_scratch.add(Activation('relu'))\n",
    "model_scratch.add(Dropout(0.5))\n",
    "model_scratch.add(Dense(num_classes))\n",
    "model_scratch.add(Activation('softmax'))\n",
    "\n",
    "model_scratch.compile(loss='categorical_crossentropy',\n",
    "              optimizer='adam',\n",
    "              metrics=['accuracy'])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JFdkIokMGhJT",
    "outputId": "63e7d032-4083-4fe0-d970-c10bf0c39a94"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 70 images belonging to 8 classes.\n",
      "Found 70 images belonging to 8 classes.\n"
     ]
    }
   ],
   "source": [
    "# This is the augmentation configuration we will use for training\n",
    "train_datagen = ImageDataGenerator(\n",
    "        rescale=1./255,\n",
    "        shear_range=0.2,\n",
    "        zoom_range=0.2,\n",
    "        horizontal_flip=True)\n",
    "\n",
    "# This is the augmentation configuration we will use for validation:\n",
    "# only rescaling\n",
    "validation_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "# This is a generator that will read pictures found in\n",
    "# subfolers of './train', and indefinitely generate\n",
    "# batches of augmented image data\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "        './train',  # this is the target directory\n",
    "        target_size=(image_size, image_size),  # all images will be resized to 150x150\n",
    "        classes=class_names,\n",
    "        batch_size=batch_size)  \n",
    "\n",
    "# This is a similar generator, for validation data\n",
    "validation_generator = validation_datagen.flow_from_directory(\n",
    "        './validation',\n",
    "        target_size = (image_size, image_size),\n",
    "        classes = class_names,\n",
    "        batch_size = batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cytHiQUTGhJb"
   },
   "outputs": [],
   "source": [
    "name = 'cnn_face_1'\n",
    "\n",
    "tensorboard = TensorBoard(\n",
    "        log_dir ='./tensorboard/' + name + '/', \n",
    "        write_graph=True,\n",
    "        histogram_freq=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "C7dCbyXPGhJg",
    "outputId": "98b4085e-ed6d-43e2-831f-aec32161583f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n"
     ]
    },
    {
     "ename": "UnidentifiedImageError",
     "evalue": "cannot identify image file <_io.BytesIO object at 0x7f2da807e3b0>",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnidentifiedImageError\u001b[0m                    Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-c88ff01da6f6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mvalidation_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalidation_generator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mvalidation_steps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnum_valid_images\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     callbacks = [tensorboard])\n\u001b[0m",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_freq, max_queue_size, workers, use_multiprocessing, **kwargs)\u001b[0m\n\u001b[1;32m    817\u001b[0m         \u001b[0mmax_queue_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_queue_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    818\u001b[0m         \u001b[0mworkers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mworkers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 819\u001b[0;31m         use_multiprocessing=use_multiprocessing)\n\u001b[0m\u001b[1;32m    820\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    821\u001b[0m   def evaluate(self,\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_v2.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, model, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_freq, max_queue_size, workers, use_multiprocessing, **kwargs)\u001b[0m\n\u001b[1;32m    233\u001b[0m           \u001b[0mmax_queue_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_queue_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    234\u001b[0m           \u001b[0mworkers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mworkers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 235\u001b[0;31m           use_multiprocessing=use_multiprocessing)\n\u001b[0m\u001b[1;32m    236\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    237\u001b[0m       \u001b[0mtotal_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_get_total_number_of_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtraining_data_adapter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_v2.py\u001b[0m in \u001b[0;36m_process_training_inputs\u001b[0;34m(model, x, y, batch_size, epochs, sample_weights, class_weights, steps_per_epoch, validation_split, validation_data, validation_steps, shuffle, distribution_strategy, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m    612\u001b[0m           \u001b[0mclass_weights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_weights\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    613\u001b[0m           \u001b[0msteps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalidation_steps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 614\u001b[0;31m           distribution_strategy=distribution_strategy)\n\u001b[0m\u001b[1;32m    615\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mvalidation_steps\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    616\u001b[0m       raise ValueError('`validation_steps` should not be specified if '\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/training_v2.py\u001b[0m in \u001b[0;36m_process_inputs\u001b[0;34m(model, mode, x, y, batch_size, epochs, sample_weights, class_weights, shuffle, steps, distribution_strategy, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m    704\u001b[0m       \u001b[0mmax_queue_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_queue_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    705\u001b[0m       \u001b[0mworkers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mworkers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 706\u001b[0;31m       use_multiprocessing=use_multiprocessing)\n\u001b[0m\u001b[1;32m    707\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    708\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0madapter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/data_adapter.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, x, y, sample_weights, standardize_function, shuffle, workers, use_multiprocessing, max_queue_size, **kwargs)\u001b[0m\n\u001b[1;32m    950\u001b[0m         \u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    951\u001b[0m         \u001b[0mmax_queue_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmax_queue_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 952\u001b[0;31m         **kwargs)\n\u001b[0m\u001b[1;32m    953\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    954\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/data_adapter.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, x, y, sample_weights, standardize_function, workers, use_multiprocessing, max_queue_size, **kwargs)\u001b[0m\n\u001b[1;32m    745\u001b[0m     \u001b[0;31m# Since we have to know the dtype of the python generator when we build the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    746\u001b[0m     \u001b[0;31m# dataset, we have to look at a batch to infer the structure.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 747\u001b[0;31m     \u001b[0mpeek\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_peek_and_restore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    748\u001b[0m     \u001b[0massert_not_namedtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpeek\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    749\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tensorflow_core/python/keras/engine/data_adapter.py\u001b[0m in \u001b[0;36m_peek_and_restore\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m    954\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    955\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_peek_and_restore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 956\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    957\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    958\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_make_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mworkers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_queue_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/keras_preprocessing/image/iterator.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m     63\u001b[0m         index_array = self.index_array[self.batch_size * idx:\n\u001b[1;32m     64\u001b[0m                                        self.batch_size * (idx + 1)]\n\u001b[0;32m---> 65\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_batches_of_transformed_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex_array\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__len__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/keras_preprocessing/image/iterator.py\u001b[0m in \u001b[0;36m_get_batches_of_transformed_samples\u001b[0;34m(self, index_array)\u001b[0m\n\u001b[1;32m    228\u001b[0m                            \u001b[0mcolor_mode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolor_mode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    229\u001b[0m                            \u001b[0mtarget_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 230\u001b[0;31m                            interpolation=self.interpolation)\n\u001b[0m\u001b[1;32m    231\u001b[0m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg_to_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_format\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata_format\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    232\u001b[0m             \u001b[0;31m# Pillow images should be closed after `load_img`,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/keras_preprocessing/image/utils.py\u001b[0m in \u001b[0;36mload_img\u001b[0;34m(path, grayscale, color_mode, target_size, interpolation)\u001b[0m\n\u001b[1;32m    112\u001b[0m                           'The use of `load_img` requires PIL.')\n\u001b[1;32m    113\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 114\u001b[0;31m         \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpil_image\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    115\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcolor_mode\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'grayscale'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    116\u001b[0m             \u001b[0;31m# if image is not already an 8-bit, 16-bit or 32-bit grayscale image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36mopen\u001b[0;34m(fp, mode, formats)\u001b[0m\n\u001b[1;32m   2942\u001b[0m         \u001b[0mwarnings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2943\u001b[0m     raise UnidentifiedImageError(\n\u001b[0;32m-> 2944\u001b[0;31m         \u001b[0;34m\"cannot identify image file %r\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfilename\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mfp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2945\u001b[0m     )\n\u001b[1;32m   2946\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnidentifiedImageError\u001b[0m: cannot identify image file <_io.BytesIO object at 0x7f2da807e3b0>"
     ]
    }
   ],
   "source": [
    "history = model_scratch.fit(\n",
    "    train_generator,\n",
    "    steps_per_epoch = num_train_images // batch_size,\n",
    "    epochs = 20,\n",
    "    validation_data = validation_generator,\n",
    "    validation_steps = num_valid_images // batch_size,\n",
    "    callbacks = [tensorboard])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wt_ONw5PGhJm",
    "outputId": "e75d8a73-da49-4dbe-ffcf-7cb316be39a2"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'valid'], loc='lower right')\n",
    "plt.show()\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'valid'], loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!tensorboard --port=8061 --logdir=tensorboard/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Y8oAT4oUGhJs"
   },
   "source": [
    "# Part II : Transfer Learning\n",
    "\n",
    "With transfer learning we reuse parts of an already trained model and change the final layer, or several layers, of the model, and then retrain those layers on our own dataset.\n",
    "\n",
    "We will continue using VGG16 model, which comes among others prepackaged with Keras. You can import it from the `tensorflow.keras.applications` module. Here's the list of image-classification models (all pretrained on the ImageNet dataset) that are available as part of `tensorflow.keras.applications`:\n",
    "\n",
    "- Xception\n",
    "- Inception V3 \n",
    "- ResNet50\n",
    "- VGG16\n",
    "- VGG19\n",
    "- MobileNet\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "TensorFlow Hub also distributes models without the last classification layer. These can be used to easily do transfer learning. Any [image feature vector URL from tfhub.dev](https://tfhub.dev/s?module-type=image-feature-vector&q=tf2) would work here.\n",
    "\n",
    "Note that we're calling the partial model (without the final classification layer) a `feature_extractor`. The reasoning for this term is that it will take the input all the way to a layer containing a number of features. So it has done the bulk of the work in identifying the content of an image, except for creating the final probability distribution. That is, it has extracted the features of the image.\n",
    "\n",
    "Let's instantiate the VGG16 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Luec7pbGhJv",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# General imports\n",
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import tensorflow as tf\n",
    "\n",
    "# Shortcuts to keras if (however from tensorflow)\n",
    "from tensorflow.keras import applications\n",
    "from tensorflow.keras import optimizers\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv2D, MaxPool2D\n",
    "from tensorflow.keras.layers import Activation, Dropout, Flatten, Dense\n",
    "from tensorflow.keras.callbacks import TensorBoard \n",
    "\n",
    "# Shortcut for displaying images\n",
    "def plot_img(img):\n",
    "    plt.imshow(img, cmap='gray')\n",
    "    plt.axis(\"off\")\n",
    "    plt.show()\n",
    "    \n",
    "# The target image size can be fixed here (quadratic)\n",
    "# The ImageDataGenerator() automatically scales the images accordingly (aspect ratio is changed)\n",
    "image_size = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eRes_n9BGhJ0"
   },
   "outputs": [],
   "source": [
    "vgg16 = applications.VGG16(include_top=False, weights='imagenet',\n",
    "                           input_shape=(image_size,image_size,3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vEIWLeqSGhJ5"
   },
   "source": [
    "You pass three arguments to the constructor:\n",
    "\n",
    "- `weights` specifies the weight checkpoint from which to initialize the model.\n",
    "\n",
    "- `include_top` refers to including (or not) the densely connected classifier on top of the network. By default, this densely connected classifier corresponds to the 1000 classes from \n",
    "ImageNet. Because we intend to use our own densely connected classifier  you don't need to include it.\n",
    "\n",
    "- `input_shape` is the shape of the image tensors that we will feed to the network. This argument is purely optional: if we don't pass it, the network will be able to process inputs of any size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "M7Bk7t1MGhJ6"
   },
   "outputs": [],
   "source": [
    "# predict_generator requires compilation\n",
    "vgg16.compile(optimizer='adam',\n",
    "              loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "05hqhVtUGhKA"
   },
   "source": [
    "Here's the detail of the architecture of teh VGG16 convolutional base. It's similar to the simple ConvNets you are familiar with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B8bXc_qZGhKC",
    "outputId": "4b81be24-0527-44b5-ed98-b3e57f511350"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"vgg16\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         [(None, 150, 150, 3)]     0         \n",
      "_________________________________________________________________\n",
      "block1_conv1 (Conv2D)        (None, 150, 150, 64)      1792      \n",
      "_________________________________________________________________\n",
      "block1_conv2 (Conv2D)        (None, 150, 150, 64)      36928     \n",
      "_________________________________________________________________\n",
      "block1_pool (MaxPooling2D)   (None, 75, 75, 64)        0         \n",
      "_________________________________________________________________\n",
      "block2_conv1 (Conv2D)        (None, 75, 75, 128)       73856     \n",
      "_________________________________________________________________\n",
      "block2_conv2 (Conv2D)        (None, 75, 75, 128)       147584    \n",
      "_________________________________________________________________\n",
      "block2_pool (MaxPooling2D)   (None, 37, 37, 128)       0         \n",
      "_________________________________________________________________\n",
      "block3_conv1 (Conv2D)        (None, 37, 37, 256)       295168    \n",
      "_________________________________________________________________\n",
      "block3_conv2 (Conv2D)        (None, 37, 37, 256)       590080    \n",
      "_________________________________________________________________\n",
      "block3_conv3 (Conv2D)        (None, 37, 37, 256)       590080    \n",
      "_________________________________________________________________\n",
      "block3_pool (MaxPooling2D)   (None, 18, 18, 256)       0         \n",
      "_________________________________________________________________\n",
      "block4_conv1 (Conv2D)        (None, 18, 18, 512)       1180160   \n",
      "_________________________________________________________________\n",
      "block4_conv2 (Conv2D)        (None, 18, 18, 512)       2359808   \n",
      "_________________________________________________________________\n",
      "block4_conv3 (Conv2D)        (None, 18, 18, 512)       2359808   \n",
      "_________________________________________________________________\n",
      "block4_pool (MaxPooling2D)   (None, 9, 9, 512)         0         \n",
      "_________________________________________________________________\n",
      "block5_conv1 (Conv2D)        (None, 9, 9, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block5_conv2 (Conv2D)        (None, 9, 9, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block5_conv3 (Conv2D)        (None, 9, 9, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block5_pool (MaxPooling2D)   (None, 4, 4, 512)         0         \n",
      "=================================================================\n",
      "Total params: 14,714,688\n",
      "Trainable params: 14,714,688\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "vgg16.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DBSrhVORGhKH"
   },
   "source": [
    "The final feature map (output volume) has shape $(4, 4, 512)$. That's the feature on top of which we will stick a densely connected classifier.\n",
    "\n",
    "At this point, there are two ways how we could proceed:\n",
    "\n",
    "- __Approach 1__: Running the convolutional base over our dataset, recording its output to a Numpy array on disk, and then using this data as input to a standalone, densely connected classifier similar to those we saw earlier in this course. This solution is fast and cheap to run, because it only requires running the convolutional base once for every input image, and the convolutional base is by far the most expensive pipeline. But for the same reason, this technique won't allow us to use data augmentation.\n",
    "\n",
    "- __Approach 2__: Extending the model we have (`vgg16`) by adding `Dense` on top, and running the whole thing end to end on the input data. This will allow us to use data augmentation, because every input image goes through the convolutional base every time it's seen by the model. But for the same reason, this technique is far more expensive than the first."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mlpIDmSCGhKI"
   },
   "source": [
    "## 1. Approach : Extracting Features Using the Pretrained Convolutional Base\n",
    "\n",
    "### Fast Feature Extraction without Data Augmentation\n",
    "\n",
    "We will start by running instances of the previously introduced `ImageDataGenerator` to extract images as Numpy arrays as well as their labels. We will extract features from these images by calling the `predict` method of the `vgg16`model.\n",
    "\n",
    "Let's run the training images through the convolutional base, and see the final shape. 480 is the number of images, and 512 is the number of activation maps in the last layer of the partial model from VGG16."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pC-jzxh_GhKL",
    "outputId": "f2e6f646-c55a-451b-d46e-0a5984217bd4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 480 images belonging to 8 classes.\n",
      "WARNING:tensorflow:From <ipython-input-15-5a7bfed0524c>:27: Model.predict_generator (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use Model.predict, which supports generators.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mirkobirbaumer/.pyenv/versions/3.6.8/lib/python3.6/site-packages/PIL/Image.py:961: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
      "  \"Palette images with Transparency expressed in bytes should be \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of last layer feature map of training dataset: (480, 4, 4, 512)\n",
      "Found 80 images belonging to 8 classes.\n",
      "Shape of last layer feature map of validation dataset: (80, 4, 4, 512)\n"
     ]
    }
   ],
   "source": [
    "# These are the class names; this defines the ordering of the classes\n",
    "class_names = [\"brad pitt\", \"johnny deep\", \"leonardo dicaprio\", \"robert de niro\",\n",
    "               \"angelina jolie\", \"sandra bullock\", \"catherine deneuve\", \"marion cotillard\"]\n",
    "\n",
    "# No augmentation \n",
    "datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "batch_size = 20\n",
    "num_train_images = 480\n",
    "num_valid_images = 80\n",
    "num_classes = 8\n",
    "\n",
    "generator = datagen.flow_from_directory(\n",
    "        './train',\n",
    "        target_size=(image_size, image_size),\n",
    "        batch_size=batch_size,\n",
    "        classes=class_names,\n",
    "        # this means our generator will only yield batches of \n",
    "        # data, no labels\n",
    "        class_mode=None,  \n",
    "        # our data will be in order\n",
    "        shuffle=False)  \n",
    "\n",
    "# the predict_generator method returns the CNN activation maps \n",
    "# of the last layer\n",
    "bottleneck_features_train = vgg16.predict_generator(generator, \n",
    "                                                    num_train_images // batch_size)\n",
    "\n",
    "print(\"Shape of last layer feature map of training dataset:\", bottleneck_features_train.shape)\n",
    "\n",
    "# save the output as a Numpy array\n",
    "np.save('./models/bottleneck_features_train.npy', \n",
    "        bottleneck_features_train)\n",
    "\n",
    "generator = datagen.flow_from_directory(\n",
    "        './validation',\n",
    "        target_size=(image_size, image_size),\n",
    "        batch_size=batch_size,\n",
    "        classes=class_names,\n",
    "        class_mode=None,\n",
    "        shuffle=False)\n",
    "\n",
    "bottleneck_features_validation = vgg16.predict_generator(generator, \n",
    "                                                         num_valid_images // batch_size)\n",
    "\n",
    "np.save('./models/bottleneck_features_validation.npy', bottleneck_features_validation)\n",
    "\n",
    "print(\"Shape of last layer feature map of validation dataset:\", bottleneck_features_validation.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Nbw0M5JeGhKP"
   },
   "source": [
    "##### Load numpy array containing activation maps of training dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EpwO5BOkGhKQ",
    "outputId": "ab179875-edb2-4940-f7ea-167119ed2a52"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, ..., 0, 0, 0],\n",
       "       [1, 0, 0, ..., 0, 0, 0],\n",
       "       [1, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 1],\n",
       "       [0, 0, 0, ..., 0, 0, 1],\n",
       "       [0, 0, 0, ..., 0, 0, 1]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data = np.load('./models/bottleneck_features_train.npy')\n",
    "\n",
    "# the features were saved in order, so recreating the labels is easy\n",
    "train_labels = np.zeros((num_train_images, num_classes), dtype=int)\n",
    "for ind in range(num_classes):\n",
    "    step = num_train_images // num_classes\n",
    "    train_labels[ind*step:(ind+1)*step,ind]=1\n",
    "\n",
    "train_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0ZpacbU8GhKV"
   },
   "source": [
    "##### Load numpy array containing activation maps of validation dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7ou0VDvmGhKW"