{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "zX4Kg8DUTKWO"
      },
      "outputs": [],
      "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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "30GC2JEwL2xj"
      },
      "source": [
        "## Again start by downloading the neccessary data into the Colab Instance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "RXZT2UsyIVe_",
        "outputId": "4a52c50e-c0e0-4884-e92e-81ddc0f001cf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-04-03 17:57:19--  https://storage.googleapis.com/learning-datasets/horse-or-human.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.194.207, 142.250.4.207, 172.253.118.207, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.194.207|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 149574867 (143M) [application/zip]\n",
            "Saving to: ‘/tmp/horse-or-human.zip’\n",
            "\n",
            "/tmp/horse-or-human 100%[===================>] 142.65M  23.1MB/s    in 7.4s    \n",
            "\n",
            "2024-04-03 17:57:27 (19.2 MB/s) - ‘/tmp/horse-or-human.zip’ saved [149574867/149574867]\n",
            "\n",
            "--2024-04-03 17:57:27--  https://storage.googleapis.com/learning-datasets/validation-horse-or-human.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.194.207, 142.250.4.207, 172.253.118.207, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.194.207|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 11480187 (11M) [application/zip]\n",
            "Saving to: ‘/tmp/validation-horse-or-human.zip’\n",
            "\n",
            "/tmp/validation-hor 100%[===================>]  10.95M  7.01MB/s    in 1.6s    \n",
            "\n",
            "2024-04-03 17:57:29 (7.01 MB/s) - ‘/tmp/validation-horse-or-human.zip’ saved [11480187/11480187]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!wget --no-check-certificate \\\n",
        "    https://storage.googleapis.com/learning-datasets/horse-or-human.zip \\\n",
        "    -O /tmp/horse-or-human.zip\n",
        "\n",
        "!wget --no-check-certificate \\\n",
        "    https://storage.googleapis.com/learning-datasets/validation-horse-or-human.zip \\\n",
        "    -O /tmp/validation-horse-or-human.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "PLy3pthUS0D2"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import zipfile\n",
        "\n",
        "local_zip = '/tmp/horse-or-human.zip'\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp/horse-or-human')\n",
        "local_zip = '/tmp/validation-horse-or-human.zip'\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp/validation-horse-or-human')\n",
        "zip_ref.close()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "E_-A0q1QL2xk",
        "outputId": "7db9bf45-5b03-49cc-cf03-07b1485f959c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['horse16-1.png', 'horse49-1.png', 'horse44-8.png', 'horse35-8.png', 'horse34-9.png', 'horse08-9.png', 'horse40-9.png', 'horse26-3.png', 'horse08-1.png', 'horse46-4.png']\n",
            "['human04-02.png', 'human10-01.png', 'human04-18.png', 'human06-24.png', 'human15-23.png', 'human17-23.png', 'human07-12.png', 'human10-02.png', 'human06-01.png', 'human08-13.png']\n",
            "['horse3-521.png', 'horse6-218.png', 'horse2-201.png', 'horse1-484.png', 'horse1-298.png', 'horse5-100.png', 'horse3-397.png', 'horse4-389.png', 'horse5-400.png', 'horse2-544.png']\n",
            "['valhuman03-10.png', 'valhuman05-23.png', 'valhuman01-23.png', 'valhuman05-06.png', 'valhuman04-06.png', 'valhuman03-11.png', 'valhuman05-05.png', 'valhuman03-18.png', 'valhuman01-19.png', 'valhuman03-19.png']\n"
          ]
        }
      ],
      "source": [
        "# Directory with our training horse pictures\n",
        "train_horse_dir = os.path.join('/tmp/horse-or-human/horses')\n",
        "# Directory with our training human pictures\n",
        "train_human_dir = os.path.join('/tmp/horse-or-human/humans')\n",
        "# Directory with our training horse pictures\n",
        "validation_horse_dir = os.path.join('/tmp/validation-horse-or-human/horses')\n",
        "# Directory with our training human pictures\n",
        "validation_human_dir = os.path.join('/tmp/validation-horse-or-human/humans')\n",
        "train_horse_names = os.listdir('/tmp/horse-or-human/horses')\n",
        "print(train_horse_names[:10])\n",
        "train_human_names = os.listdir('/tmp/horse-or-human/humans')\n",
        "print(train_human_names[:10])\n",
        "validation_horse_hames = os.listdir('/tmp/validation-horse-or-human/horses')\n",
        "print(validation_horse_hames[:10])\n",
        "validation_human_names = os.listdir('/tmp/validation-horse-or-human/humans')\n",
        "print(validation_human_names[:10])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "qvfZg3LQbD-5"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "import tensorflow as tf\n",
        "\n",
        "# This script requires TensorFlow 2 and Python 3.\n",
        "if tf.__version__.split('.')[0] != '2':\n",
        "    raise Exception((f\"The script is developed and tested for tensorflow 2. \"\n",
        "                     f\"Current version: {tf.__version__}\"))\n",
        "\n",
        "if sys.version_info.major < 3:\n",
        "    raise Exception((f\"The script is developed and tested for Python 3. \"\n",
        "                     f\"Current version: {sys.version_info.major}\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DFi8qSIL2xl"
      },
      "source": [
        "## Then again define your model and optimizer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "PixZ2s5QbYQ3"
      },
      "outputs": [],
      "source": [
        "model = tf.keras.models.Sequential([\n",
        "    # Note the input shape is the desired size of the image 100x100 with 3 bytes color\n",
        "    # This is the first convolution\n",
        "    tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(100, 100, 3)),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    # The second convolution\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    # The third convolution\n",
        "    tf.keras.layers.Conv2D(128, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    # The fourth convolution\n",
        "    tf.keras.layers.Conv2D(256, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    # Flatten the results to feed into a DNN\n",
        "    tf.keras.layers.Flatten(),\n",
        "    # 512 neuron hidden layer\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(256, activation='relu'),\n",
        "    # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('horses') and 1 for the other ('humans')\n",
        "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "FCO9TvtOPtH7",
        "outputId": "08d17eac-e71f-487f-a43a-83c3ea2ae5f8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 98, 98, 32)        896       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 49, 49, 32)        0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 47, 47, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 23, 23, 64)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 21, 21, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 10, 10, 128)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 8, 8, 256)         295168    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPoolin  (None, 4, 4, 256)         0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 4096)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               2097664   \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 256)               131328    \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 1)                 257       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2617665 (9.99 MB)\n",
            "Trainable params: 2617665 (9.99 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "print(model.summary())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "8DHWhFP_uhq3"
      },
      "outputs": [],
      "source": [
        "optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\n",
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer=optimizer,\n",
        "              metrics=['acc'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wKYbRjx8L2xl"
      },
      "source": [
        "## Now when we organize the data into Generators note how we use many more kinds of Data Augmentation!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "ClebU9NJg99G",
        "outputId": "f782edde-7f79-4507-91cb-22d8b53cd0a3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 1027 images belonging to 2 classes.\n",
            "Found 256 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "# All images will be augmented wiht the full list of augmentation techniques below\n",
        "train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(\n",
        "      rescale=1./255,\n",
        "      rotation_range=20,\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'\n",
        "      )\n",
        "\n",
        "# Flow training images in batches of 128 using train_datagen generator\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        '/tmp/horse-or-human/',  # This is the source directory for training images\n",
        "        target_size=(100, 100),  # All images will be resized to 300x300\n",
        "        batch_size=128,\n",
        "        # Since we use binary_crossentropy loss, we need binary labels\n",
        "        class_mode='binary')\n",
        "\n",
        "validation_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "validation_generator = validation_datagen.flow_from_directory(\n",
        "        '/tmp/validation-horse-or-human',\n",
        "        target_size=(100, 100),\n",
        "        class_mode='binary')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LcGH0D3CL2xm"
      },
      "source": [
        "## Train your model with the new augmented data\n",
        "Since we now have more data due to the data augmentation this training process will take a bit longer than the last time. However, you'll find that the results are much better!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "Fb1_lgobv81m",
        "outputId": "8ee7305f-4ce4-490e-cf9c-bbc5003fad5e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "8/8 [==============================] - 18s 1s/step - loss: 0.7058 - acc: 0.5172 - val_loss: 0.6930 - val_acc: 0.5000\n",
            "Epoch 2/10\n",
            "8/8 [==============================] - 16s 2s/step - loss: 0.6871 - acc: 0.5156 - val_loss: 0.6990 - val_acc: 0.5000\n",
            "Epoch 3/10\n",
            "8/8 [==============================] - 9s 1s/step - loss: 0.6758 - acc: 0.5451 - val_loss: 0.7094 - val_acc: 0.5000\n",
            "Epoch 4/10\n",
            "8/8 [==============================] - 9s 1s/step - loss: 0.6514 - acc: 0.6396 - val_loss: 0.6075 - val_acc: 0.5977\n",
            "Epoch 5/10\n",
            "8/8 [==============================] - 9s 973ms/step - loss: 0.6097 - acc: 0.6897 - val_loss: 0.6597 - val_acc: 0.5000\n",
            "Epoch 6/10\n",
            "8/8 [==============================] - 9s 1s/step - loss: 0.6215 - acc: 0.6674 - val_loss: 0.5234 - val_acc: 0.7617\n",
            "Epoch 7/10\n",
            "8/8 [==============================] - 9s 1s/step - loss: 0.5569 - acc: 0.7230 - val_loss: 0.7182 - val_acc: 0.5977\n",
            "Epoch 8/10\n",
            "8/8 [==============================] - 10s 1s/step - loss: 0.4505 - acc: 0.7753 - val_loss: 2.0966 - val_acc: 0.5000\n",
            "Epoch 9/10\n",
            "8/8 [==============================] - 8s 1s/step - loss: 0.3909 - acc: 0.8131 - val_loss: 1.8327 - val_acc: 0.5664\n",
            "Epoch 10/10\n",
            "8/8 [==============================] - 8s 1s/step - loss: 0.2851 - acc: 0.8810 - val_loss: 3.0540 - val_acc: 0.5586\n"
          ]
        }
      ],
      "source": [
        "history = model.fit(\n",
        "      train_generator,\n",
        "      steps_per_epoch=8,\n",
        "      epochs=100,\n",
        "      verbose=1,\n",
        "      validation_data=validation_generator)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o6vSHzPR2ghH"
      },
      "source": [
        "## Try Running the Model Again\n",
        "\n",
        "Can you confuse it this time? Or did the extra data augmentation help the model generalize? What do you think it was about your confusing examples that are no longer confusing (or what is still confusing)?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "DoWp43WxJDNT",
        "outputId": "27a1d4d2-5a14-4d91-c5b5-2df52000eae5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 39
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-74c86271-b05d-46d7-ba97-e0171b28b3c8\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-74c86271-b05d-46d7-ba97-e0171b28b3c8\">\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>// Copyright 2017 Google LLC\n",
              "//\n",
              "// 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",
              "//      http://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.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "import numpy as np\n",
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        "\n",
        "  # predicting images\n",
        "  path = '/content/' + fn\n",
        "  img = tf.keras.utils.load_img(path, target_size=(100, 100))\n",
        "  x = tf.keras.utils.img_to_array(img)\n",
        "  x = x / 255.0\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "\n",
        "  image_tensor = np.vstack([x])\n",
        "  classes = model.predict(image_tensor)\n",
        "  print(classes)\n",
        "  print(classes[0])\n",
        "  if classes[0]>0.5:\n",
        "    print(fn + \" is a human\")\n",
        "  else:\n",
        "    print(fn + \" is a horse\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DzVJDupFL2xm"
      },
      "source": [
        "## Finally again lets visualize some of the layers for intuition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "xV_9ZT7CL2xn",
        "outputId": "f3b18477-b83e-449e-f6b6-e8f6be0e7ee0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 494ms/step\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-13-3268f781e619>:48: RuntimeWarning: invalid value encountered in divide\n",
            "  x /= x.std()\n",
            "<ipython-input-13-3268f781e619>:51: RuntimeWarning: invalid value encountered in cast\n",
            "  x = np.clip(x, 0, 255).astype('uint8')\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x400 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABk0AAAFlCAYAAABGNK8cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqz0lEQVR4nO3dfZTWdZ0//ucgMGgxY6TMcDMgRYE33EWKQ7tKK4nocZm2bYltz6iL7Dd/sEcWa4tOiTe7O7Vm1pYLuoXUGqtZiS2Zhhi4Bt4Achbd4ogZUMugZczIlCMy1++PjlOTM4PTzjXDzeNxzufo9ble7/e8OOd6z/u6znM+16ekUCgUAgAAAAAAcIzr09sNAAAAAAAAHA6EJgAAAAAAABGaAAAAAAAAJBGaAAAAAAAAJBGaAAAAAAAAJBGaAAAAAAAAJBGaAAAAAAAAJBGaAAAAAAAAJBGaAAAAAAAAJBGaAAAAAAAAJCliaPLCCy/kgx/8YMrKynLiiSdm7ty52b9/f6djpk2blpKSkjbHhz70oWK1CAAAAAAA0KqkUCgUijHxzJkzs2fPntxyyy05cOBALrvsspx55plZuXJlh2OmTZuWt7/97bnuuutaz51wwgkpKysrRosAAAAAAACt+hZj0h/+8Ie577778vjjj+ed73xnkuQLX/hCLrzwwnzmM5/J0KFDOxx7wgknpLKyshhtAQAAAAAAdKgoocnGjRtz4okntgYmSTJ9+vT06dMnjz76aN773vd2OPZrX/tabr/99lRWVubiiy/OJz/5yZxwwgkd1jc3N6e5ubn1cUtLS1544YW8+c1vTklJSff8gwAAAAAAgCNSoVDIiy++mKFDh6ZPn87vWlKU0KS+vj6DBw9u+4P69s2gQYNSX1/f4bi//Mu/zMiRIzN06ND893//dz760Y9m+/bt+da3vtXhmLq6ulx77bXd1jsAAAAAAHD02b17d4YPH95pTZdCk4997GP59Kc/3WnND3/4w65M2cbf/M3ftP7/uHHjMmTIkJx33nl55pln8ta3vrXdMYsXL86iRYtaHzc0NGTEiBH5o1yYvun3B/cCAEDx7P7YlN5uAejApr/+Um+3cER679vH9XYLAAB04JUcyMO5NwMHDjxkbZdCk6uuuiqXXnpppzVvectbUllZmeeee65tU6+8khdeeKFL9yuZMuU3H6Z37NjRYWhSWlqa0tLS15zvm37pWyI0AQA4HB03YEBvtwB0oGxg519XQPt8/gQAOIwVfvOf13NLjy6FJieffHJOPvnkQ9ZVV1dn37592bx5cyZPnpwkefDBB9PS0tIahLweW7duTZIMGTKkK20CAAAAAAB0WVH+hOjUU0/NBRdckHnz5uWxxx7LD37wgyxYsCAf+MAHMnTo0CTJz372s4wdOzaPPfZYkuSZZ57J9ddfn82bN+cnP/lJvv3tb6e2tjbnnHNOxo8fX4w2AQAAAAAAWhXtuuuvfe1rGTt2bM4777xceOGF+aM/+qPceuutrc8fOHAg27dvz69+9askSf/+/fPAAw/k/PPPz9ixY3PVVVflfe97X/7zP/+zWC0CAAAAAAC06tLXc3XFoEGDsnLlyg6fP+WUU1IoFFofV1VVZf369cVqBwAAAAAAoFPu8AcAAAAAABChCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQBKhCQAAAAAAQJIeCk1uvvnmnHLKKRkwYECmTJmSxx57rNP6u+66K2PHjs2AAQMybty43HvvvT3RJgAAAAAAcAwremhy5513ZtGiRVmyZEm2bNmSCRMmZMaMGXnuuefard+wYUPmzJmTuXPn5oknnkhNTU1qamry5JNPFrtVAAAAAADgGFb00OSzn/1s5s2bl8suuyynnXZali1blhNOOCHLly9vt/7zn/98LrjggnzkIx/Jqaeemuuvvz7veMc78sUvfrHYrQIAAAAAAMewooYmL7/8cjZv3pzp06f/9gf26ZPp06dn48aN7Y7ZuHFjm/okmTFjRof1zc3NaWxsbHMAAAAAAAB0VVFDk5///Oc5ePBgKioq2pyvqKhIfX19u2Pq6+u7VF9XV5fy8vLWo6qqqnuaBwAAAAAAjik9ciP4Ylq8eHEaGhpaj927d/d2SwAAAAAAwBGobzEnP+mkk3Lcccdl7969bc7v3bs3lZWV7Y6prKzsUn1paWlKS0u7p2EAAAAAAOCYVdQrTfr375/Jkydn7dq1redaWlqydu3aVFdXtzumurq6TX2SrFmzpsN6AAAAAACA7lDUK02SZNGiRbnkkkvyzne+M2eddVY+97nPpampKZdddlmSpLa2NsOGDUtdXV2S5Morr8y5556bG2+8MRdddFHuuOOObNq0KbfeemuxWwUAAAAAAI5hRQ9NZs+eneeffz5XX3116uvrM3HixNx3332tN3vftWtX+vT57QUvU6dOzcqVK/OJT3wiH//4x/O2t70tq1atyhlnnFHsVgEAAAAAgGNYSaFQKPR2E92psbEx5eXlmZZZ6VvSr7fbAQCgHbuWTO3tFoAO/PD//Wtvt3BEmjF0Ym+3AABAB14pHMi63JOGhoaUlZV1WlvUe5oAAAAAAAAcKYQmAAAAAAAAEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAkEZoAAAAAAAAk6aHQ5Oabb84pp5ySAQMGZMqUKXnsscc6rF2xYkVKSkraHAMGDOiJNgEAAAAAgGNY0UOTO++8M4sWLcqSJUuyZcuWTJgwITNmzMhzzz3X4ZiysrLs2bOn9di5c2ex2wQAAAAAAI5xRQ9NPvvZz2bevHm57LLLctppp2XZsmU54YQTsnz58g7HlJSUpLKysvWoqKgodpsAAAAAAMAxrqihycsvv5zNmzdn+vTpv/2Bffpk+vTp2bhxY4fj9u/fn5EjR6aqqiqzZs3KU0891WFtc3NzGhsb2xwAAAAAAABd1beYk//85z/PwYMHX3OlSEVFRX70ox+1O2bMmDFZvnx5xo8fn4aGhnzmM5/J1KlT89RTT2X48OGvqa+rq8u1115blP4BAACONafe8v/1dgtHpBHZ0NstAADQDXrkRvBdUV1dndra2kycODHnnntuvvWtb+Xkk0/OLbfc0m794sWL09DQ0Hrs3r27hzsGAAAAAACOBkW90uSkk07Kcccdl71797Y5v3fv3lRWVr6uOfr165dJkyZlx44d7T5fWlqa0tLS/3OvAAAAAADAsa2oV5r0798/kydPztq1a1vPtbS0ZO3atamurn5dcxw8eDDbtm3LkCFDitUmAAAAAABAca80SZJFixblkksuyTvf+c6cddZZ+dznPpempqZcdtllSZLa2toMGzYsdXV1SZLrrrsuZ599dkaPHp19+/blhhtuyM6dO3P55ZcXu1UAAAAAAOAYVvTQZPbs2Xn++edz9dVXp76+PhMnTsx9993XenP4Xbt2pU+f317w8stf/jLz5s1LfX193vSmN2Xy5MnZsGFDTjvttGK3CgAAAAAAHMNKCoVCobeb6E6NjY0pLy/PtMxK35J+vd0OAADt2LVkam+3ANCtRly7obdbAACgA68UDmRd7klDQ0PKyso6rS3qPU0AAAAAAACOFEITAAAAAACACE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSCE0AAAAAAACSFDk0eeihh3LxxRdn6NChKSkpyapVqw45Zt26dXnHO96R0tLSjB49OitWrChmiwAAAAAAAEmKHJo0NTVlwoQJufnmm19X/bPPPpuLLroo7373u7N169YsXLgwl19+ee6///5itgkAAAAAAJC+xZx85syZmTlz5uuuX7ZsWUaNGpUbb7wxSXLqqafm4Ycfzk033ZQZM2YUq00AAAAAAIDD654mGzduzPTp09ucmzFjRjZu3NhLHQEAAAAAAMeKol5p0lX19fWpqKhoc66ioiKNjY359a9/neOPP/41Y5qbm9Pc3Nz6uLGxseh9AgAAAAAAR5/D6kqTP0RdXV3Ky8tbj6qqqt5uCQAAAAAAOAIdVqFJZWVl9u7d2+bc3r17U1ZW1u5VJkmyePHiNDQ0tB67d+/uiVYBAAAAAICjzGH19VzV1dW5995725xbs2ZNqqurOxxTWlqa0tLSYrcGAAAAAAAc5Yp6pcn+/fuzdevWbN26NUny7LPPZuvWrdm1a1eS31wlUltb21r/oQ99KD/+8Y/z93//9/nRj36Uf/3Xf83Xv/71/N3f/V0x2wQAAAAAAChuaLJp06ZMmjQpkyZNSpIsWrQokyZNytVXX50k2bNnT2uAkiSjRo3Kd77znaxZsyYTJkzIjTfemC996UuZMWNGMdsEAAAAAAAo7tdzTZs2LYVCocPnV6xY0e6YJ554oohdAQAAAAAAvNZhdSN4AAAAAACA3iI0AQAAAAAAiNAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgidAEAAAAAAAgSZFDk4ceeigXX3xxhg4dmpKSkqxatarT+nXr1qWkpOQ1R319fTHbBAAAAAAAKG5o0tTUlAkTJuTmm2/u0rjt27dnz549rcfgwYOL1CEAAAAAAMBv9C3m5DNnzszMmTO7PG7w4ME58cQTu78hAAAAAACADhyW9zSZOHFihgwZkve85z35wQ9+0Gltc3NzGhsb2xwAAAAAAABddViFJkOGDMmyZcvyzW9+M9/85jdTVVWVadOmZcuWLR2OqaurS3l5eetRVVXVgx0DAAAAAABHi6J+PVdXjRkzJmPGjGl9PHXq1DzzzDO56aab8u///u/tjlm8eHEWLVrU+rixsVFwAgAAAAAAdNlhFZq056yzzsrDDz/c4fOlpaUpLS3twY4AAAAAAICj0WH19Vzt2bp1a4YMGdLbbQAAAAAAAEe5ol5psn///uzYsaP18bPPPputW7dm0KBBGTFiRBYvXpyf/exn+epXv5ok+dznPpdRo0bl9NNPz0svvZQvfelLefDBB/O9732vmG0CAAAAAAAUNzTZtGlT3v3ud7c+fvXeI5dccklWrFiRPXv2ZNeuXa3Pv/zyy7nqqqvys5/9LCeccELGjx+fBx54oM0cAAAAAAAAxVBSKBQKvd1Ed2psbEx5eXmmZVb6lvTr7XYAAGjHriVTe7sFgG414toNvd0CAAAdeKVwIOtyTxoaGlJWVtZp7WF/TxMAAAAAAICeIDQBAAAAAACI0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACCJ0AQAAAAAACBJkUOTurq6nHnmmRk4cGAGDx6cmpqabN++/ZDj7rrrrowdOzYDBgzIuHHjcu+99xazTQAAAAAAgOKGJuvXr8/8+fPzyCOPZM2aNTlw4EDOP//8NDU1dThmw4YNmTNnTubOnZsnnngiNTU1qampyZNPPlnMVgEAAAAAgGNcSaFQKPTUD3v++eczePDgrF+/Puecc067NbNnz05TU1NWr17deu7ss8/OxIkTs2zZskP+jMbGxpSXl2daZqVvSb9u6x0AgO6za8nU3m4BoFuNuHZDb7cAAEAHXikcyLrck4aGhpSVlXVa26P3NGloaEiSDBo0qMOajRs3Zvr06W3OzZgxIxs3bmy3vrm5OY2NjW0OAAAAAACAruqx0KSlpSULFy7Mu971rpxxxhkd1tXX16eioqLNuYqKitTX17dbX1dXl/Ly8tajqqqqW/sGAAAAAACODT0WmsyfPz9PPvlk7rjjjm6dd/HixWloaGg9du/e3a3zAwAAAAAAx4a+PfFDFixYkNWrV+ehhx7K8OHDO62trKzM3r1725zbu3dvKisr260vLS1NaWlpt/UKAAAAAAAcm4p6pUmhUMiCBQty991358EHH8yoUaMOOaa6ujpr165tc27NmjWprq4uVpsAAAAAAADFvdJk/vz5WblyZe65554MHDiw9b4k5eXlOf7445MktbW1GTZsWOrq6pIkV155Zc4999zceOONueiii3LHHXdk06ZNufXWW4vZKgAAAAAAcIwr6pUmS5cuTUNDQ6ZNm5YhQ4a0HnfeeWdrza5du7Jnz57Wx1OnTs3KlStz6623ZsKECfnGN76RVatWdXrzeAAAAAAAgP+rol5pUigUDlmzbt2615x7//vfn/e///1F6AgAAAAAAKB9Rb3SBAAAAAAA4EghNAEAAAAAAIjQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIInQBAAAAAAAIEmRQ5O6urqceeaZGThwYAYPHpyampps37690zErVqxISUlJm2PAgAHFbBMAAAAAAKC4ocn69eszf/78PPLII1mzZk0OHDiQ888/P01NTZ2OKysry549e1qPnTt3FrNNAAAAAACA9C3m5Pfdd1+bxytWrMjgwYOzefPmnHPOOR2OKykpSWVlZTFbAwAAAAAAaKNH72nS0NCQJBk0aFCndfv378/IkSNTVVWVWbNm5amnnuqwtrm5OY2NjW0OAAAAAACAruqx0KSlpSULFy7Mu971rpxxxhkd1o0ZMybLly/PPffck9tvvz0tLS2ZOnVqfvrTn7ZbX1dXl/Ly8tajqqqqWP8EAAAAAADgKFZSKBQKPfGDrrjiinz3u9/Nww8/nOHDh7/ucQcOHMipp56aOXPm5Prrr3/N883NzWlubm593NjYmKqqqkzLrPQt6dctvQMA0L12LZna2y0AdKsR127o7RYAAOjAK4UDWZd70tDQkLKysk5ri3pPk1ctWLAgq1evzkMPPdSlwCRJ+vXrl0mTJmXHjh3tPl9aWprS0tLuaBMAAAAAADiGFfXruQqFQhYsWJC77747Dz74YEaNGtXlOQ4ePJht27ZlyJAhRegQAAAAAADgN4p6pcn8+fOzcuXK3HPPPRk4cGDq6+uTJOXl5Tn++OOTJLW1tRk2bFjq6uqSJNddd13OPvvsjB49Ovv27csNN9yQnTt35vLLLy9mqwAAAAAAwDGuqKHJ0qVLkyTTpk1rc/62227LpZdemiTZtWtX+vT57QUvv/zlLzNv3rzU19fnTW96UyZPnpwNGzbktNNOK2arAAAAAADAMa6oocnrucf8unXr2jy+6aabctNNNxWpIwAAAAAAgPYV9Z4mAAAAAAAARwqhCQAAAAAAQIQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYocmixdujTjx49PWVlZysrKUl1dne9+97udjrnrrrsyduzYDBgwIOPGjcu9995bzBYBAAAAAACSFDk0GT58eD71qU9l8+bN2bRpU/7kT/4ks2bNylNPPdVu/YYNGzJnzpzMnTs3TzzxRGpqalJTU5Mnn3yymG0CAAAAAACkpFAoFHryBw4aNCg33HBD5s6d+5rnZs+enaampqxevbr13Nlnn52JEydm2bJlr2v+xsbGlJeXZ1pmpW9Jv27rGwCA7rNrydTebgGgW424dkNvtwAAQAdeKRzIutyThoaGlJWVdVrbY/c0OXjwYO644440NTWlurq63ZqNGzdm+vTpbc7NmDEjGzdu7IkWAQAAAACAY1jfYv+Abdu2pbq6Oi+99FLe+MY35u67785pp53Wbm19fX0qKiranKuoqEh9fX2H8zc3N6e5ubn1cWNjY/c0DgAAAAAAHFOKfqXJmDFjsnXr1jz66KO54oorcskll+R//ud/um3+urq6lJeXtx5VVVXdNjcAAAAAAHDsKHpo0r9//4wePTqTJ09OXV1dJkyYkM9//vPt1lZWVmbv3r1tzu3duzeVlZUdzr948eI0NDS0Hrt37+7W/gEAAAAAgGNDj93T5FUtLS1tvk7rd1VXV2ft2rVtzq1Zs6bDe6AkSWlpacrKytocAAAAAAAAXVXUe5osXrw4M2fOzIgRI/Liiy9m5cqVWbduXe6///4kSW1tbYYNG5a6urokyZVXXplzzz03N954Yy666KLccccd2bRpU2699dZitgkAAAAAAFDc0OS5555LbW1t9uzZk/Ly8owfPz73339/3vOe9yRJdu3alT59fnuxy9SpU7Ny5cp84hOfyMc//vG87W1vy6pVq3LGGWcUs00AAAAAAICUFAqFQm830Z0aGxtTXl6eaZmVviX9ersdAADasWvJ1N5uAaBbjbh2Q2+3AABAB14pHMi63JOGhoZD3uKjx+9pAgAAAAAAcDgSmgAAAAAAAERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkERoAgAAAAAAkKTIocnSpUszfvz4lJWVpaysLNXV1fnud7/bYf2KFStSUlLS5hgwYEAxWwQAAAAAAEiS9C3m5MOHD8+nPvWpvO1tb0uhUMhXvvKVzJo1K0888UROP/30dseUlZVl+/btrY9LSkqK2SIAAAAAAECSIocmF198cZvH//iP/5ilS5fmkUce6TA0KSkpSWVlZTHbAgAAAAAAeI2ihia/6+DBg7nrrrvS1NSU6urqDuv279+fkSNHpqWlJe94xzvyT//0Tx0GLEnS3Nyc5ubm1scNDQ1JkldyICl0X/8AAHSfgy+91NstAHSrVwoHersFAAA68Ep+816tUDh0aFBSeD1V/wfbtm1LdXV1XnrppbzxjW/MypUrc+GFF7Zbu3Hjxjz99NMZP358Ghoa8pnPfCYPPfRQnnrqqQwfPrzdMddcc02uvfbaYv4TAAAAAACAI9zu3bs7zBpeVfTQ5OWXX86uXbvS0NCQb3zjG/nSl76U9evX57TTTjvk2AMHDuTUU0/NnDlzcv3117db8/tXmrS0tOSFF17Im9/85sPufiiNjY2pqqrK7t27U1ZW1tvtQK+wDjjWWQNgHUBiHUBiHYA1ANYBPadQKOTFF1/M0KFD06dPn05ri/71XP3798/o0aOTJJMnT87jjz+ez3/+87nlllsOObZfv36ZNGlSduzY0WFNaWlpSktL25w78cQT/089F1tZWZlfAhzzrAOOddYAWAeQWAeQWAdgDYB1QM8oLy9/XXWdRypF0NLS0ubKkM4cPHgw27Zty5AhQ4rcFQAAAAAAcKwr6pUmixcvzsyZMzNixIi8+OKLWblyZdatW5f7778/SVJbW5thw4alrq4uSXLdddfl7LPPzujRo7Nv377ccMMN2blzZy6//PJitgkAAAAAAFDc0OS5555LbW1t9uzZk/Ly8owfPz73339/3vOe9yRJdu3a1eb7w375y19m3rx5qa+vz5ve9KZMnjw5GzZseF33PzkSlJaWZsmSJa/5OjE4llgHHOusAbAOILEOILEOwBoA64DDU9FvBA8AAAAAAHAk6PF7mgAAAAAAAByOhCYAAAAAAAARmgAAAAAAACQRmgAAAAAAACQRmnS7m2++OaecckoGDBiQKVOm5LHHHuu0/q677srYsWMzYMCAjBs3Lvfee28PdQrdr66uLmeeeWYGDhyYwYMHp6amJtu3b+90zIoVK1JSUtLmGDBgQA91DN3vmmuuec1reuzYsZ2OsRdwNDnllFNeswZKSkoyf/78duvtAxwNHnrooVx88cUZOnRoSkpKsmrVqjbPFwqFXH311RkyZEiOP/74TJ8+PU8//fQh5+3qZwvoTZ2tgwMHDuSjH/1oxo0blze84Q0ZOnRoamtr87//+7+dzvmHvK+C3nSo/eDSSy99zWv6ggsuOOS89gOOFIdaA+19TigpKckNN9zQ4Zz2AnqD0KQb3XnnnVm0aFGWLFmSLVu2ZMKECZkxY0aee+65dus3bNiQOXPmZO7cuXniiSdSU1OTmpqaPPnkkz3cOXSP9evXZ/78+XnkkUeyZs2aHDhwIOeff36ampo6HVdWVpY9e/a0Hjt37uyhjqE4Tj/99Dav6YcffrjDWnsBR5vHH3+8zet/zZo1SZL3v//9HY6xD3Cka2pqyoQJE3LzzTe3+/w///M/51/+5V+ybNmyPProo3nDG96QGTNm5KWXXupwzq5+toDe1tk6+NWvfpUtW7bkk5/8ZLZs2ZJvfetb2b59e/70T//0kPN25X0V9LZD7QdJcsEFF7R5Tf/Hf/xHp3PaDziSHGoN/O5rf8+ePVm+fHlKSkryvve9r9N57QX0tJJCoVDo7SaOFlOmTMmZZ56ZL37xi0mSlpaWVFVV5W//9m/zsY997DX1s2fPTlNTU1avXt167uyzz87EiROzbNmyHusbiuX555/P4MGDs379+pxzzjnt1qxYsSILFy7Mvn37erY5KJJrrrkmq1atytatW19Xvb2Ao93ChQuzevXqPP300ykpKXnN8/YBjjYlJSW5++67U1NTk+Q3V5kMHTo0V111VT784Q8nSRoaGlJRUZEVK1bkAx/4QLvzdPWzBRxOfn8dtOfxxx/PWWedlZ07d2bEiBHt1nT1fRUcTtpbB5deemn27dv3mr++74z9gCPV69kLampq8uKLL2bt2rUd1tgL6A2uNOkmL7/8cjZv3pzp06e3nuvTp0+mT5+ejRs3tjtm48aNbeqTZMaMGR3Ww5GmoaEhSTJo0KBO6/bv35+RI0emqqoqs2bNylNPPdUT7UHRPP300xk6dGje8pa35IMf/GB27drVYa29gKPZyy+/nNtvvz1//dd/3W5g8ir7AEezZ599NvX19W1+15eXl2fKlCkd/q7/Qz5bwJGmoaEhJSUlOfHEEzut68r7KjgSrFu3LoMHD86YMWNyxRVX5Be/+EWHtfYDjmZ79+7Nd77zncydO/eQtfYCeprQpJv8/Oc/z8GDB1NRUdHmfEVFRerr69sdU19f36V6OJK0tLRk4cKFede73pUzzjijw7oxY8Zk+fLlueeee3L77benpaUlU6dOzU9/+tMe7Ba6z5QpU7JixYrcd999Wbp0aZ599tn88R//cV588cV26+0FHM1WrVqVffv25dJLL+2wxj7A0e7V3+dd+V3/h3y2gCPJSy+9lI9+9KOZM2dOysrKOqzr6vsqONxdcMEF+epXv5q1a9fm05/+dNavX5+ZM2fm4MGD7dbbDziafeUrX8nAgQPzZ3/2Z53W2QvoDX17uwHg6DR//vw8+eSTh/yeyerq6lRXV7c+njp1ak499dTccsstuf7664vdJnS7mTNntv7/+PHjM2XKlIwcOTJf//rXX9df0MDR5Mtf/nJmzpyZoUOHdlhjHwA4thw4cCB/8Rd/kUKhkKVLl3Za630VR5vf/UrGcePGZfz48XnrW9+adevW5bzzzuvFzqDnLV++PB/84AczYMCATuvsBfQGV5p0k5NOOinHHXdc9u7d2+b83r17U1lZ2e6YysrKLtXDkWLBggVZvXp1vv/972f48OFdGtuvX79MmjQpO3bsKFJ30LNOPPHEvP3tb+/wNW0v4Gi1c+fOPPDAA7n88su7NM4+wNHm1d/nXfld/4d8toAjwauByc6dO7NmzZpOrzJpz6HeV8GR5i1veUtOOumkDl/T9gOOVv/1X/+V7du3d/mzQmIvoGcITbpJ//79M3ny5DY3LmppacnatWvb/PXk76qurn7NjY7WrFnTYT0c7gqFQhYsWJC77747Dz74YEaNGtXlOQ4ePJht27ZlyJAhRegQet7+/fvzzDPPdPiathdwtLrtttsyePDgXHTRRV0aZx/gaDNq1KhUVla2+V3f2NiYRx99tMPf9X/IZws43L0amDz99NN54IEH8uY3v7nLcxzqfRUcaX7605/mF7/4RYevafsBR6svf/nLmTx5ciZMmNDlsfYCeoLQpBstWrQo//Zv/5avfOUr+eEPf5grrrgiTU1Nueyyy5IktbW1Wbx4cWv9lVdemfvuuy833nhjfvSjH+Waa67Jpk2bsmDBgt76J8D/yfz583P77bdn5cqVGThwYOrr61NfX59f//rXrTW/vw6uu+66fO9738uPf/zjbNmyJX/1V3+VnTt3/kF/bQCHgw9/+MNZv359fvKTn2TDhg1573vfm+OOOy5z5sxJYi/g2NDS0pLbbrstl1xySfr2bfttsPYBjkb79+/P1q1bs3Xr1iS/ufn71q1bs2vXrpSUlGThwoX5h3/4h3z729/Otm3bUltbm6FDh6ampqZ1jvPOOy9f/OIXWx8f6rMFHG46WwcHDhzIn//5n2fTpk352te+loMHD7Z+Vnj55Zdb5/j9dXCo91VwuOlsHezfvz8f+chH8sgjj+QnP/lJ1q5dm1mzZmX06NGZMWNG6xz2A45kna2BVzU2Nuauu+7q8P2+vYDDQoFu9YUvfKEwYsSIQv/+/QtnnXVW4ZFHHml97txzzy1ccsklbeq//vWvF97+9rcX+vfvXzj99NML3/nOd3q4Y+g+Sdo9brvtttaa318HCxcubF0zFRUVhQsvvLCwZcuWnm8eusns2bMLQ4YMKfTv378wbNiwwuzZsws7duxofd5ewLHg/vvvLyQpbN++/TXP2Qc4Gn3/+99v9z3Qq6/1lpaWwic/+clCRUVFobS0tHDeeee9Zn2MHDmysGTJkjbnOvtsAYebztbBs88+2+Fnhe9///utc/z+OjjU+yo43HS2Dn71q18Vzj///MLJJ59c6NevX2HkyJGFefPmFerr69vMYT/gSHao90SFQqFwyy23FI4//vjCvn372p3DXsDhoKRQKBSKnswAAAAAAAAc5nw9FwAAAAAAQIQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASYQmAAAAAAAASZL/HxG70ARjPIitAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import random\n",
        "import numpy as np\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "# Let's define a new Model that will take an image as input, and will output\n",
        "# intermediate representations for all layers in the previous model after the first.\n",
        "successive_outputs = [layer.output for layer in model.layers[1:]]\n",
        "visualization_model = tf.keras.models.Model(inputs = model.input, outputs = successive_outputs)\n",
        "# Let's prepare a random input image from the training set.\n",
        "horse_img_files = [os.path.join(train_horse_dir, f) for f in train_horse_names]\n",
        "human_img_files = [os.path.join(train_human_dir, f) for f in train_human_names]\n",
        "img_path = random.choice(horse_img_files + human_img_files)\n",
        "# uncomment the following line if you want to pick the Xth human file manually\n",
        "# img_path = human_img_files[0]\n",
        "\n",
        "img = tf.keras.preprocessing.image.load_img(img_path, target_size=(100, 100))  # this is a PIL image\n",
        "x = tf.keras.preprocessing.image.img_to_array(img)  # Numpy array with shape (100, 100, 3)\n",
        "x = x.reshape((1,) + x.shape)  # Numpy array with shape (1, 100, 100, 3)\n",
        "\n",
        "# Rescale by 1/255\n",
        "x /= 255.0\n",
        "\n",
        "# Let's run our image through our network, thus obtaining all\n",
        "# intermediate representations for this image.\n",
        "successive_feature_maps = visualization_model.predict(x)\n",
        "\n",
        "# These are the names of the layers, so can have them as part of our plot\n",
        "layer_names = [layer.name for layer in model.layers[1:]]\n",
        "\n",
        "# Now let's display our representations\n",
        "for layer_name, feature_map in zip(layer_names, successive_feature_maps):\n",
        "  if len(feature_map.shape) == 4:\n",
        "    # Just do this for the conv / maxpool layers, not the fully-connected layers\n",
        "    n_features = feature_map.shape[-1]  # number of features in feature map\n",
        "    n_features = min(n_features,5) # limit to 5 features for easier viewing\n",
        "    # The feature map has shape (1, size, size, n_features)\n",
        "    size = feature_map.shape[1]\n",
        "    # We will tile our images in this matrix\n",
        "    display_grid = np.zeros((size, size * n_features))\n",
        "    for i in range(n_features):\n",
        "      # Postprocess the feature to make it visually palatable\n",
        "      x = feature_map[0, :, :, i]\n",
        "      x -= x.mean()\n",
        "      x /= x.std()\n",
        "      x *= 64\n",
        "      x += 128\n",
        "      x = np.clip(x, 0, 255).astype('uint8')\n",
        "      # We'll tile each filter into this big horizontal grid\n",
        "      display_grid[:, i * size : (i + 1) * size] = x\n",
        "    # Display the grid\n",
        "    scale = 20. / n_features\n",
        "    plt.figure(figsize=(scale * n_features, scale))\n",
        "    #plt.title(layer_name)\n",
        "    plt.grid(False)\n",
        "    plt.imshow(display_grid, aspect='auto', cmap='viridis')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j4IBgYCYooGD"
      },
      "source": [
        "## Clean Up\n",
        "\n",
        "Before running the next exercise, run the following cell to terminate the kernel and free memory resources:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "651IgjLyo-Jx"
      },
      "outputs": [],
      "source": [
        "import os, signal\n",
        "os.kill(os.getpid(), signal.SIGKILL)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "machine_shape": "hm",
      "name": "2-4-6-HorseOrHumanWithAugmentation",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}