DLL3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "DLL3.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyNOzF4pVGm4HRmMQ67tG/Re",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/NamLam-L/Transfer-Learning-model/blob/main/DLL3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KhxAHb_Ic8XI",
        "outputId": "42f6dfbd-cb0e-45fa-84fe-9ec8f87f4b42"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "CPD6K9wnXzpx",
        "outputId": "4a55863f-65de-4ba4-dad8-90cad13cd227"
      },
      "source": [
        "import keras\n",
        "keras.__version__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'2.7.0'"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "64hJJecLY_yl"
      },
      "source": [
        "# 5.2 - Using convnets with small datasets\n",
        "\n",
        "This notebook contains the code sample found in Chapter 5, Section 2 of [Deep Learning with Python](https://www.manning.com/books/deep-learning-with-python?a_aid=keras&a_bid=76564dff). Note that the original text features far more content, in particular further explanations and figures: in this notebook, you will only find source code and related comments.\n",
        "\n",
        "## Training a convnet from scratch on a small dataset\n",
        "\n",
        "Having to train an image classification model using only very little data is a common situation, which you likely encounter yourself in \n",
        "practice if you ever do computer vision in a professional context.\n",
        "\n",
        "Having \"few\" samples can mean anywhere from a few hundreds to a few tens of thousands of images. As a practical example, we will focus on \n",
        "classifying images as \"dogs\" or \"cats\", in a dataset containing 4000 pictures of cats and dogs (2000 cats, 2000 dogs). We will use 2000 \n",
        "pictures for training, 1000 for validation, and finally 1000 for testing.\n",
        "\n",
        "In this section, we will review one basic strategy to tackle this problem: training a new model from scratch on what little data we have. We \n",
        "will start by naively training a small convnet on our 2000 training samples, without any regularization, to set a baseline for what can be \n",
        "achieved. This will get us to a classification accuracy of 71%. At that point, our main issue will be overfitting. Then we will introduce \n",
        "*data augmentation*, a powerful technique for mitigating overfitting in computer vision. By leveraging data augmentation, we will improve \n",
        "our network to reach an accuracy of 82%.\n",
        "\n",
        "In the next section, we will review two more essential techniques for applying deep learning to small datasets: *doing feature extraction \n",
        "with a pre-trained network* (this will get us to an accuracy of 90% to 93%), and *fine-tuning a pre-trained network* (this will get us to \n",
        "our final accuracy of 95%). Together, these three strategies -- training a small model from scratch, doing feature extracting using a \n",
        "pre-trained model, and fine-tuning a pre-trained model -- will constitute your future toolbox for tackling the problem of doing computer \n",
        "vision with small datasets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rUMx6L2pZWsb"
      },
      "source": [
        "## The relevance of deep learning for small-data problems\n",
        "\n",
        "You will sometimes hear that deep learning only works when lots of data is available. This is in part a valid point: one fundamental \n",
        "characteristic of deep learning is that it is able to find interesting features in the training data on its own, without any need for manual \n",
        "feature engineering, and this can only be achieved when lots of training examples are available. This is especially true for problems where \n",
        "the input samples are very high-dimensional, like images.\n",
        "\n",
        "However, what constitutes \"lots\" of samples is relative -- relative to the size and depth of the network you are trying to train, for \n",
        "starters. It isn't possible to train a convnet to solve a complex problem with just a few tens of samples, but a few hundreds can \n",
        "potentially suffice if the model is small and well-regularized and if the task is simple. \n",
        "Because convnets learn local, translation-invariant features, they are very \n",
        "data-efficient on perceptual problems. Training a convnet from scratch on a very small image dataset will still yield reasonable results \n",
        "despite a relative lack of data, without the need for any custom feature engineering. You will see this in action in this section.\n",
        "\n",
        "But what's more, deep learning models are by nature highly repurposable: you can take, say, an image classification or speech-to-text model \n",
        "trained on a large-scale dataset then reuse it on a significantly different problem with only minor changes. Specifically, in the case of \n",
        "computer vision, many pre-trained models (usually trained on the ImageNet dataset) are now publicly available for download and can be used \n",
        "to bootstrap powerful vision models out of very little data. That's what we will do in the next section.\n",
        "\n",
        "For now, let's get started by getting our hands on the data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sDK3YGXWZZzH"
      },
      "source": [
        "## Downloading the data\n",
        "\n",
        "The cats vs. dogs dataset that we will use isn't packaged with Keras. It was made available by Kaggle.com as part of a computer vision \n",
        "competition in late 2013, back when convnets weren't quite mainstream. You can download the original dataset at: \n",
        "`https://www.kaggle.com/c/dogs-vs-cats/data` (you will need to create a Kaggle account if you don't already have one -- don't worry, the \n",
        "process is painless).\n",
        "\n",
        "The pictures are medium-resolution color JPEGs. They look like this:\n",
        "\n",
        "![cats_vs_dogs_samples](https://s3.amazonaws.com/book.keras.io/img/ch5/cats_vs_dogs_samples.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rouApsP9Zel5"
      },
      "source": [
        "Unsurprisingly, the cats vs. dogs Kaggle competition in 2013 was won by entrants who used convnets. The best entries could achieve up to \n",
        "95% accuracy. In our own example, we will get fairly close to this accuracy (in the next section), even though we will be training our \n",
        "models on less than 10% of the data that was available to the competitors.\n",
        "This original dataset contains 25,000 images of dogs and cats (12,500 from each class) and is 543MB large (compressed). After downloading \n",
        "and uncompressing it, we will create a new dataset containing three subsets: a training set with 1000 samples of each class, a validation \n",
        "set with 500 samples of each class, and finally a test set with 500 samples of each class.\n",
        "\n",
        "Here are a few lines of code to do this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mV8RzkobZ7RW",
        "outputId": "3648036f-f39d-40e7-c129-db637dc5e92a"
      },
      "source": [
        "path = \"//content//gdrive//MyDrive//ML\"\n",
        "import os\n",
        "os.path.isdir(path)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TnSjiBGWaQUO"
      },
      "source": [
        "base_dir = path + '//Cat and Dog'\n",
        "train_dir = os.path.join(base_dir, 'Train')\n",
        "validation_dir = os.path.join(base_dir, 'Validation')\n",
        "test_dir = os.path.join(base_dir, 'Validation')\n",
        "\n",
        "\n",
        "# Directory with our training cat pictures\n",
        "train_cats_dir = os.path.join(train_dir, 'Cat')\n",
        "\n",
        "\n",
        "# Directory with our training dog pictures\n",
        "train_dogs_dir = os.path.join(train_dir, 'Dog')\n",
        "\n",
        "\n",
        "# Directory with our validation cat pictures\n",
        "validation_cats_dir = os.path.join(validation_dir, 'Cat')\n",
        "\n",
        "\n",
        "# Directory with our validation dog pictures\n",
        "validation_dogs_dir = os.path.join(validation_dir, 'Dog')\n",
        "\n",
        "\n",
        "# Directory with our validation cat pictures\n",
        "test_cats_dir = os.path.join(test_dir, 'Cat')\n",
        "\n",
        "\n",
        "# Directory with our validation dog pictures\n",
        "test_dogs_dir = os.path.join(test_dir, 'Dog')\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0bs13V9tdkfI"
      },
      "source": [
        "As a sanity check, let's count how many pictures we have in each training split (train/validation/test):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUufGKPMdVM_",
        "outputId": "f63ad768-daaf-4a8e-e450-1c8cf4baf87e"
      },
      "source": [
        "print(\"total train cat images: \", len(os.listdir(train_cats_dir)))\n",
        "print(\"total train dog images: \", len(os.listdir(train_dogs_dir)))\n",
        "print(\"total validation cat images: \", len(os.listdir(validation_cats_dir)))\n",
        "print(\"total validation dog images: \", len(os.listdir(validation_dogs_dir)))\n",
        "print(\"total test cat images: \", len(os.listdir(test_cats_dir)))\n",
        "print(\"total test dog images: \", len(os.listdir(test_dogs_dir)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total train cat images:  1001\n",
            "total train dog images:  1001\n",
            "total validation cat images:  501\n",
            "total validation dog images:  501\n",
            "total test cat images:  501\n",
            "total test dog images:  501\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "qkby4F1aih5R",
        "outputId": "8e6f253a-97f0-4245-d449-e4f5756ae582"
      },
      "source": [
        "import random\n",
        "idx = random.randint(0,1000)\n",
        "idx\n",
        "train_cats_dir\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "img_path = train_cats_dir + \"/\" + \"cat.\" + str(idx) + \".jpg\"\n",
        "\n",
        "img = mpimg.imread(img_path)\n",
        "plt.imshow(img)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fcdadd4bd50>"
            ]
          },
          "metadata": {},
          "execution_count": 7
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a5TU1t3ikOKI"
      },
      "source": [
        "So we have indeed 2000 training images, and then 1000 validation images and 1000 test images. In each split, there is the same number of \n",
        "samples from each class: this is a balanced binary classification problem, which means that classification accuracy will be an appropriate \n",
        "measure of success."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bn0DhvcEkTZx"
      },
      "source": [
        "## Building our network\n",
        "\n",
        "We've already built a small convnet for MNIST in the previous example, so you should be familiar with them. We will reuse the same \n",
        "general structure: our convnet will be a stack of alternated `Conv2D` (with `relu` activation) and `MaxPooling2D` layers.\n",
        "\n",
        "However, since we are dealing with bigger images and a more complex problem, we will make our network accordingly larger: it will have one \n",
        "more `Conv2D` + `MaxPooling2D` stage. This serves both to augment the capacity of the network, and to further reduce the size of the \n",
        "feature maps, so that they aren't overly large when we reach the `Flatten` layer. Here, since we start from inputs of size 150x150 (a \n",
        "somewhat arbitrary choice), we end up with feature maps of size 7x7 right before the `Flatten` layer.\n",
        "\n",
        "Note that the depth of the feature maps is progressively increasing in the network (from 32 to 128), while the size of the feature maps is \n",
        "decreasing (from 148x148 to 7x7). This is a pattern that you will see in almost all convnets.\n",
        "\n",
        "Since we are attacking a binary classification problem, we are ending the network with a single unit (a `Dense` layer of size 1) and a \n",
        "`sigmoid` activation. This unit will encode the probability that the network is looking at one class or the other."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k1sIKTiOmbrV"
      },
      "source": [
        "from keras import layers\n",
        "from keras import models\n",
        "\n",
        "model = models.Sequential()\n",
        "model.add(layers.Conv2D(32, (3, 3), activation='relu',\n",
        "                        input_shape=(150, 150, 3)))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dense(512, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0JbkaNgzmhKR"
      },
      "source": [
        "Let's take a look at how the dimensions of the feature maps change with every successive layer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z08tzHX7mh-n",
        "outputId": "5705e8cc-efae-4204-c0f0-d8117ee9dffb"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 148, 148, 32)      896       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 74, 74, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 72, 72, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 36, 36, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 17, 17, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 15, 15, 128)       147584    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 7, 7, 128)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 6272)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               3211776   \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 513       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3,453,121\n",
            "Trainable params: 3,453,121\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z3JoyhEPnOi9"
      },
      "source": [
        "For our compilation step, we'll go with the `RMSprop` optimizer as usual. Since we ended our network with a single sigmoid unit, we will \n",
        "use binary crossentropy as our loss (as a reminder, check out the table in Chapter 4, section 5 for a cheatsheet on what loss function to \n",
        "use in various situations)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0gqbUuiSnN6q",
        "outputId": "7660ff21-898e-4d28-cd61-f5cb72099142"
      },
      "source": [
        "from tensorflow.keras import optimizers\n",
        "\n",
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer=optimizers.RMSprop(lr=1e-4),\n",
        "              metrics=['acc'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/rmsprop.py:130: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(RMSprop, self).__init__(name, **kwargs)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qsGHpb1NnqHp"
      },
      "source": [
        "## Data preprocessing\n",
        "\n",
        "As you already know by now, data should be formatted into appropriately pre-processed floating point tensors before being fed into our \n",
        "network. Currently, our data sits on a drive as JPEG files, so the steps for getting it into our network are roughly:\n",
        "\n",
        "* Read the picture files.\n",
        "* Decode the JPEG content to RBG grids of pixels.\n",
        "* Convert these into floating point tensors.\n",
        "* Rescale the pixel values (between 0 and 255) to the [0, 1] interval (as you know, neural networks prefer to deal with small input values).\n",
        "\n",
        "It may seem a bit daunting, but thankfully Keras has utilities to take care of these steps automatically. Keras has a module with image \n",
        "processing helper tools, located at `keras.preprocessing.image`. In particular, it contains the class `ImageDataGenerator` which allows to \n",
        "quickly set up Python generators that can automatically turn image files on disk into batches of pre-processed tensors. This is what we \n",
        "will use here."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a-XCrnrenrBr",
        "outputId": "17b7b1dd-9443-4391-fd90-a754dd5e663e"
      },
      "source": [
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "# ImageDataGenerator: tạo ra các mẩu ảnh ngẫu nhiên để train model thay vì dùng random\n",
        "\n",
        "# All images will be rescaled by 1./255: rescaled giá trị của mỗi pixel từ 256 giá trị nguyên thành các số folat từ 0 -> 1  để máy học tốt hơn\n",
        "train_datagen = ImageDataGenerator(rescale=1./255)\n",
        "test_datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        # This is the target directory\n",
        "        train_dir,\n",
        "        # All images will be resized to 150x150\n",
        "        target_size=(150, 150),\n",
        "        batch_size=20,\n",
        "        # Since we use binary_crossentropy loss, we need binary labels\n",
        "        class_mode='binary')\n",
        "\n",
        "validation_generator = test_datagen.flow_from_directory(\n",
        "        validation_dir,\n",
        "        target_size=(150, 150),\n",
        "        batch_size=20,\n",
        "        class_mode='binary')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 2002 images belonging to 2 classes.\n",
            "Found 1002 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hWXfDPehXAwC"
      },
      "source": [
        "Tập Validation là tập kiểm tra xem tập train có đang thực sự học tốt hay không trong quá trình học. Nếu không, nó sẽ dừng quá trình học lại và chuyển sang cách học mới."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iR9mdPgEXl0k"
      },
      "source": [
        "Let's take a look at the output of one of these generators: it yields batches of 150x150 RGB images (shape `(20, 150, 150, 3)`) and binary \n",
        "labels (shape `(20,)`). 20 is the number of samples in each batch (the batch size). Note that the generator yields these batches \n",
        "indefinitely: it just loops endlessly over the images present in the target folder. For this reason, we need to `break` the iteration loop \n",
        "at some point."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nac9IyJhW5Ch",
        "outputId": "a2ff6fb7-73c4-45a6-8487-5588f82aa9d1"
      },
      "source": [
        "for data_batch, labels_batch in train_generator:\n",
        "    print('data batch shape:', data_batch.shape)\n",
        "    print('labels batch shape:', labels_batch.shape)\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data batch shape: (20, 150, 150, 3)\n",
            "labels batch shape: (20,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1yHsnC-LZS8p"
      },
      "source": [
        "Let's fit our model to the data using the generator. We do it using the `fit_generator` method, the equivalent of `fit` for data generators \n",
        "like ours. It expects as first argument a Python generator that will yield batches of inputs and targets indefinitely, like ours does. \n",
        "Because the data is being generated endlessly, the generator needs to know example how many samples to draw from the generator before \n",
        "declaring an epoch over. This is the role of the `steps_per_epoch` argument: after having drawn `steps_per_epoch` batches from the \n",
        "generator, i.e. after having run for `steps_per_epoch` gradient descent steps, the fitting process will go to the next epoch. In our case, \n",
        "batches are 20-sample large, so it will take 100 batches until we see our target of 2000 samples.\n",
        "\n",
        "When using `fit_generator`, one may pass a `validation_data` argument, much like with the `fit` method. Importantly, this argument is \n",
        "allowed to be a data generator itself, but it could be a tuple of Numpy arrays as well. If you pass a generator as `validation_data`, then \n",
        "this generator is expected to yield batches of validation data endlessly, and thus you should also specify the `validation_steps` argument, \n",
        "which tells the process how many batches to draw from the validation generator for evaluation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ErCWuh9RZXPE",
        "outputId": "757176e0-0d4b-4673-b813-37f4e864d961"
      },
      "source": [
        "history = model.fit_generator(\n",
        "      train_generator,\n",
        "      steps_per_epoch=100,\n",
        "      epochs=50,\n",
        "      validation_data=validation_generator,\n",
        "      validation_steps=50)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:6: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "100/100 [==============================] - 535s 5s/step - loss: 0.6888 - acc: 0.5429 - val_loss: 0.7092 - val_acc: 0.5010\n",
            "Epoch 2/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.6466 - acc: 0.6130 - val_loss: 0.6379 - val_acc: 0.6410\n",
            "Epoch 3/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.5967 - acc: 0.6791 - val_loss: 0.6955 - val_acc: 0.5940\n",
            "Epoch 4/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.5662 - acc: 0.7084 - val_loss: 0.6163 - val_acc: 0.6600\n",
            "Epoch 5/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.5305 - acc: 0.7336 - val_loss: 0.5687 - val_acc: 0.7110\n",
            "Epoch 6/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.5062 - acc: 0.7477 - val_loss: 0.6076 - val_acc: 0.6770\n",
            "Epoch 7/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.4791 - acc: 0.7679 - val_loss: 0.6150 - val_acc: 0.6960\n",
            "Epoch 8/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.4397 - acc: 0.7886 - val_loss: 0.6222 - val_acc: 0.6780\n",
            "Epoch 9/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.4254 - acc: 0.7947 - val_loss: 0.5638 - val_acc: 0.7200\n",
            "Epoch 10/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.4026 - acc: 0.8103 - val_loss: 0.6465 - val_acc: 0.7010\n",
            "Epoch 11/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.3813 - acc: 0.8370 - val_loss: 0.6026 - val_acc: 0.7020\n",
            "Epoch 12/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.3614 - acc: 0.8391 - val_loss: 0.6033 - val_acc: 0.7170\n",
            "Epoch 13/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.3325 - acc: 0.8486 - val_loss: 0.5682 - val_acc: 0.7430\n",
            "Epoch 14/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.3100 - acc: 0.8592 - val_loss: 0.5644 - val_acc: 0.7470\n",
            "Epoch 15/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.2893 - acc: 0.8814 - val_loss: 0.5913 - val_acc: 0.7230\n",
            "Epoch 16/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.2736 - acc: 0.8875 - val_loss: 0.6030 - val_acc: 0.7240\n",
            "Epoch 17/50\n",
            "100/100 [==============================] - 117s 1s/step - loss: 0.2568 - acc: 0.8951 - val_loss: 0.6027 - val_acc: 0.7410\n",
            "Epoch 18/50\n",
            "100/100 [==============================] - 117s 1s/step - loss: 0.2302 - acc: 0.9122 - val_loss: 0.6498 - val_acc: 0.7210\n",
            "Epoch 19/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.2082 - acc: 0.9273 - val_loss: 0.6569 - val_acc: 0.7380\n",
            "Epoch 20/50\n",
            "100/100 [==============================] - 117s 1s/step - loss: 0.1913 - acc: 0.9233 - val_loss: 0.6470 - val_acc: 0.7420\n",
            "Epoch 21/50\n",
            "100/100 [==============================] - 117s 1s/step - loss: 0.1658 - acc: 0.9445 - val_loss: 0.7605 - val_acc: 0.7060\n",
            "Epoch 22/50\n",
            "100/100 [==============================] - 117s 1s/step - loss: 0.1531 - acc: 0.9450 - val_loss: 0.7686 - val_acc: 0.7190\n",
            "Epoch 23/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.1355 - acc: 0.9556 - val_loss: 0.8713 - val_acc: 0.7230\n",
            "Epoch 24/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.1217 - acc: 0.9581 - val_loss: 0.7819 - val_acc: 0.7220\n",
            "Epoch 25/50\n",
            "100/100 [==============================] - 120s 1s/step - loss: 0.1056 - acc: 0.9672 - val_loss: 0.7885 - val_acc: 0.7330\n",
            "Epoch 26/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0894 - acc: 0.9733 - val_loss: 0.7723 - val_acc: 0.7450\n",
            "Epoch 27/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0773 - acc: 0.9798 - val_loss: 0.8053 - val_acc: 0.7330\n",
            "Epoch 28/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0652 - acc: 0.9839 - val_loss: 0.9849 - val_acc: 0.7330\n",
            "Epoch 29/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.0586 - acc: 0.9839 - val_loss: 0.9369 - val_acc: 0.7360\n",
            "Epoch 30/50\n",
            "100/100 [==============================] - 124s 1s/step - loss: 0.0464 - acc: 0.9894 - val_loss: 0.9564 - val_acc: 0.7280\n",
            "Epoch 31/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0424 - acc: 0.9889 - val_loss: 0.9756 - val_acc: 0.7430\n",
            "Epoch 32/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0368 - acc: 0.9909 - val_loss: 0.9954 - val_acc: 0.7480\n",
            "Epoch 33/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0355 - acc: 0.9899 - val_loss: 1.0989 - val_acc: 0.7350\n",
            "Epoch 34/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0307 - acc: 0.9934 - val_loss: 1.3030 - val_acc: 0.7130\n",
            "Epoch 35/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0257 - acc: 0.9924 - val_loss: 1.1060 - val_acc: 0.7280\n",
            "Epoch 36/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0195 - acc: 0.9960 - val_loss: 1.1497 - val_acc: 0.7280\n",
            "Epoch 37/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0258 - acc: 0.9929 - val_loss: 1.2060 - val_acc: 0.7360\n",
            "Epoch 38/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0112 - acc: 0.9985 - val_loss: 1.2928 - val_acc: 0.7330\n",
            "Epoch 39/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.0154 - acc: 0.9960 - val_loss: 1.2388 - val_acc: 0.7410\n",
            "Epoch 40/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0136 - acc: 0.9960 - val_loss: 1.2625 - val_acc: 0.7270\n",
            "Epoch 41/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0155 - acc: 0.9950 - val_loss: 1.3413 - val_acc: 0.7370\n",
            "Epoch 42/50\n",
            "100/100 [==============================] - 119s 1s/step - loss: 0.0137 - acc: 0.9965 - val_loss: 1.3433 - val_acc: 0.7410\n",
            "Epoch 43/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0087 - acc: 0.9975 - val_loss: 1.4206 - val_acc: 0.7380\n",
            "Epoch 44/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0103 - acc: 0.9970 - val_loss: 1.4447 - val_acc: 0.7360\n",
            "Epoch 45/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0097 - acc: 0.9970 - val_loss: 1.4429 - val_acc: 0.7330\n",
            "Epoch 46/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0145 - acc: 0.9950 - val_loss: 1.4892 - val_acc: 0.7310\n",
            "Epoch 47/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0055 - acc: 0.9985 - val_loss: 1.5297 - val_acc: 0.7290\n",
            "Epoch 48/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0073 - acc: 0.9980 - val_loss: 1.5367 - val_acc: 0.7360\n",
            "Epoch 49/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0155 - acc: 0.9970 - val_loss: 1.5455 - val_acc: 0.7400\n",
            "Epoch 50/50\n",
            "100/100 [==============================] - 118s 1s/step - loss: 0.0170 - acc: 0.9960 - val_loss: 1.5789 - val_acc: 0.7280\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EGkp_579EkQi"
      },
      "source": [
        "It is good practice to always save your models after training:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eM4UT4giErJQ"
      },
      "source": [
        "model.save('cats_and_dogs_small_1.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IsEY34gAEudR"
      },
      "source": [
        "Let's plot the loss and accuracy of the model over the training and validation data during training:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IMAw2wmZEuFf"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\n",
        "\n",
        "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend()\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vLshM5QuY3IK"
      },
      "source": [
        "Test_size = 5\n",
        "probability = model.predict(validation_generator, test_size)\n",
        "for index, probability in enumerate(probabilities):\n",
        "  print(\"index:\", index)\n",
        "  # print(\" probability\", probability[0])\n",
        "  # print(\"file_name:\", test_generator.filenames[index])\n",
        "  image_path = test_dir + \"/\" + test_generator.filenames[index]\n",
        "  img = mpimg.imread(image_path)\n",
        "  plt.imshow(img)\n",
        "  if probability > 0.5:\n",
        "    plt.title(\"%.2f\" % (probability[0]*100) + \"% dog\")\n",
        "  else:\n",
        "    plt.title(\"%.2f\" % ((1-probability[0])*100)+ \"% cat\" )\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VyqHOMHDE25K"
      },
      "source": [
        "These plots are characteristic of overfitting. Our training accuracy increases linearly over time, until it reaches nearly 100%, while our \n",
        "validation accuracy stalls at 70-72%. Our validation loss reaches its minimum after only five epochs then stalls, while the training loss \n",
        "keeps decreasing linearly until it reaches nearly 0.\n",
        "\n",
        "Because we only have relatively few training samples (2000), overfitting is going to be our number one concern. You already know about a \n",
        "number of techniques that can help mitigate overfitting, such as dropout and weight decay (L2 regularization). We are now going to \n",
        "introduce a new one, specific to computer vision, and used almost universally when processing images with deep learning models: *data \n",
        "augmentation*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MFixaljeDhAO"
      },
      "source": [
        "## Using data augmentation\n",
        "\n",
        "Overfitting is caused by having too few samples to learn from, rendering us unable to train a model able to generalize to new data. \n",
        "Given infinite data, our model would be exposed to every possible aspect of the data distribution at hand: we would never overfit. Data \n",
        "augmentation takes the approach of generating more training data from existing training samples, by \"augmenting\" the samples via a number \n",
        "of random transformations that yield believable-looking images. The goal is that at training time, our model would never see the exact same \n",
        "picture twice. This helps the model get exposed to more aspects of the data and generalize better.\n",
        "\n",
        "In Keras, this can be done by configuring a number of random transformations to be performed on the images read by our `ImageDataGenerator` \n",
        "instance. Let's get started with an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "22NxXTG1Dgmu"
      },
      "source": [
        "datagen = ImageDataGenerator(\n",
        "      rotation_range=40,\n",
        "      width_shift_range=0.2,\n",
        "      height_shift_range=0.2,\n",
        "      shear_range=0.2,\n",
        "      zoom_range=0.2,\n",
        "      horizontal_flip=True,\n",
        "      fill_mode='nearest')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5Ht7guyDxxJ"
      },
      "source": [
        "These are just a few of the options available (for more, see the Keras documentation). Let's quickly go over what we just wrote:\n",
        "\n",
        "* `rotation_range` is a value in degrees (0-180), a range within which to randomly rotate pictures.\n",
        "* `width_shift` and `height_shift` are ranges (as a fraction of total width or height) within which to randomly translate pictures \n",
        "vertically or horizontally.\n",
        "* `shear_range` is for randomly applying shearing transformations.\n",
        "* `zoom_range` is for randomly zooming inside pictures.\n",
        "* `horizontal_flip` is for randomly flipping half of the images horizontally -- relevant when there are no assumptions of horizontal \n",
        "asymmetry (e.g. real-world pictures).\n",
        "* `fill_mode` is the strategy used for filling in newly created pixels, which can appear after a rotation or a width/height shift.\n",
        "\n",
        "Let's take a look at our augmented images:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zxBKWBv0DuVy"
      },
      "source": [
        "# This is module with image preprocessing utilities\n",
        "from keras.preprocessing import image\n",
        "\n",
        "fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]\n",
        "\n",
        "# We pick one image to \"augment\"\n",
        "img_path = fnames[3]\n",
        "\n",
        "# Read the image and resize it\n",
        "img = image.load_img(img_path, target_size=(150, 150))\n",
        "\n",
        "# Convert it to a Numpy array with shape (150, 150, 3)\n",
        "x = image.img_to_array(img)\n",
        "\n",
        "# Reshape it to (1, 150, 150, 3)\n",
        "x = x.reshape((1,) + x.shape)\n",
        "\n",
        "# The .flow() command below generates batches of randomly transformed images.\n",
        "# It will loop indefinitely, so we need to `break` the loop at some point!\n",
        "i = 0\n",
        "for batch in datagen.flow(x, batch_size=1):\n",
        "    plt.figure(i)\n",
        "    imgplot = plt.imshow(image.array_to_img(batch[0]))\n",
        "    i += 1\n",
        "    if i % 4 == 0:\n",
        "        break\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0ySCGDeD5AG"
      },
      "source": [
        "If we train a new network using this data augmentation configuration, our network will never see twice the same input. However, the inputs \n",
        "that it sees are still heavily intercorrelated, since they come from a small number of original images -- we cannot produce new information, \n",
        "we can only remix existing information. As such, this might not be quite enough to completely get rid of overfitting. To further fight \n",
        "overfitting, we will also add a Dropout layer to our model, right before the densely-connected classifier:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-2BALo5vDwDB"
      },
      "source": [
        "model = models.Sequential()\n",
        "model.add(layers.Conv2D(32, (3, 3), activation='relu',\n",
        "                        input_shape=(150, 150, 3)))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dropout(0.5))\n",
        "model.add(layers.Dense(512, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))\n",
        "\n",
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer=optimizers.RMSprop(lr=1e-4),\n",
        "              metrics=['acc'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "foM-Wxg7D_OI"
      },
      "source": [
        "Let's train our network using data augmentation and dropout:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zfU6bdSnD-VG"
      },
      "source": [
        "train_datagen = ImageDataGenerator(\n",
        "    rescale=1./255,\n",
        "    rotation_range=40,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    horizontal_flip=True,)\n",
        "\n",
        "# Note that the validation data should not be augmented!\n",
        "test_datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        # This is the target directory\n",
        "        train_dir,\n",
        "        # All images will be resized to 150x150\n",
        "        target_size=(150, 150),\n",
        "        batch_size=32,\n",
        "        # Since we use binary_crossentropy loss, we need binary labels\n",
        "        class_mode='binary')\n",
        "\n",
        "validation_generator = test_datagen.flow_from_directory(\n",
        "        validation_dir,\n",
        "        target_size=(150, 150),\n",
        "        batch_size=32,\n",
        "        class_mode='binary')\n",
        "\n",
        "history = model.fit_generator(\n",
        "      train_generator,\n",
        "      steps_per_epoch=100,\n",
        "      epochs=50,\n",
        "      validation_data=validation_generator,\n",
        "      validation_steps=50)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iogv-vVBEKvV"
      },
      "source": [
        "Let's save our model -- we will be using it in the section on convnet visualization."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M2qXjCIMeVMC",
        "outputId": "9027ed6f-6b5c-49ca-b459-8a134cf0c64f"
      },
      "source": [
        "model_dir = \"//content//gdrive//Shared drives//AI(everythings)//Transfer Learning Model\"\n",
        "os.path.isdir(model_dir)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TB_r1Oc1ENFb"
      },
      "source": [
        "model.save(model_dir + '//Cat and Dog CNN1.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SP6F3UaESpb"
      },
      "source": [
        "Let's plot our results again:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UFm5mDGfEQwm"
      },
      "source": [
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\n",
        "\n",
        "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend()\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ecIMwGJqEXlA"
      },
      "source": [
        "Thanks to data augmentation and dropout, we are no longer overfitting: the training curves are rather closely tracking the validation \n",
        "curves. We are now able to reach an accuracy of 82%, a 15% relative improvement over the non-regularized model.\n",
        "\n",
        "By leveraging regularization techniques even further and by tuning the network's parameters (such as the number of filters per convolution \n",
        "layer, or the number of layers in the network), we may be able to get an even better accuracy, likely up to 86-87%. However, it would prove \n",
        "very difficult to go any higher just by training our own convnet from scratch, simply because we have so little data to work with. As a \n",
        "next step to improve our accuracy on this problem, we will have to leverage a pre-trained model, which will be the focus of the next two \n",
        "sections."
      ]
    }
  ]
}