Copy_of_Exercise_6_Question.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Copy of Exercise 6 - Question.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RhuthuHegde/Tensorflow-coursera/blob/master/Copy_of_Exercise_6_Question.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zX4Kg8DUTKWO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dn-6c02VmqiN",
        "colab": {}
      },
      "source": [
        "# In this exercise you will train a CNN on the FULL Cats-v-dogs dataset\n",
        "# This will require you doing a lot of data preprocessing because\n",
        "# the dataset isn't split into training and validation for you\n",
        "# This code block has all the required inputs\n",
        "import os\n",
        "import zipfile\n",
        "import random\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.optimizers import RMSprop\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from shutil import copyfile"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3sd9dQWa23aj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 224
        },
        "outputId": "1188f83d-ca70-4516-8c54-7a412e9f84a5"
      },
      "source": [
        "\n",
        "# This code block downloads the full Cats-v-Dogs dataset and stores it as \n",
        "# cats-and-dogs.zip. It then unzips it to /tmp\n",
        "# which will create a tmp/PetImages directory containing subdirectories\n",
        "# called 'Cat' and 'Dog' (that's how the original researchers structured it)\n",
        "# If the URL doesn't work, \n",
        "# .   visit https://www.microsoft.com/en-us/download/confirmation.aspx?id=54765\n",
        "# And right click on the 'Download Manually' link to get a new URL\n",
        "\n",
        "!wget --no-check-certificate \\\n",
        "    \"https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip\" \\\n",
        "    -O \"/tmp/cats-and-dogs.zip\"\n",
        "\n",
        "local_zip = '/tmp/cats-and-dogs.zip'\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp')\n",
        "zip_ref.close()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-06-28 11:38:48--  https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip\n",
            "Resolving download.microsoft.com (download.microsoft.com)... 104.81.140.145, 2a02:26f0:d9:4b1::e59, 2a02:26f0:d9:4b0::e59\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|104.81.140.145|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 824894548 (787M) [application/octet-stream]\n",
            "Saving to: ‘/tmp/cats-and-dogs.zip’\n",
            "\n",
            "/tmp/cats-and-dogs. 100%[===================>] 786.68M  64.5MB/s    in 12s     \n",
            "\n",
            "2020-06-28 11:39:00 (67.2 MB/s) - ‘/tmp/cats-and-dogs.zip’ saved [824894548/824894548]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gi3yD62a6X3S",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "d3913598-f6a2-48b2-a881-263fc6f1c33a"
      },
      "source": [
        "print(len(os.listdir('/tmp/PetImages/Cat/')))\n",
        "print(len(os.listdir('/tmp/PetImages/Dog/')))\n",
        "\n",
        "# Expected Output:\n",
        "# 12501\n",
        "# 12501"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12501\n",
            "12501\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "F-QkLjxpmyK2",
        "colab": {}
      },
      "source": [
        "# Use os.mkdir to create your directories\n",
        "# You will need a directory for cats-v-dogs, and subdirectories for training\n",
        "# and testing. These in turn will need subdirectories for 'cats' and 'dogs'\n",
        "try:\n",
        "    #YOUR CODE GOES HERE\n",
        "    os.mkdir('/tmp/cats-v-dogs')\n",
        "    os.mkdir('/tmp/cats-v-dogs/training')\n",
        "    os.mkdir('/tmp/cats-v-dogs/testing')\n",
        "    os.mkdir('/tmp/cats-v-dogs/training/cats')\n",
        "    os.mkdir('/tmp/cats-v-dogs/training/dogs')\n",
        "    os.mkdir('/tmp/cats-v-dogs/testing/cats')\n",
        "    os.mkdir('/tmp/cats-v-dogs/testing/dogs')\n",
        "except OSError:\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "zvSODo0f9LaU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "e40a61e8-2b86-48eb-9ad9-46823939a3fa"
      },
      "source": [
        "# Write a python function called split_data which takes\n",
        "# a SOURCE directory containing the files\n",
        "# a TRAINING directory that a portion of the files will be copied to\n",
        "# a TESTING directory that a portion of the files will be copie to\n",
        "# a SPLIT SIZE to determine the portion\n",
        "# The files should also be randomized, so that the training set is a random\n",
        "# X% of the files, and the test set is the remaining files\n",
        "# SO, for example, if SOURCE is PetImages/Cat, and SPLIT SIZE is .9\n",
        "# Then 90% of the images in PetImages/Cat will be copied to the TRAINING dir\n",
        "# and 10% of the images will be copied to the TESTING dir\n",
        "# Also -- All images should be checked, and if they have a zero file length,\n",
        "# they will not be copied over\n",
        "#\n",
        "# os.listdir(DIRECTORY) gives you a listing of the contents of that directory\n",
        "# os.path.getsize(PATH) gives you the size of the file\n",
        "# copyfile(source, destination) copies a file from source to destination\n",
        "# random.sample(list, len(list)) shuffles a list\n",
        "def split_data(SOURCE, TRAINING, TESTING, SPLIT_SIZE):\n",
        "# YOUR CODE STARTS HERE\n",
        "    dataset = []\n",
        "    \n",
        "    for unitData in os.listdir(SOURCE):\n",
        "        data = SOURCE + unitData\n",
        "        if(os.path.getsize(data) > 0):\n",
        "            dataset.append(unitData)\n",
        "        else:\n",
        "            print(unitData+ ' is zero length, so ignoring')\n",
        "    \n",
        "    train_set_length = int(len(dataset) * SPLIT_SIZE)\n",
        "    test_set_length = int(len(dataset) - train_set_length)\n",
        "    shuffled_set = random.sample(dataset, len(dataset))\n",
        "    train_set = dataset[0:train_set_length]\n",
        "    test_set = dataset[-test_set_length:]\n",
        "       \n",
        "    for unitData in train_set:\n",
        "        temp_train_set = SOURCE + unitData\n",
        "        final_train_set = TRAINING + unitData\n",
        "        copyfile(temp_train_set, final_train_set)\n",
        "    \n",
        "    for unitData in test_set:\n",
        "        temp_test_set = SOURCE + unitData\n",
        "        final_test_set = TESTING + unitData\n",
        "        copyfile(temp_test_set, final_test_set)\n",
        "# YOUR CODE ENDS HERE\n",
        "\n",
        "\n",
        "CAT_SOURCE_DIR = \"/tmp/PetImages/Cat/\"\n",
        "TRAINING_CATS_DIR = \"/tmp/cats-v-dogs/training/cats/\"\n",
        "TESTING_CATS_DIR = \"/tmp/cats-v-dogs/testing/cats/\"\n",
        "DOG_SOURCE_DIR = \"/tmp/PetImages/Dog/\"\n",
        "TRAINING_DOGS_DIR = \"/tmp/cats-v-dogs/training/dogs/\"\n",
        "TESTING_DOGS_DIR = \"/tmp/cats-v-dogs/testing/dogs/\"\n",
        "\n",
        "split_size = .9\n",
        "split_data(CAT_SOURCE_DIR, TRAINING_CATS_DIR, TESTING_CATS_DIR, split_size)\n",
        "split_data(DOG_SOURCE_DIR, TRAINING_DOGS_DIR, TESTING_DOGS_DIR, split_size)\n",
        "\n",
        "# Expected output\n",
        "# 666.jpg is zero length, so ignoring\n",
        "# 11702.jpg is zero length, so ignoring"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "666.jpg is zero length, so ignoring\n",
            "11702.jpg is zero length, so ignoring\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "luthalB76ufC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "211642b0-aa08-4859-f9f7-728588867c06"
      },
      "source": [
        "print(len(os.listdir('/tmp/cats-v-dogs/training/cats/')))\n",
        "print(len(os.listdir('/tmp/cats-v-dogs/training/dogs/')))\n",
        "print(len(os.listdir('/tmp/cats-v-dogs/testing/cats/')))\n",
        "print(len(os.listdir('/tmp/cats-v-dogs/testing/dogs/')))\n",
        "\n",
        "# Expected output:\n",
        "# 11250\n",
        "# 11250\n",
        "# 1250\n",
        "# 1250"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11250\n",
            "11250\n",
            "1250\n",
            "1250\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "-BQrav4anTmj",
        "colab": {}
      },
      "source": [
        "# DEFINE A KERAS MODEL TO CLASSIFY CATS V DOGS\n",
        "# USE AT LEAST 3 CONVOLUTION LAYERS\n",
        "model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16,(3,3),activation='relu',input_shape=(300,300,3)),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(32,(3,3),activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64,(3,3),activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64,(3,3),activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(512,activation='relu'),\n",
        "    tf.keras.layers.Dense(1,activation='sigmoid')\n",
        "# YOUR CODE HERE\n",
        "])\n",
        "\n",
        "model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "mlNjoJ5D61N6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "f737c3e0-c966-47e6-f560-1d6cdf6649bb"
      },
      "source": [
        "TRAINING_DIR = '/tmp/cats-v-dogs/training'#YOUR CODE HERE\n",
        "train_datagen =ImageDataGenerator(\n",
        "    rescale=1.0/255.0,\n",
        "    rotation_range=40,\n",
        "    horizontal_flip=True,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    shear_range=0.2,\n",
        "    fill_mode='nearest'\n",
        ") #YOUR CODE HERE\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "    TRAINING_DIR,\n",
        "    batch_size=10,\n",
        "    target_size=(300,300),\n",
        "    class_mode='binary')#YOUR CODE HERE\n",
        "\n",
        "VALIDATION_DIR ='/tmp/cats-v-dogs/testing' #YOUR CODE HERE\n",
        "validation_datagen = ImageDataGenerator(rescale=1/255)#YOUR CODE HERE\n",
        "validation_generator = validation_datagen.flow_from_directory(\n",
        "    \n",
        "    VALIDATION_DIR,\n",
        "     batch_size=10,\n",
        "    target_size=(300,300),\n",
        "    class_mode='binary'\n",
        ")#YOUR CODE HERE\n",
        "\n",
        "\n",
        "\n",
        "# Expected Output:\n",
        "# Found 22498 images belonging to 2 classes.\n",
        "# Found 2500 images belonging to 2 classes."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found 22498 images belonging to 2 classes.\n",
            "Found 2500 images belonging to 2 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "KyS4n53w7DxC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 819
        },
        "outputId": "fd88db76-2843-4dcf-dfde-f1e18757aecf"
      },
      "source": [
        "history = model.fit(train_generator,\n",
        "                              epochs=15,\n",
        "                              verbose=1,\n",
        "                              validation_data=validation_generator)\n",
        "\n",
        "# The expectation here is that the model will train, and that accuracy will be > 95% on both training and validation\n",
        "# i.e. acc:A1 and val_acc:A2 will be visible, and both A1 and A2 will be > .9"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "2085/2250 [==========================>...] - ETA: 35s - loss: 0.6465 - accuracy: 0.6388"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 32 bytes but only got 0. Skipping tag 270\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 5 bytes but only got 0. Skipping tag 271\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 272\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 282\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 283\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 20 bytes but only got 0. Skipping tag 306\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 48 bytes but only got 0. Skipping tag 532\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.6/dist-packages/PIL/TiffImagePlugin.py:788: UserWarning: Corrupt EXIF data.  Expecting to read 2 bytes but only got 0. \n",
            "  warnings.warn(str(msg))\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "2250/2250 [==============================] - 495s 220ms/step - loss: 0.6437 - accuracy: 0.6416 - val_loss: 0.5420 - val_accuracy: 0.7360\n",
            "Epoch 2/15\n",
            "2250/2250 [==============================] - 490s 218ms/step - loss: 0.5949 - accuracy: 0.6963 - val_loss: 0.5153 - val_accuracy: 0.7520\n",
            "Epoch 3/15\n",
            "2250/2250 [==============================] - 487s 216ms/step - loss: 0.5799 - accuracy: 0.7121 - val_loss: 0.5323 - val_accuracy: 0.7376\n",
            "Epoch 4/15\n",
            "2250/2250 [==============================] - 485s 216ms/step - loss: 0.5679 - accuracy: 0.7219 - val_loss: 0.5700 - val_accuracy: 0.7052\n",
            "Epoch 5/15\n",
            "2250/2250 [==============================] - 485s 215ms/step - loss: 0.5633 - accuracy: 0.7266 - val_loss: 0.4705 - val_accuracy: 0.7736\n",
            "Epoch 6/15\n",
            "2250/2250 [==============================] - 486s 216ms/step - loss: 0.5718 - accuracy: 0.7254 - val_loss: 0.4701 - val_accuracy: 0.7876\n",
            "Epoch 7/15\n",
            "2250/2250 [==============================] - 492s 219ms/step - loss: 0.5634 - accuracy: 0.7339 - val_loss: 0.4973 - val_accuracy: 0.7744\n",
            "Epoch 8/15\n",
            "2250/2250 [==============================] - 491s 218ms/step - loss: 0.5509 - accuracy: 0.7426 - val_loss: 0.4667 - val_accuracy: 0.7904\n",
            "Epoch 9/15\n",
            "2250/2250 [==============================] - 488s 217ms/step - loss: 0.5557 - accuracy: 0.7464 - val_loss: 0.6078 - val_accuracy: 0.7352\n",
            "Epoch 10/15\n",
            "2250/2250 [==============================] - 486s 216ms/step - loss: 0.5400 - accuracy: 0.7536 - val_loss: 0.4460 - val_accuracy: 0.8052\n",
            "Epoch 11/15\n",
            "2250/2250 [==============================] - 486s 216ms/step - loss: 0.5383 - accuracy: 0.7574 - val_loss: 0.4632 - val_accuracy: 0.7964\n",
            "Epoch 12/15\n",
            "2250/2250 [==============================] - 476s 212ms/step - loss: 0.5591 - accuracy: 0.7571 - val_loss: 0.4729 - val_accuracy: 0.7784\n",
            "Epoch 13/15\n",
            "2250/2250 [==============================] - 472s 210ms/step - loss: 0.5525 - accuracy: 0.7514 - val_loss: 0.3954 - val_accuracy: 0.8244\n",
            "Epoch 14/15\n",
            "2250/2250 [==============================] - 471s 209ms/step - loss: 0.5363 - accuracy: 0.7595 - val_loss: 0.5463 - val_accuracy: 0.7812\n",
            "Epoch 15/15\n",
            "2250/2250 [==============================] - 474s 211ms/step - loss: 0.5556 - accuracy: 0.7570 - val_loss: 0.8233 - val_accuracy: 0.7028\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "outputId": "a1866f62-e0f3-40b6-bcc2-75de9090dd51"
      },
      "source": [
        "# PLOT LOSS AND ACCURACY\n",
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.image  as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#-----------------------------------------------------------\n",
        "# Retrieve a list of list results on training and test data\n",
        "# sets for each training epoch\n",
        "#-----------------------------------------------------------\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)) # Get number of epochs\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation accuracy per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, acc, 'r', \"Training Accuracy\")\n",
        "plt.plot(epochs, val_acc, 'b', \"Validation Accuracy\")\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.figure()\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation loss per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, loss, 'r', \"Training Loss\")\n",
        "plt.plot(epochs, val_loss, 'b', \"Validation Loss\")\n",
        "\n",
        "\n",
        "plt.title('Training and validation loss')\n",
        "\n",
        "# Desired output. Charts with training and validation metrics. No crash :)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Training and validation loss')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        },
        {
          "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": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "LqL6FYUrtXpf",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 174
        },
        "outputId": "de0e30dd-1d7c-4c4a-d631-0ec6775431e8"
      },
      "source": [
        "# Here's a codeblock just for fun. You should be able to upload an image here \n",
        "# and have it classified without crashing\n",
        "\n",
        "import numpy as np\n",
        "from google.colab import files\n",
        "from keras.preprocessing import image\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        " \n",
        "  # predicting images\n",
        "  path = '/content/' + fn\n",
        "  img = image.load_img(path, target_size=(300,300))# YOUR CODE HERE))\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "\n",
        "  images = np.vstack([x])\n",
        "  classes = model.predict(images, batch_size=10)\n",
        "  print(classes[0])\n",
        "  if classes[0]>0.5:\n",
        "    print(fn + \" is a dog\")\n",
        "  else:\n",
        "    print(fn + \" is a cat\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-fc23bc35-36ba-4a29-ad19-584cf282fecd\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-fc23bc35-36ba-4a29-ad19-584cf282fecd\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving dog-3277416_640.jpg to dog-3277416_640.jpg\n",
            "Saving kitty-551554_640(1).jpg to kitty-551554_640(1).jpg\n",
            "[1.]\n",
            "dog-3277416_640.jpg is a dog\n",
            "[1.]\n",
            "kitty-551554_640(1).jpg is a dog\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OVFqKZ4sMOcf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}