1-Cats-Vs-Dogs-Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Course 2 - Part 6 - Lesson 3 - Notebook.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "##  Cats vs Dogs Classification using Transfer Learning"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1xJZ5glPPCRz",
        "outputId": "8f039db9-892a-438f-c0b8-aeffb76f6408"
      },
      "source": [
        "import os\n",
        "\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras import Model\n",
        "!wget --no-check-certificate \\\n",
        "    https://storage.googleapis.com/mledu-datasets/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5 \\\n",
        "    -O /tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
        "  \n",
        "from tensorflow.keras.applications.inception_v3 import InceptionV3\n",
        "\n",
        "local_weights_file = '/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
        "\n",
        "pre_trained_model = InceptionV3(input_shape = (150, 150, 3), \n",
        "                                include_top = False, \n",
        "                                weights = None)\n",
        "\n",
        "pre_trained_model.load_weights(local_weights_file)\n",
        "\n",
        "for layer in pre_trained_model.layers:\n",
        "  layer.trainable = False\n",
        "  \n",
        "# pre_trained_model.summary()\n",
        "\n",
        "last_layer = pre_trained_model.get_layer('mixed7')\n",
        "print('last layer output shape: ', last_layer.output_shape)\n",
        "last_output = last_layer.output"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2021-08-07 19:22:11--  https://storage.googleapis.com/mledu-datasets/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.141.128, 142.251.2.128, 2607:f8b0:4023:c0b::80, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.141.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 87910968 (84M) [application/x-hdf]\n",
            "Saving to: ‘/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5’\n",
            "\n",
            "/tmp/inception_v3_w 100%[===================>]  83.84M   118MB/s    in 0.7s    \n",
            "\n",
            "2021-08-07 19:22:12 (118 MB/s) - ‘/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5’ saved [87910968/87910968]\n",
            "\n",
            "last layer output shape:  (None, 7, 7, 768)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BMXb913pbvFg",
        "outputId": "b945fb04-9837-4b0b-8a8c-4901f92685af"
      },
      "source": [
        "from tensorflow.keras.optimizers import RMSprop\n",
        "\n",
        "# Flatten the output layer to 1 dimension\n",
        "x = layers.Flatten()(last_output)\n",
        "# Add a fully connected layer with 1,024 hidden units and ReLU activation\n",
        "x = layers.Dense(1024, activation='relu')(x)\n",
        "# Add a dropout rate of 0.2\n",
        "x = layers.Dropout(0.2)(x)                  \n",
        "# Add a final sigmoid layer for classification\n",
        "x = layers.Dense  (1, activation='sigmoid')(x)           \n",
        "\n",
        "model = Model( pre_trained_model.input, x) \n",
        "\n",
        "model.compile(optimizer = RMSprop(lr=0.0001), \n",
        "              loss = 'binary_crossentropy', \n",
        "              metrics = ['accuracy'])\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py:375: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  \"The `lr` argument is deprecated, use `learning_rate` instead.\")\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O4s8HckqGlnb",
        "outputId": "04a2c6a1-2678-40e0-fc64-451a839511d5"
      },
      "source": [
        "!wget --no-check-certificate \\\n",
        "        https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip \\\n",
        "       -O /tmp/cats_and_dogs_filtered.zip\n",
        "\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "import os\n",
        "import zipfile\n",
        "\n",
        "local_zip = '//tmp/cats_and_dogs_filtered.zip'\n",
        "\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "\n",
        "zip_ref.extractall('/tmp')\n",
        "zip_ref.close()\n",
        "\n",
        "# Define our example directories and files\n",
        "base_dir = '/tmp/cats_and_dogs_filtered'\n",
        "\n",
        "train_dir = os.path.join( base_dir, 'train')\n",
        "validation_dir = os.path.join( base_dir, 'validation')\n",
        "\n",
        "\n",
        "train_cats_dir = os.path.join(train_dir, 'cats') # Directory with our training cat pictures\n",
        "train_dogs_dir = os.path.join(train_dir, 'dogs') # Directory with our training dog pictures\n",
        "validation_cats_dir = os.path.join(validation_dir, 'cats') # Directory with our validation cat pictures\n",
        "validation_dogs_dir = os.path.join(validation_dir, 'dogs')# Directory with our validation dog pictures\n",
        "\n",
        "train_cat_fnames = os.listdir(train_cats_dir)\n",
        "train_dog_fnames = os.listdir(train_dogs_dir)\n",
        "\n",
        "# Add our data-augmentation parameters to ImageDataGenerator\n",
        "train_datagen = ImageDataGenerator(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.0/255. )\n",
        "\n",
        "# Flow training images in batches of 20 using train_datagen generator\n",
        "train_generator = train_datagen.flow_from_directory(train_dir,\n",
        "                                                    batch_size = 20,\n",
        "                                                    class_mode = 'binary', \n",
        "                                                    target_size = (150, 150))     \n",
        "\n",
        "# Flow validation images in batches of 20 using test_datagen generator\n",
        "validation_generator =  test_datagen.flow_from_directory( validation_dir,\n",
        "                                                          batch_size  = 20,\n",
        "                                                          class_mode  = 'binary', \n",
        "                                                          target_size = (150, 150))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2021-08-07 19:22:29--  https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.250.141.128, 142.251.2.128, 2607:f8b0:4023:c06::80, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.250.141.128|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 68606236 (65M) [application/zip]\n",
            "Saving to: ‘/tmp/cats_and_dogs_filtered.zip’\n",
            "\n",
            "/tmp/cats_and_dogs_ 100%[===================>]  65.43M   346MB/s    in 0.2s    \n",
            "\n",
            "2021-08-07 19:22:30 (346 MB/s) - ‘/tmp/cats_and_dogs_filtered.zip’ saved [68606236/68606236]\n",
            "\n",
            "Found 2000 images belonging to 2 classes.\n",
            "Found 1000 images belonging to 2 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Blhq2MAUeyGA",
        "outputId": "71398d44-1dbc-45c5-83fa-56b5e4a21f87"
      },
      "source": [
        "history = model.fit(\n",
        "            train_generator,\n",
        "            validation_data = validation_generator,\n",
        "            steps_per_epoch = 100,\n",
        "            epochs = 20,\n",
        "            validation_steps = 50,\n",
        "            verbose = 2)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/20\n",
            "100/100 - 52s - loss: 0.3675 - accuracy: 0.8590 - val_loss: 0.0947 - val_accuracy: 0.9650\n",
            "Epoch 2/20\n",
            "100/100 - 18s - loss: 0.2071 - accuracy: 0.9115 - val_loss: 0.1251 - val_accuracy: 0.9600\n",
            "Epoch 3/20\n",
            "100/100 - 17s - loss: 0.2085 - accuracy: 0.9215 - val_loss: 0.1311 - val_accuracy: 0.9530\n",
            "Epoch 4/20\n",
            "100/100 - 18s - loss: 0.1977 - accuracy: 0.9260 - val_loss: 0.1191 - val_accuracy: 0.9590\n",
            "Epoch 5/20\n",
            "100/100 - 19s - loss: 0.1952 - accuracy: 0.9230 - val_loss: 0.1755 - val_accuracy: 0.9410\n",
            "Epoch 6/20\n",
            "100/100 - 18s - loss: 0.1706 - accuracy: 0.9400 - val_loss: 0.1460 - val_accuracy: 0.9510\n",
            "Epoch 7/20\n",
            "100/100 - 18s - loss: 0.1548 - accuracy: 0.9490 - val_loss: 0.1385 - val_accuracy: 0.9600\n",
            "Epoch 8/20\n",
            "100/100 - 19s - loss: 0.1782 - accuracy: 0.9415 - val_loss: 0.2025 - val_accuracy: 0.9460\n",
            "Epoch 9/20\n",
            "100/100 - 18s - loss: 0.1706 - accuracy: 0.9435 - val_loss: 0.1141 - val_accuracy: 0.9640\n",
            "Epoch 10/20\n",
            "100/100 - 18s - loss: 0.1395 - accuracy: 0.9535 - val_loss: 0.1275 - val_accuracy: 0.9660\n",
            "Epoch 11/20\n",
            "100/100 - 18s - loss: 0.1567 - accuracy: 0.9470 - val_loss: 0.1496 - val_accuracy: 0.9590\n",
            "Epoch 12/20\n",
            "100/100 - 19s - loss: 0.1587 - accuracy: 0.9460 - val_loss: 0.1903 - val_accuracy: 0.9570\n",
            "Epoch 13/20\n",
            "100/100 - 18s - loss: 0.1572 - accuracy: 0.9500 - val_loss: 0.1697 - val_accuracy: 0.9560\n",
            "Epoch 14/20\n",
            "100/100 - 19s - loss: 0.1477 - accuracy: 0.9530 - val_loss: 0.1735 - val_accuracy: 0.9590\n",
            "Epoch 15/20\n",
            "100/100 - 18s - loss: 0.1232 - accuracy: 0.9590 - val_loss: 0.1409 - val_accuracy: 0.9670\n",
            "Epoch 16/20\n",
            "100/100 - 17s - loss: 0.1380 - accuracy: 0.9565 - val_loss: 0.1175 - val_accuracy: 0.9700\n",
            "Epoch 17/20\n",
            "100/100 - 19s - loss: 0.1252 - accuracy: 0.9550 - val_loss: 0.1303 - val_accuracy: 0.9650\n",
            "Epoch 18/20\n",
            "100/100 - 18s - loss: 0.1420 - accuracy: 0.9540 - val_loss: 0.1095 - val_accuracy: 0.9740\n",
            "Epoch 19/20\n",
            "100/100 - 17s - loss: 0.1450 - accuracy: 0.9510 - val_loss: 0.1272 - val_accuracy: 0.9670\n",
            "Epoch 20/20\n",
            "100/100 - 18s - loss: 0.1285 - accuracy: 0.9565 - val_loss: 0.1331 - val_accuracy: 0.9640\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "C2Fp6Se9rKuL",
        "outputId": "5bfec5e3-ea93-4e91-98c9-10478f995d5a"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\n",
        "\n",
        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend(loc=0)\n",
        "plt.figure()\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GWRDxO-uqFbg"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    }
  ]
}