Copy_of_Lab6_Cats_v_Dogs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Lab6-Cats-v-Dogs.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/darennie/casa0018/blob/main/Copy_of_Lab6_Cats_v_Dogs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7v55rWlQehzL"
      },
      "source": [
        "## Training with a Larger Dataset - Cats and Dogs\n",
        "\n",
        "In the previous lab you trained a classifier with a horses-v-humans dataset. You saw that despite getting great training results, when you tried to do classification with real images, there were many errors, due primarily to overfitting -- where the network  does very well with data that it has previously seen, but poorly with data it hasn't!\n",
        "\n",
        "In this lab you'll look at a real, and very large dataset, and see the impact this has to avoid overfitting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dn-6c02VmqiN"
      },
      "source": [
        "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": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3sd9dQWa23aj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "31c7664f-4c15-4f74-a05c-02de49043e4e"
      },
      "source": [
        "# If the URL doesn't work, 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 to the dataset\n",
        "\n",
        "# Note: This is a very large dataset and will take time to download\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": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2021-01-18 22:56:16--  https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip\n",
            "Resolving download.microsoft.com (download.microsoft.com)... 23.46.53.60, 2600:1408:3000:28b::e59, 2600:1408:3000:294::e59\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|23.46.53.60|: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   281MB/s    in 2.8s    \n",
            "\n",
            "2021-01-18 22:56:19 (281 MB/s) - ‘/tmp/cats-and-dogs.zip’ saved [824894548/824894548]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DM851ZmN28J3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b1406e2-c548-4a6c-8663-a765a23a66ce"
      },
      "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": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12501\n",
            "12501\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-QkLjxpmyK2"
      },
      "source": [
        "try:\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": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zvSODo0f9LaU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "021ec2bb-bd41-4827-9942-bd37de7f8e53"
      },
      "source": [
        "def split_data(SOURCE, TRAINING, TESTING, SPLIT_SIZE):\n",
        "    files = []\n",
        "    for filename in os.listdir(SOURCE):\n",
        "        file = SOURCE + filename\n",
        "        if os.path.getsize(file) > 0:\n",
        "            files.append(filename)\n",
        "        else:\n",
        "            print(filename + \" is zero length, so ignoring.\")\n",
        "\n",
        "    training_length = int(len(files) * SPLIT_SIZE)\n",
        "    testing_length = int(len(files) - training_length)\n",
        "    shuffled_set = random.sample(files, len(files))\n",
        "    training_set = shuffled_set[0:training_length]\n",
        "    testing_set = shuffled_set[-testing_length:]\n",
        "\n",
        "    for filename in training_set:\n",
        "        this_file = SOURCE + filename\n",
        "        destination = TRAINING + filename\n",
        "        copyfile(this_file, destination)\n",
        "\n",
        "    for filename in testing_set:\n",
        "        this_file = SOURCE + filename\n",
        "        destination = TESTING + filename\n",
        "        copyfile(this_file, destination)\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": 5,
      "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": {
        "id": "hwHXFhVG3786",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9a93d317-83dc-42b5-d358-d5e3b321362d"
      },
      "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": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11250\n",
            "11250\n",
            "1250\n",
            "1250\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-BQrav4anTmj"
      },
      "source": [
        "model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(150, 150, 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.Flatten(),\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['acc'])\n"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fQrZfVgz4j2g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4407d7e3-c8a7-45ae-c1dc-3c125f413ed0"
      },
      "source": [
        "\n",
        "TRAINING_DIR = \"/tmp/cats-v-dogs/training/\"\n",
        "train_datagen = ImageDataGenerator(rescale=1.0/255.)\n",
        "train_generator = train_datagen.flow_from_directory(TRAINING_DIR,\n",
        "                                                    batch_size=250,\n",
        "                                                    class_mode='binary',\n",
        "                                                    target_size=(150, 150))\n",
        "\n",
        "VALIDATION_DIR = \"/tmp/cats-v-dogs/testing/\"\n",
        "validation_datagen = ImageDataGenerator(rescale=1.0/255.)\n",
        "validation_generator = validation_datagen.flow_from_directory(VALIDATION_DIR,\n",
        "                                                              batch_size=250,\n",
        "                                                              class_mode='binary',\n",
        "                                                              target_size=(150, 150))\n",
        "\n",
        "# Expected Output:\n",
        "# Found 22498 images belonging to 2 classes.\n",
        "# Found 2500 images belonging to 2 classes."
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found 22499 images belonging to 2 classes.\n",
            "Found 2499 images belonging to 2 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5qE1G6JB4fMn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e89e64a4-0f73-41d8-d90d-4c98d525262d"
      },
      "source": [
        "# Note that this may take some time.\n",
        "history = model.fit(train_generator, epochs=15, steps_per_epoch=90,\n",
        "                    validation_data=validation_generator, validation_steps=6)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "26/90 [=======>......................] - ETA: 43s - loss: 2.6154 - acc: 0.5084"
          ],
          "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": [
            "90/90 [==============================] - 77s 773ms/step - loss: 1.4883 - acc: 0.5310 - val_loss: 0.6291 - val_acc: 0.6760\n",
            "Epoch 2/15\n",
            "90/90 [==============================] - 68s 759ms/step - loss: 0.6431 - acc: 0.6439 - val_loss: 0.5787 - val_acc: 0.6853\n",
            "Epoch 3/15\n",
            "90/90 [==============================] - 68s 754ms/step - loss: 0.5813 - acc: 0.7044 - val_loss: 0.5410 - val_acc: 0.7120\n",
            "Epoch 4/15\n",
            "90/90 [==============================] - 68s 751ms/step - loss: 0.5095 - acc: 0.7464 - val_loss: 0.5467 - val_acc: 0.7313\n",
            "Epoch 5/15\n",
            "90/90 [==============================] - 68s 753ms/step - loss: 0.4686 - acc: 0.7790 - val_loss: 0.4781 - val_acc: 0.7700\n",
            "Epoch 6/15\n",
            "90/90 [==============================] - 67s 748ms/step - loss: 0.4176 - acc: 0.8081 - val_loss: 0.4479 - val_acc: 0.7913\n",
            "Epoch 7/15\n",
            "90/90 [==============================] - 68s 751ms/step - loss: 0.3827 - acc: 0.8263 - val_loss: 0.7123 - val_acc: 0.7133\n",
            "Epoch 8/15\n",
            "90/90 [==============================] - 68s 755ms/step - loss: 0.3290 - acc: 0.8580 - val_loss: 0.4835 - val_acc: 0.7780\n",
            "Epoch 9/15\n",
            "90/90 [==============================] - 68s 751ms/step - loss: 0.2571 - acc: 0.8930 - val_loss: 0.4322 - val_acc: 0.8220\n",
            "Epoch 10/15\n",
            "90/90 [==============================] - 68s 752ms/step - loss: 0.2150 - acc: 0.9132 - val_loss: 0.5518 - val_acc: 0.7833\n",
            "Epoch 11/15\n",
            "90/90 [==============================] - 67s 747ms/step - loss: 0.1649 - acc: 0.9377 - val_loss: 0.5137 - val_acc: 0.7947\n",
            "Epoch 12/15\n",
            "90/90 [==============================] - 68s 751ms/step - loss: 0.1282 - acc: 0.9528 - val_loss: 0.6572 - val_acc: 0.7920\n",
            "Epoch 13/15\n",
            "90/90 [==============================] - 68s 752ms/step - loss: 0.1193 - acc: 0.9583 - val_loss: 1.0557 - val_acc: 0.7167\n",
            "Epoch 14/15\n",
            "90/90 [==============================] - 68s 750ms/step - loss: 0.1033 - acc: 0.9621 - val_loss: 0.6791 - val_acc: 0.8027\n",
            "Epoch 15/15\n",
            "90/90 [==============================] - 68s 750ms/step - loss: 0.0657 - acc: 0.9833 - val_loss: 0.7490 - val_acc: 0.8033\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 563
        },
        "outputId": "5a21ff21-0ccc-412c-bc83-9d23c62f4912"
      },
      "source": [
        "%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['acc']\n",
        "val_acc=history.history['val_acc']\n",
        "loss=history.history['loss']\n",
        "val_loss=history.history['val_loss']\n",
        "\n",
        "epochs=range(len(acc)) # 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",
        "plt.figure()\n",
        "\n",
        "\n",
        "# Desired output. Charts with training and validation metrics. No crash :)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "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": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAD4CAYAAAC0VQLEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhUVdIG8LeSsAriABEkoOwZBUEhgBuKbCJboyKi4giOIDoaRB039FN00HEZAREXVARHFgVF1IRVQEFUCPsia5BdEEEkCAGS+v6o7kkI2SDdfe/tvL/n6SdJp/veCiRdfc6tU0dUFURERF4R5XQAREREp4OJi4iIPIWJi4iIPIWJi4iIPIWJi4iIPCXG6QCKg8qVK2vNmjWdDoOIyFOWLFmyT1Vjc97PxBUGNWvWREpKitNhEBF5iohsze1+ThUSEZGnMHEREZGnMHEREZGnMHEREZGnMHEREZGnMHEREZGnMHEREZGnMHEREXnE3LnAsmVOR+E8LkAmIvKAjAzg5puBWrWAxYudjsZZTFxERB6waBHw229227kTiItzOiLncKqQiMgDkpKyPv/yS+ficAMmLiIiD0hOBlq2BOrUAaZOdToaZzFxERG53K5dVpTRqRPg8wFz5gCHDjkdlXOYuIiIXG7aNPvYsaMlrmPHgOnTnY3JSUxcREQul5QE1KgBNGwIXHEFUKlS8Z4uZOIiInKx9HRg1iybJhQBYmKAzp0tmR0/7nR0zsg3cYnIXBG5Lsd9D4rIW/k8Z56IJPg/TxaRc3J5zLMi8kgB5+4mIhdl+/o5EWmb33MKQ0RaichXRT0OEVE4LFgApKXZNGFA167A778D8+c7F5eTChpxTQDQM8d9Pf33F0hVO6rq72cSGIBuAP6XuFT1/1R19hkei4jIk5KSgFKlgNats+5r397uK67ThQUlrskAOolISQAQkZoAqgGYLyJviUiKiKwRkcG5PVlEfhaRyv7PB4nIBhFZACA+22P6ishiEVkhIp+KSFkRuQJAVwCviMhyEakjImNEpLv/OW1EZJmIrBKR0SJSKtv5BovIUv/3/lrYfwgRudX/nNUi8pL/vmj/eVf7vzfQf3+iiKwVkZUiMrGw5yAiOl3JyUCrVsBZZ2XdV64c0LatJS5Vx0JzTL6JS1X3A1gE4Hr/XT0BfKKqCmCQqiYAaATgGhFplNdxRKSp/7mXAOgIoFm2b3+mqs1UtTGAnwD8XVUXAvgCwD9V9RJV3ZztWKUBjAFwi6peDOv+cW+24+1T1SYA3gKQ73RktmNWA/ASgNb+GJuJSDf/53Gq2tB/rg/8T3kcwKWq2ghA/zyO2c+f2FN+/fXXwoRBRHSSzZuB9evt+lZOPh+wdSuwcmX443JaYYozsk8XZp8m7CEiSwEsA9AA2ab1ctESwBRV/VNV/4AlpYCGIjJfRFYBuN1/rPzEA9iiqhv8X48FcHW273/m/7gEQM0CjhXQDMA8Vf1VVU8AGOc/ZiqA2iIyQkQ6APjD//iVAMaJSC8AJ3I7oKqOUtUEVU2IjY0tZBhERFkC3TKyX98K6NLFijWK43RhYRLXVABtRKQJgLKqukREasFGM238o44kAKXPMIYxAO73j2gGF+E4Aen+jxkoYi9GVT0AoDGAebCR1Xv+b3UCMBJAEwCLRYQ9H4ko6JKTgfh465aRU9WqQIsWwBdfnPq9SFdg4lLVNABzAYxG1mjrbACHARwUkSrImkrMy7cAuolIGREpD6BLtu+VB7BbRErARlwBh/zfy2k9gJoiUtf/9R0Avino5yjAIth0Z2URiQZwK4Bv/NfnolT1UwBPAWgiIlEAaqjqXACPAagAoFwRz09EdJLDh4F583KfJgzw+YAlS4AdO8IWlisUdh3XBNjIYwIAqOoK2BThOgDjAXyX35NVdSmAjwGsADANQPam/E8D+NF/jHXZ7p8I4J/+Iow62Y51FEAfAJP804uZAN4u5M8R0EZEdgRusCnFx2EJegWAJao6FUAcgHkishzARwCeABAN4CP/uZcBeL0IlZNERLmaM8fWcOU2TRjg89nH4jbqEi2OJSlhlpCQoCkpKU6HQUQe0r8/MG6cbWNSsmTuj1G1qcRatYAZM8IbXziIyBJ/EeBJ2DmDiMhlVK0wo127vJMWYMUZPp/tjHzwYPjicxoTFxGRy6xebdet8ru+FeDzWeun4tR0l4mLiMhlAmXw1xdU9gbg8suBypWLV1k8ExcRkcskJwOXXgpUq1bwY6OjrelucnLxabrLxEVE5CIHDgALFxZumjDA57NrXN8UdWGQRzBxERG5yMyZQEZG/mXwObVrB5QuXXymC5m4iIhcJCnJNops3rzwzznrLEtexaXpLhMXEZFLZGQA06YBHTrYtavT4fMB27cDK1aEJjY3YeIiInKJlBRg377Tu74V0Llz8Wm6y8RFROQSSUlAVBRw3XUFPzanKlWsNJ6Ji4iIwiY52ZJPxYpn9nyfD1i2DNi2LbhxuQ0TFxGRC+zebZ3ez2SaMKC4NN1l4iIicoFp0+zj6ZTB5xQfb7dIny5k4nK7E7lusExEESY5GYiLAxo1KtpxfD7bx+v3CN5siYnLze66C+je3ekoiCjEjh2zhccdO1plYFH4fPZ+NzCCi0RMXG5WvbpNVm/e7HQkRBRC330HHDpUtOtbAS1aALGxkT1dyMTlZv372yrEkSOdjoSIQigpyfbdatOm6MeKjga6dLER17FjRT+eGzFxuVm1ajZV+P77QFqa09EQUYgkJQHXXAOUKxec4/l8wB9/2LWuSMTE5XaJifYb+OGHTkdCRCGQmgqsWxecacKAtm2BMmUityyeicvtLrsMSEgARowoHt0ziYqZ5GT7WJQy+JzKlgXat7fEFYkvG0xcbidio65164DZs52OhoiCLDkZqFfPbsEUaLq7bFlwj+sGTFxe0KMHcO65wOuvOx0JEQXRn38Cc+cGd5owoHNn63sYidWFTFxeUKqUVRgmJQGbNjkdDREFyZw5wNGjwZ0mDIiNBa64gomLnMTSeKKIk5xsm0BefXVoju/z2f5cP/8cmuM7hYnLK847z6YMR4+2lYpE5GmqNonStq1NqoRCpDbdZeLyEpbGE0WMtWtt+5FQXN8KqFcPuPDCyJsuZOLykhYtgGbNrDQ+M9PpaIioCJKS7OP114f2PD4f8M03wIEDoT1PODFxeU1iIrB+PTBrltOREFERJCcDjRtbS9JQ6toVyMjIWi8WCZi4vObmm22PbpbGE3nW778DCxaEdpowoEULe8mIpOlCJi6vCZTGJycDGzc6HQ0RnYGZM20UFIoy+JyiorKa7qanh/584cDE5UX33AOUKMHSeCKPSk4GKla0jm7h4PNZn+5IabrLxOVFLI0n8qzMTBv9XHedLc0MhzZtrH9hpEwXMnF5VWKiJa2xY52OhIhOw5IlwN694bm+FVCmjCXKSGm6y8TlVc2b21VXlsYTeUpSkvXOvu668J7X5wN27rTE6XVMXF6WmAhs2GBXeonIE5KS7NpW5crhPW+nTpHTdJeJy8u6dweqVmVpPJFH7NkDpKSEd5owoHJl4KqrmLjIaSVLWmn8tGk28iIiV5s2zT6Goww+Nz4fsGoVsGWLM+cPFiYurwuUxr/xhtOREFEBkpOtKPiSS5w5f6DprtdHXUxcXle1KnDLLcAHH1gDXiJypePHgRkzbLQl4kwMdeoAF13ExEVukJhoqwtZGk/kWt99Z+8tnbi+lZ3PB8yfD+zfH/pzbd4cmuMycUWCZs2sTIml8USulZxss/pt2zobh89n7aYC3elDYdcu4LbbgPh428gy2Ji4IkViovUunDHD6UiIKBdJSbbTcfnyzsbRrJldZwvF5pLHjwNDhwJ//Svw2WfAoEFA/frBPw8TV6S46Sb7bWRpPJHr/PyzbRzp9DQhkNV0d/r04Dbd/fZboEkT4KGHrOx+9Wpg8GDr2hFsTFyRomRJ4N577bdx/XqnoyGibAJ7YTlVBp9ToOnunDlFP9YvvwB33AFcc411ofv8cxtd1q1b9GPnhYkrkvTrZwmMpfFErpKUZBV9oZg2OxOtWwNnnVW06sITJ4Dhw+061iefAE89ZaNKny/0VZNMXJGkShUrjR8zBjh40OloiAjAkSM2snGyDD6n0qWBDh3sOteZ1HMtWGDTgg8+CFx+uU0LPv+8daAPByauSPPAAzYHMGaM05FQEO3c6XQEdKbmzgWOHnXH9a3sfD5g925rQVVYe/YAd94JtGxpuzh/+ql1A6lXL3Rx5oaJK9I0a2ZvgVgaHzG+/BKoXj3rOgl5S3KyjUSuucbpSE7WqZPtB1aY6cITJ+wlJT4emDABeOIJ4KefgBtvdGYUycQViRITbeVfoDEaedqrr9rHp56KjL2UihNVu77Vpo1Nz7lJxYo2cioocS1cCCQk2MtK8+bW6/CFF+wamVOYuCLRTTcB1arZWyTytKVLrcz48suBZcu836qnuFm3zkrh3TZNGODzAWvW5N7hYu9eoE8f4Morgd9+AyZNsmWi8fHhjzMnJq5IVKKElcbPmGF/OeRZw4YB5crZdGH9+sAzz3AG2EsC3Smuv97ZOPLStat9zP6GKCMDGDnSEtRHHwGPPWbTgt27u6e4hIkrUrE03vN27wYmTrR3vZUqWdJaudI6EpA3JCUBF18MnH++05HkrnZtoGHDrMT1ww92mfz++61qcOVK4N//tjdPbsLEFanOPRe49VaWxnvYm2/aRfHERPv6lluACy+0BJaR4WxsVLCDB61s3C2LjvPi81mcd95pU9J79gAffwzMnm2/b27ExBXJHngAOHzYtjwhTzlyBHj7bWvNE+hAEB0NPPusLfKcNMnR8KgQZs2yNx5uvb4V4PPZ9PP48cAjj9jVhR493DMtmBtRlimFXEJCgqaczmKJYLrySuvJsmGDvfKRJ7z3HtC3ry1cvfbarPszM4HGja2Z6Zo1/C91s7vuAqZMAX79FYiJcTqavKkCH35olYMNGjgdzclEZImqJuS8nyOuSJeYCKSmsjTeQ1StKKNxY6BVq5O/FxVlo6716209DblTZqat37ruOncnLcBGVnfe6b6klR8mrkh3441WGs+u8Z4xe7aNph58MPfpmhtusKQ2eLBNRZH7LF1q14rcPk3oVUxcka5ECeC++2zCfe1ap6OhQhg2LKu2JjdRUZa0Nm2ycmVyn/Hj7U1Hhw5ORxKZmLiKg379gFKlWBrvAevX2xTTfffZf1leuna1cuXnnrPrXeQeU6faZop33gnExjodTWRi4ioOYmPt7fuHH1pnTHKt4cOztlbLj4glrS1bgLFjwxMbFWztWqBXLyt0ePNNp6OJXExcxQVL411v/35LQrffblOFBenY0XrHPf88cOxY6OOj/B04YKXlZcvaIvFQ7PxLhomruGjSxPbTfuMNrl51qXffBf7804oyCiMw6tq2DRg9OrSxUf4yMoDbbgO2brWtPmrUcDqiyMbE5WJDh1rp8y+/BOmAgdJ47o/hOseP23uK1q2BRo0K/7z27YErrgCGDAHS00MXH+XvySeB6dOtr/VVVzkdTeRj4nKxFSuseuyCC+xC79KlRTxgt25AXBxL413os8+AHTsKP9oKCIy6duywRcsUfhMmAC+/DPTvD9xzj9PRFA9MXC42ZoxVmfXrZ9MPTZva/jmTJ5/h+p1AaXxgoRC5xtCh1trpTNb9tG4NXH217ZF05EjwY6O8LVsG/P3vNsoaPtzpaIoPJi6Xq1/fph927gRee80+3nwzUKeOvcvbv/80D9i3r101btsWeOcd1lK7wA8/AD/+CAwYYGu0Tldg1LVrFzBqVPDjo9zt3WuTGJUq2ZvJkiWdjqj4YOLyiAoVgIEDgY0bgc8/t+0IHnvMLgL3738aa4tjY4F58yzz9e9vexp8+im31nXQ0KH2/9u795kf45prbOT14otW4EGhdfy4vYHcu9f+HqtUcTqi4oWJy2Oio63kdu5cYPlyoGdPm1Js0MD6oiUnF2KjwebNgfnzbaVkdLTtEHf55bbVLoXVtm32vqFv36LveTR4sLUZeuut4MRGeRs40P5c3nvPpvApvJi4PKxxY+D994Ht24F//QtYvdqukVx4oVWopaXl82QRa7+wcqUdZMcOe9veuTOwalXYfobibuRI+/jAA0U/1lVXWZXhSy8V8H9PRfL++/b/9vDDtuaOwo+JKwLExgKDBlkXhfHjgXPOsRfCuDjgoYfs/jzFxNj+Cxs22FanCxZYRuzTx4YDFDJpaXZN6sYbg7dD7uDBto1GICFScC1caF1N2rWzPxdyBhNXBClZ0jo7/fgj8P331llhxAirVrvhBru0leelrLJl7aJZaqplu/HjrTLkn/88gwoQKoxAB66BA4N3zMsuA66/3gp3/vgjeMclK4y66Sa7rjxxovu3K4lkTFwR6rLLbH3Jzz8Djz9ul7SuvRa45BLrspDnBfyKFYFXX7URWM+ewH/+k1XCyFrroMnMtC7wzZvb/1UwDR5s7zVGjAjucYuzo0ftzd+hQ3ZpuGJFpyMq3pi4IlxcnHVV2L7dWgplZtq6k9hYq8mYMCGPd+YXXGBVHytWWGuGxx6zEdgHH7BlVBBMm2YVonntuVUUzZoBXbrY+4+DB4N77OJI1QpwFy8G/vtfK8QlZzFxFRNlygB33221GPPmWSeO776z/mqxsfZCN3asNQo9ycUXA0lJVsZYrZpdD2vcGPjyS5bQF8HQofamonv30Bx/8GCbhhw2LDTHL05ef93+Np55xkZd5AKqyluIb02bNlU3OnFCdf581QEDVGvUUAVUY2JU27dXfecd1T17cjwhM1N10iTVevXswS1bqi5c6EjsXrZypf3zvfhiaM9zww2qZ5+tun9/aM8TyWbPVo2OVu3WTTUjw+loih8AKZrLaypHXMVYdLSVUA8bZl2tf/zR6jI2b7aea+edZ9fF3njDLkxDxIYIa9bYYqENG2wa8cYbgXXrnP5xPGP4cBsB9+sX2vM8+6xNA7/2WmjPE6m2bAF69ADi462Q5ky6mlBoiHK6J+QSEhI0JSXF6TAKTdWmFCdPtsWxP/1k919+uVVV3XQTULMmrJ576NCswo277gIeecSuhVGu9u610vc+fcKzULhHD7ue9vPP1prIy377zTqMhKOa7/Bhe0+2bZtd26pbN/TnpFOJyBJVTch5P99D0ClE7DLW889bK6m1a+3zI0csL9WqZTu8vjiiHDbc8rQN0f7xDyvmiI+3VbBTp55hJ2Cr/Th40EZ569b5R3sR4p13bPuRAQPCc75nnrEX4VdfDc/5QmXGDLsmeN55NlKdOTN0bTZV7Y3F6tVW9s6k5T4ccYWB10Zc+dm82bbg+PRTm1oErMqqe3eg82X7UPLLT5H2STIO/XoEaZVq4lCrLkhreg0Oydk4dMgGafl9PHTo1Kr7qCibuvzXv7xdhpyebsWaTZqEd0u0224DvvjClugVZmdlt5kzxzrC1K9vrc2+/NJ+X/7yF2ty27279YwOVpPbF16wBf0vv2zLGMk5eY24mLjCIJISV3bbt2clsQULCi4yjIpSlC8PlC8vKF/eevMV5uPChcCbb9oL1ZAhVh0ZHR2enzGYPvzQqjlnzrTOC+Gybp294D/0EPDKK+E7bzDMnw906GCj/HnzgMqVbU3VzJk2lT11ql3Hq1DBOph1724D/tKlz+x8SUlWYduzJzBuXPCXKtDpYeJyUKQmrux++cVeWGJiciSfPZtRftJolPv4fZT+Yw+kUSPbE+z220+rq+yqVdbG6ptvbMQyYoRdg/AKVWvGmp5uU1DhfkH829/shT41FahaNbznPlM//GAJPi7O/t9z68Ceng58/bX9bJ9/bss5ypWz5NO9uyW9smULd75164AWLWy9/YIFhX8ehU5eicvxUvHicHNrOXxYpaWpjhql2rix1YKffbbqAw+orl1b6ENkZqpOnKhavbod4o47VHftCmHMQTRvnsU8apQz59+wwcq6H3zQmfOfrpQU1QoVVOvUUd2xo3DPOXZMdfp01bvvVq1Uyf69y5ZVvflm1Y8/Vj10KO/nHjigWr++amys6tatwfkZqOiQRzm84y/qxeHGxJVNZqbqd9+p3n67asmS9ivYurXq5Mn2ylMIaWmqTz5pTy9fXvWVV1TT00McdxF162Yvpn/+6VwMffqoliqlunOnczEUxooVqhUrql5wwZknkePHbQ1W//6q555rv2ZlyqjeeKPq+PGqBw9mPfbECdWOHW0N4zffBOVHoCBh4mLicp89e1RfeEH1/PPtV7FaNdXBgws9jNq4UbVzZ3tqfLzqjBkhjvcMbdqkKqI6aJCzcWzebC/O99/vbBz5WbPGRj1xcRZvMJw4YSPe++9XPe88+30pVUq1a1fVDz9Uffhhu+/NN4NzPgoeJi4mLvc6cUL1iy9Ur7tO/9e+o0cPe7XJzCzw6V99pVq3rj21WzfV1NQwxHwaBgxQLVHCHSOdu++2keq2bU5HcqoNG1SrVrXb+vWhOUdGRla3mLg4+50BVPv2LdSvGoUZExcTlzds3Kj60EOqf/mL/Xo2aKA6cmT+FyhU9ehRG7yVLataurTqM884Oy0XcPCgTWf26uV0JGbLFkui/fs7HcnJUlPt2mXlyjbqCoeMDNXvv7eR1tGj4TknnR4mLiYubzl8WHX0aNWmTe3XtEIF1YEDC5w/2r5dtWdPe8oFF6h++qmz76Rfe81iSUlxLoac+ve35LVli9ORmK1bVWvWtPcqy5c7HQ25SV6Ji50zyJ3KlrX2BYsXn7orps9nNdB66lKO6tVtq5Z584Czz7b2VO3bZ7WtCqeMDOss3rKllcK7xZNPWjn+kCFORwLs2gW0bm37h82aZR1biArCxEXuJmI7LY4fbw33Bg2yFclt29qWK6NG5bor5jXXAEuXWq5LSQEaNQIefji8uwJPnWohB3OH42CoUcPaJo0ZY+u6nLJnD9CmjX2cMcNdyZ3cjYmLvCMuzpombt9uG1qWKGG9oKpXt40ut2496eExMcD991sT+z59rB9w/fq2t1JmZujDHTbMmhF37Rr6c52uJ56w7iNPP+3MvqD79tl7j23brP1VsHeBpsjGxEXeU7o00Lu3Dam+/dbetr/6KlC7trVL+Pbbk6YRY2NtYLZokbUO6t0buPJKaxt09GhoQlyyxNoVJSa6sz1VtWoW2/jxQL16lmTDNRo9cMCmbzdtsh6KLVuG57wUQXK78MUbizM8Z+tW1cces5WrgOoll1hxx5EjJz0sI0P1gw+yFqWWKmXrn4cMUf3hB1u4Ggy9elk1YfaFrm5z4oQVr1x5pf6vmcnAgaEt2jh4ULV5cyvJnzYtdOehyABWFTJxFQuHD1tfpYYN7de7cmVb+Zujb1Bamq3/GjhQtVEj/d96nrPPVu3SRXXYMNup+EwqEnfutKq9AQOC9DOFwaJFqrfeam2hoqJUu3e3BifBrMg8dMiSZEyM6tSpwTsuRS4mLiau4iUzU/Xrr1V9PmtbERNjdfILF+b6arxnj/Wz69cvazEzYCOznj1V33238J0cBg2yUwar80M4bdum+uijquecYz9/8+aqEyYUuhtXng4fVm3VypLipEnBiZUiX16Ji93hw6A4dId3tdRUYORI4P33bYfKZs3sAs/NNwOlSuX6lK1bbR+oOXOs8n73bru/Zk27pNa6td1ydlo/csSq9lq2BKZMCe2PFUppaVbEMmyYXYuqUcO68/ftC5xzzukd6+hRW8Ewaxbw0Ue2PxhRYbA7PEdcdOiQdeGIj7fhRKVKqomJqkuX5vu0zExrYv/GG6o33JA1Ggk09njgAdXPP7cO46NG2f2R0qw1I8O6cbVqZT/XWWfZz7tpU+Gen56u2qmTPXf06NDGSpEHHHE5hyMul8nMBGbPBt57zxZbHTtmK19797bhQAHbBGdkAMuX20js66+tevDIEdupuXRpID7eqgojbRPCZctsBDZhAnDihJX5DxwIXH117j/r8ePALbfYyPOtt4D+/cMfM3kbN5J0EBOXi+3fD0ycaKtxFy+2xV+dOlkS69ixUPvBp6cDP/5oSWzhQtvuvX37kEfumN27beb17beB336zjT0HDgR69Mj658rIAHr1sn/aYcOAAQOcjZm8iYnLQUxcHrFmjV3Y+e9/bUvnypVtp+Y+fdiLKBd//mnXrIYNs5Za1aoB//iHXQd75BHgww+Bl14CHn3U6UjJq5i4HMTE5TEnTtjq5DFjsqYSL7kkayoxNtbpCF0lM9P+uV57zQowoqLsvuees84cRGeKictBTFwetn+/XdQZM8aaHsbEAJ07Z00llijhdISusnq1TSPWrm2jrki7zkfhxcTlICauCLF6ddZU4p49NvLq1cuSWKNGTkdHFHHySlzsVUhUWA0bAq+8AuzYAXz1lbWgf+MNu/7VpIntYbJvn9NREkU8Ji6i0xWoPJw0yUrsRoywCzsDBliFQrdu9r0jR5yOlCgiMXERFUWlSrZ3SkoKsHKldeRYvNhqw6tWBe66y+rkndg7hChCMXERBcvFF9v2Ktu22QLnm24CJk+2jafOP9+qFZYty3XnZiIqPCYuomCLjraGhqNHWxHHJ58ACQl2DaxJE6BBA+CFF2x7ZCI6bUxcRKFUpow185061a6Hvf22TS8OGmS7Wl51lfVD+u03pyMl8gwmLqJwqVQJuOcea264ZQswZIhtB3zffXY9rGtXG52xqIMoX0xcRE6oWRN48klbG7ZsmVUkLlliXWmrVLG1YbNmsaiDKBdMXEROErF2UoGijq+/Brp3t5bq7dvbRlgPPQQsXep0pESuwcRF5BbR0bY75ejR1uR30iSgeXNb5Ny0KXDZZdZ+6vhxpyMlchQTF5EblSljI6/PP7ck9vrrVsBx2202zThkCLt0ULHFxEXkdhUrAg88AKxfb62mLroIeOopm0a8+25g1SqnIyQKKyYuIq+IirJWU7NmWVHH3/4GjBtnDX7btAG++ILFHFQsMHEReVGDBsA771jD3xdfBDZsAHw+ID4eGD4c+OMPpyMkChkmLiIvq1QJePxxIDUV+Phj4NxzgQcfBKpXt4+bNzsdIVHQMXERRYISJayx78gVI/8AAA4sSURBVMKFwKJFtph55EigXj37fM4c9kikiMHERRRpmjUDPvoI2LrVWkt9/71dA2vUCHjvPXbmIM9j4iKKVNWqAc8/D2zfbmvDoqOBvn2tGnHQIGDnTqcjJDojTFxEka50aaBPH2stNXcu0LKlFXTUrAn06gVs3Oh0hESnhYmLqLgQAVq1snZSmzbZ2rApU4ALL7TmvxyBkUcwcREVR7VrA6+9ZlWH994LfPABULcu8M9/cosVcj0mLqLirGpVYMQI68rRowfwn/9YUnv+eSAtzenoiHLFxEVEtqnl2LHWPqp1a+D//s8S2PDhQHq609ERnYSJi4iyNGhg171++AFo2NAWMdevD4wZw3ZS5BpMXER0qhYtbG+wmTOB2FirSrz4YuCzz7iQmRzHxEVEuRMB2rUDFi8GJk+2hHXTTZbUZs92Ojoqxpi4iCh/IpawVq0C3n/f9gdr1866cSxa5HR0VAwxcRFR4cTEAHfdZZ3ohw4FVq600dcNNwBr1jgdHRUjTFxEdHpKl7aijdRUYPBguxbWqBHQuzfw889OR0fFABMXEZ2Z8uWtbD41FRg4EJg40SoQExOB3budjo4iGBMXERVN5crAq69az8M77wTefNMa+XbubEUdXAdGQcbERUTBUaMG8O67wLp11jpq2TLg5puB884D7r/fqhNZSk9BwMRFRMFVt651n9+2DZg+HbjuOqtGbN7cFjW/8gqnEqlImLiIKDSioy1pTZhgieqdd4AKFYBHHwWqVwc6dQI++QQ4etTpSMljmLiIKPTOOQfo1w9YuNCmEh9/3Mrpb7nFphLvu8/WhHEqkQqBiYuIwis+HhgyxErnZ84EOna0bVVatLBeiS+/DOza5XSU5GJMXETkjOho68Axbpx143j3XaBiReCxx6zQ4/rrgY8/5lQinYKJi4icV6ECcPfdwIIF1pnjiSesG0fPnjaVeO+91rGeU4kEJi4icpt69YB//cumEmfPtvVgY8cCl18ONG4MjBoFHD7sdJTkICYuInKnqChr5Pvf/9pU4qhRNr14zz1AXJx169i40ekoyQFMXETkfmefDfTtCyxdatOJHTsCb7xhLaY6dAC++oobXRYjTFxE5B0iwJVXAuPHA9u3A889Z9utdOliU4yvvAL89pvTUVKIMXERkTdVrQo8/bRdC/vkE+D887MWN//97zY6o4jExEVE3laihPVEnDfPFjX37m2d6ps2Ba64wkZnx445HSUFERMXEUWOiy8G3noL2LkTGDYM2LcPuP12Wxf29NPAjh1OR0hBwMRFRJHnnHOAAQOsvdSMGdaVY8gQoGZNoHt3G51xTZhnMXERUeSKigLatwe++ALYvBl4+GFg7lzg2muzRmdpaU5HSaeJiYuIiodatYCXXrLpwg8+AEqXtua+550H3HqrFXgcOuR0lFQITFxEVLyUKWMFHIsXWxupnj2Br7+2TvWxsVZaP3q0XR8jV2LiIqLiScSufb37ru0X9u231hNx1Sorp69SBWjVChg+3DbFJNcQ5QXKkEtISNCUlBSnwyCiwlAFli8Hpkyx2+rVdn/TpsANN9jtwgst8VFIicgSVU045X4mrtBj4iLysI0bs5LYDz/YffXrAzfeaEksIcGKQCjomLgcxMRFFCF27gSmTrUkNm8ecOKENfzt1s2S2NVX24JoCgomLgcxcRFFoAMHrLnvlCnA9OnAkSO2EWaXLpbE2rUDypZ1OkpPY+JyEBMXUYT7809b6DxlCvDll8Dvv9s1sLg4oHbtk2+1atnHKlV4nawAeSWuGCeCISKKKGXLZhVuHD9u04jffQds2QKkpgIzZwK7dp36nEASy57QAp9ztJYnJi4iomAqUcKmCdu1O/n+I0esk30gmWW/zZlz6q7OVauemtBq17a1ZqVL23q0wK1EiWI1emPiIiIKhzJlrIz+wgtP/Z6qLXjOmdC2bLGNMydMADIz8z52VFRWEsuZ1Aq6P3CrXh2oU8du5cuH7t8hCJi4iIicJmIjqdhYWxSd07Fjtgg6NdWKQo4cOfl29Oip92X/3r59eT8nN7GxWUks+61uXeDccx0f3TFxERG5XcmSljTq1g3ucVWB9HSbpty2Ddi0yZoRB27z59t+ZtmL+M46K/ekVqeObeYZE/q0wsRFRFRcidgUYunSQKVKwKWXnvqY9HS7Npc9oW3ebFvGJCfb9wNiYoALLrAEG0hmd9xhI7ggYuIiIqK8lSoFxMfbLafMTKuWzDlS27wZ+PFHWxbg8zFxERGRS0RFWVFH9erWkDin/fuBChWCflomLiIiCo2KFUNyWHaGJCIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiT2HiIiIiTwlK4hKRSiKy3H/7RUR2Zvu6ZAHPTRCR1wtxjoVBirWViHwVjGMREVH4BaU7vKr+BuASABCRZwGkqeqrge+LSIyqnsjjuSkAUgpxjiuCESsREXlbyKYKRWSMiLwtIj8CeFlEmovI9yKyTEQWiki8/3H/GwGJyLMiMlpE5olIqogkZjteWrbHzxORySKyTkTGiYj4v9fRf98SEXn9dEZWInKriKwSkdUi8pL/vmj/z7Ha/72B/vsTRWStiKwUkYlB+0cjIqIChXo/ruoArlDVDBE5G0BLVT0hIm0BvADgplye81cA1wIoD2C9iLylqsdzPOZSAA0A7ALwHYArRSQFwDsArlbVLSIyobBBikg1AC8BaArgAICZItINwHYAcara0P+4c/xPeRxALVVNz3ZfzmP2A9APAM4///zChkJERAUIdXHGJFXN8H9eAcAkEVkNYCgs8eQmSVXTVXUfgL0AquTymEWqukNVMwEsB1ATlvBSVXWL/zGFTlwAmgGYp6q/+qc0xwG4GkAqgNoiMkJEOgD4w//4lQDGiUgvAHlNgY5S1QRVTYgN8rbVRETFWagT1+Fsnz8PYK5/9NIFQOk8npOe7fMM5D4qLMxjikxVDwBoDGAegP4A3vN/qxOAkQCaAFgsItxJmogoTMJZDl8BwE7/571DcPz1sNFRTf/Xt5zGcxcBuEZEKotINIBbAXwjIpUBRKnqpwCeAtBERKIA1FDVuQAeg/1c5YL0MxARUQHCOVJ4GcBYEXkKQFKwD66qR0TkPgDTReQwgMX5PLyNiOzI9vXNsOtWcwEIbLpyqog0BvCBP1kBwBMAogF8JCIV/I99XVV/D/bPQ0REuRNVdTqGoBGRcqqa5q8yHAlgo6oOdTquhIQETUkpsOKfiIiyEZElqpqQ8/5I65zRV0SWA1gDm8J7x+F4iIgoyCKqqMA/unJ8hEVERKETaSMuIiKKcExcRETkKRFVnOFWIvIrgK1n+PTKAPYFMZxQ81K8jDV0vBSvl2IFvBVvUWO9QFVP6eDAxOVyIpKSW1WNW3kpXsYaOl6K10uxAt6KN1SxcqqQiIg8hYmLiIg8hYnL/UY5HcBp8lK8jDV0vBSvl2IFvBVvSGLlNS4iIvIUjriIiMhTmLiIiMhTmLhcTEQ6iMh6EdkkIo87HU9eRKSGiMwVkbUiskZEBjgdU0FEJFpElonIV07HUhAROUdEJovIOhH5SUQudzqmvIjIQP/vwGoRmSAiee275wgRGS0ie/0b2gbuqygis0Rko//jX5yMMbs84n3F/7uwUkSm5LULe7jlFmu27z0sIurfKqrImLhcyr8v2EgA1wO4CMCtInKRs1Hl6QSAh1X1IgCXAfiHi2MNGADgJ6eDKKThAKar6l9hG5u6Mm4RiQOQCCDBv2FsNICezkZ1ijEAOuS473EAX6tqPQBf+792izE4Nd5ZABqqaiMAG2DbLbnBGJwaK0SkBoD2ALYF60RMXO7VHMAmVU1V1WMAJgLwORxTrlR1t6ou9X9+CPbCGudsVHkTkeqwXazfK+ixTvPv+3Y1gPcBQFWPuXz/txgAZfy7gpcFsMvheE6iqt8C2J/jbh+Asf7PxwLoFtag8pFbvKo6U1VP+L/8AUD1sAeWizz+bQFrfP4ogKBVAjJxuVccgO3Zvt4BFyeDAP8O1JcC+NHZSPI1DPaHlOl0IIVQC8CvsA1Nl4nIeyJyltNB5UZVdwJ4FfbOejeAg6o609moCqWKqu72f/4LgCpOBnOa7gIwzekg8iIiPgA7VXVFMI/LxEVBIyLlAHwK4EFV/cPpeHIjIp0B7FXVJU7HUkgxAJoAeEtVLwVwGO6ayvof/7UhHyzZVgNwloj0cjaq06O2PsgTa4REZBBsmn6c07HkRkTKAngSwP8F+9hMXO61E0CNbF9X99/nSiJSApa0xqnqZ07Hk48rAXQVkZ9h06+tReQjZ0PK1w4AO1Q1MIKdDEtkbtQWwBZV/VVVjwP4DMAVDsdUGHtE5DwA8H/c63A8BRKR3gA6A7hd3bsYtw7sTcwK/99bdQBLRaRqUQ/MxOVeiwHUE5FaIlISdpH7C4djypWICOwazE+q+prT8eRHVZ9Q1eqqWhP2bzpHVV07KlDVXwBsF5F4/11tAKx1MKT8bANwmYiU9f9OtIFLC0ly+ALAnf7P7wQw1cFYCiQiHWBT3V1V9U+n48mLqq5S1XNVtab/720HgCb+3+kiYeJyKf/F1/sBzID98X+iqmucjSpPVwK4AzZ6We6/dXQ6qAjyAIBxIrISwCUAXnA4nlz5R4WTASwFsAr2+uKq9kQiMgHA9wDiRWSHiPwdwL8BtBORjbBR47+djDG7POJ9A0B5ALP8f2tvOxqkXx6xhuZc7h1lEhERnYojLiIi8hQmLiIi8hQmLiIi8hQmLiIi8hQmLiIi8hQmLiIi8hQmLiIi8pT/BwtZgL6djOstAAAAAElFTkSuQmCC\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": "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": 106
        },
        "outputId": "0961bb60-f450-4239-f716-ac37ee024bb8"
      },
      "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",
        "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=(150, 150))\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": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8bc201a9-6236-4655-a296-8c31aeb1ba56\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8bc201a9-6236-4655-a296-8c31aeb1ba56\">\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 250978C9-2017-43DD-8380-32A557679FB3.jpeg to 250978C9-2017-43DD-8380-32A557679FB3.jpeg\n",
            "[1.]\n",
            "250978C9-2017-43DD-8380-32A557679FB3.jpeg is a dog\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}