AI_Fall22_Project.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/princebiscuits/AI-Fall22-Project/blob/master/AI_Fall22_Project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## __Misc__\n",
        " blocks not in use anymore"
      ],
      "metadata": {
        "id": "Fm7QO8_N5xrh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "!cp /content/drive/MyDrive/npy/bottleneck_features_test.npy /content/ -r\n",
        "!cp /content/drive/MyDrive/npy/bottleneck_features_validation.npy /content/ -r\n",
        "!cp /content/drive/MyDrive/npy/bottleneck_features_train.npy /content/ -r\n",
        "!cp '/content/drive/MyDrive/test images/' /content/ -r"
      ],
      "metadata": {
        "id": "RuzwHvaPuSVN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f306e7dc-19bc-4236-a6fd-5e0d0fc5d1f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from mlxtend.plotting import plot_confusion_matrix\n",
        "\n",
        "fig, ax = plot_confusion_matrix(conf_mat=cm, figsize=(6, 6), cmap=plt.cm.Greens, show_normed=True, show_absolute=False)\n",
        "plt.xlabel('Predictions', fontsize=18)\n",
        "plt.ylabel('Actuals', fontsize=18)\n",
        "plt.title('Confusion Matrix', fontsize=18)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "fS-ytIEks0U7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BL6Wj3ZaAMIO"
      },
      "source": [
        "## __Objective:__ Create a multiclass image classifier\n",
        "\n",
        "## __Purpose:__ Can be used to classify  species of animal\n",
        "\n",
        "### Use transfer learning and vgg16 model"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Imports and Paths"
      ],
      "metadata": {
        "id": "1qxETfJFcxFY"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j-eYCdhiAMIW"
      },
      "source": [
        "#### importing necessary libraries"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files"
      ],
      "metadata": {
        "id": "xoS1fiGZcLBq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xZPQ1HjeAMIZ"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np \n",
        "import itertools\n",
        "import keras\n",
        "from sklearn import metrics\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from tensorflow.keras.utils import img_to_array, load_img\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from keras.models import Sequential \n",
        "from keras import optimizers\n",
        "from keras.preprocessing import image\n",
        "from keras.layers import Dropout, Flatten, Dense  \n",
        "from keras import applications  \n",
        "from keras.utils.np_utils import to_categorical  \n",
        "import matplotlib.pyplot as plt \n",
        "import matplotlib.image as mpimg\n",
        "%matplotlib inline\n",
        "import math  \n",
        "import datetime\n",
        "import time"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9KKLfjEGAMIb"
      },
      "source": [
        "#### Loading up our image datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n_0ix--gAMIb"
      },
      "outputs": [],
      "source": [
        "#Default dimensions\n",
        "img_width, img_height = 224, 224  \n",
        "   \n",
        "#Create a bottleneck file\n",
        "top_model_weights_path = 'bottleneck_fc_model.h5' \n",
        "\n",
        "# loading up our datasets\n",
        "train_data_dir = 'data/train'  \n",
        "validation_data_dir = 'data/validation'  \n",
        "test_data_dir = 'data/test'\n",
        "   \n",
        "# number of epochs to train top model  \n",
        "epochs = 7  \n",
        "# batch size used by flow_from_directory and predict_generator  \n",
        "batch_size = 50  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GllRTIOeAMIe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9645d0f1-fb77-4e8f-e18a-87fc4d5c4549"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "58889256/58889256 [==============================] - 3s 0us/step\n"
          ]
        }
      ],
      "source": [
        "#Loading vgg16 model\n",
        "vgg16 = applications.VGG16(include_top=False, weights='imagenet') "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K7qj-mszAMIg"
      },
      "outputs": [],
      "source": [
        "datagen = ImageDataGenerator(rescale=1. / 255)  #needed to create the bottleneck .npy files"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NV6WYPSuAMIh"
      },
      "source": [
        "## Creation of weights/features with VGG16"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rk0AqV0AAMIi"
      },
      "outputs": [],
      "source": [
        "# Takes about 1.5 hour so storing as a npy file\n",
        "\n",
        "start = datetime.datetime.now()\n",
        "   \n",
        "generator = datagen.flow_from_directory(  \n",
        "     train_data_dir,  \n",
        "     target_size=(img_width, img_height),  \n",
        "     batch_size=batch_size,  \n",
        "     class_mode=None,  \n",
        "     shuffle=False)  \n",
        "   \n",
        "nb_train_samples = len(generator.filenames)  \n",
        "num_classes = len(generator.class_indices)  \n",
        "   \n",
        "predict_size_train = int(math.ceil(nb_train_samples / batch_size))  \n",
        "   \n",
        "bottleneck_features_train = vgg16.predict(generator, predict_size_train)  \n",
        "   \n",
        "np.save('bottleneck_features_train.npy', bottleneck_features_train)\n",
        "end= datetime.datetime.now()\n",
        "elapsed= end-start\n",
        "print ('Time: ', elapsed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9f9jZMXYAMIk"
      },
      "outputs": [],
      "source": [
        "print('-'*117)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Wvsy_aHAMIk"
      },
      "outputs": [],
      "source": [
        "# Takes about 20 mins so storing as a npy file\n",
        "\n",
        "start = datetime.datetime.now()\n",
        "generator = datagen.flow_from_directory(  \n",
        "     validation_data_dir,  \n",
        "     target_size=(img_width, img_height),  \n",
        "     batch_size=batch_size,  \n",
        "     class_mode=None,  \n",
        "     shuffle=False)  \n",
        "   \n",
        "nb_validation_samples = len(generator.filenames)  \n",
        "   \n",
        "predict_size_validation = int(math.ceil(nb_validation_samples / batch_size))  \n",
        "   \n",
        "bottleneck_features_validation = vgg16.predict(  \n",
        "     generator, predict_size_validation)  \n",
        "   \n",
        "np.save('bottleneck_features_validation.npy', bottleneck_features_validation) \n",
        "end= datetime.datetime.now()\n",
        "elapsed= end-start\n",
        "print ('Time: ', elapsed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SGFWGY3rAMIm"
      },
      "outputs": [],
      "source": [
        "print('-'*117)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "90MEkO-ZAMIn"
      },
      "outputs": [],
      "source": [
        "# Takes about 15 mins so storing as a npy file\n",
        "\n",
        "start = datetime.datetime.now()\n",
        "generator = datagen.flow_from_directory(  \n",
        "     test_data_dir,  \n",
        "     target_size=(img_width, img_height),  \n",
        "     batch_size=batch_size,  \n",
        "     class_mode=None,  \n",
        "     shuffle=False)  \n",
        "   \n",
        "nb_test_samples = len(generator.filenames)  \n",
        "   \n",
        "predict_size_test = int(math.ceil(nb_test_samples / batch_size))  \n",
        "   \n",
        "bottleneck_features_test = vgg16.predict(  \n",
        "     generator, predict_size_test)  \n",
        "   \n",
        "np.save('bottleneck_features_test.npy', bottleneck_features_test) \n",
        "end= datetime.datetime.now()\n",
        "elapsed= end-start\n",
        "print ('Time: ', elapsed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQRWEKr9AMIo"
      },
      "source": [
        "# Loading training, validation and testing data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YgqrRz7BAMIp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7b70918c-3226-4e9a-9229-f1b57d626b06"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 13412 images belonging to 6 classes.\n"
          ]
        }
      ],
      "source": [
        "#training data\n",
        "generator_top = datagen.flow_from_directory(  \n",
        "         train_data_dir,  \n",
        "         target_size=(img_width, img_height),  \n",
        "         batch_size=batch_size,  \n",
        "         class_mode='categorical',  \n",
        "         shuffle=False)  \n",
        "   \n",
        "nb_train_samples = len(generator_top.filenames)  \n",
        "num_classes = len(generator_top.class_indices)  \n",
        "   \n",
        "# load the bottleneck features saved earlier  \n",
        "train_data = np.load('bottleneck_features_train.npy')  \n",
        "   \n",
        "# get the class lebels for the training data, in the original order  \n",
        "train_labels = generator_top.classes  \n",
        "   \n",
        "# convert the training labels to categorical vectors  \n",
        "train_labels = to_categorical(train_labels, num_classes=num_classes) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OluTAicQAMIp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "596d7205-e0cb-4d92-9146-c95f514a747e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 2549 images belonging to 6 classes.\n"
          ]
        }
      ],
      "source": [
        "#validation data\n",
        "generator_top = datagen.flow_from_directory(  \n",
        "         validation_data_dir,  \n",
        "         target_size=(img_width, img_height),  \n",
        "         batch_size=batch_size,  \n",
        "         class_mode=None,  \n",
        "         shuffle=False)  \n",
        "   \n",
        "nb_validation_samples = len(generator_top.filenames)  \n",
        "   \n",
        "validation_data = np.load('bottleneck_features_validation.npy')  \n",
        "   \n",
        "\n",
        "validation_labels = generator_top.classes  \n",
        "validation_labels = to_categorical(validation_labels, num_classes=num_classes)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_9dzOzoIAMIq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "044c6c01-a677-493a-a1bc-be5f4ac8337c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 1845 images belonging to 6 classes.\n"
          ]
        }
      ],
      "source": [
        "#testing data\n",
        "generator_top = datagen.flow_from_directory(  \n",
        "         test_data_dir,  \n",
        "         target_size=(img_width, img_height),  \n",
        "         batch_size=batch_size,  \n",
        "         class_mode=None,  \n",
        "         shuffle=False)  \n",
        "   \n",
        "nb_test_samples = len(generator_top.filenames)  \n",
        "   \n",
        "test_data = np.load('bottleneck_features_test.npy')  \n",
        "   \n",
        "\n",
        "test_labels = generator_top.classes  \n",
        "test_labels = to_categorical(test_labels, num_classes=num_classes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UMxQDUk8AMIq"
      },
      "source": [
        "# Training of model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9-3snL-gAMIr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "03b3f4fd-62f6-45b1-a3c3-4f85a0a7e9d4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/rmsprop.py:135: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(RMSprop, self).__init__(name, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/7\n",
            "269/269 [==============================] - 15s 48ms/step - loss: 0.7388 - acc: 0.7380 - val_loss: 0.4065 - val_acc: 0.8682\n",
            "Epoch 2/7\n",
            "269/269 [==============================] - 11s 42ms/step - loss: 0.4147 - acc: 0.8597 - val_loss: 0.3331 - val_acc: 0.8929\n",
            "Epoch 3/7\n",
            "269/269 [==============================] - 11s 41ms/step - loss: 0.3335 - acc: 0.8908 - val_loss: 0.3277 - val_acc: 0.8913\n",
            "Epoch 4/7\n",
            "269/269 [==============================] - 11s 41ms/step - loss: 0.2751 - acc: 0.9091 - val_loss: 0.2678 - val_acc: 0.9078\n",
            "Epoch 5/7\n",
            "269/269 [==============================] - 13s 48ms/step - loss: 0.2442 - acc: 0.9187 - val_loss: 0.2647 - val_acc: 0.9121\n",
            "Epoch 6/7\n",
            "269/269 [==============================] - 13s 46ms/step - loss: 0.2143 - acc: 0.9283 - val_loss: 0.2557 - val_acc: 0.9219\n",
            "Epoch 7/7\n",
            "269/269 [==============================] - 11s 42ms/step - loss: 0.1883 - acc: 0.9371 - val_loss: 0.2462 - val_acc: 0.9227\n",
            "51/51 [==============================] - 1s 13ms/step - loss: 0.2462 - acc: 0.9227\n",
            "[INFO] accuracy: 92.27%\n",
            "[INFO] Loss: 0.2461557388305664\n",
            "Time:  0:02:24.477200\n"
          ]
        }
      ],
      "source": [
        "start = datetime.datetime.now()\n",
        "model = Sequential()  \n",
        "model.add(Flatten(input_shape=train_data.shape[1:]))  \n",
        "model.add(Dense(100, activation=keras.layers.LeakyReLU(alpha=0.3)))  \n",
        "model.add(Dropout(0.5))  \n",
        "model.add(Dense(50, activation=keras.layers.LeakyReLU(alpha=0.3)))  \n",
        "model.add(Dropout(0.3)) \n",
        "model.add(Dense(num_classes, activation='softmax'))  \n",
        "\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer=optimizers.RMSprop(lr=1e-4),\n",
        "              metrics=['acc'])  \n",
        "\n",
        "history = model.fit(train_data, train_labels,  \n",
        "      epochs=7,\n",
        "      batch_size=batch_size,  \n",
        "      validation_data=(validation_data, validation_labels))  \n",
        "\n",
        "model.save_weights(top_model_weights_path)  \n",
        "\n",
        "(eval_loss, eval_accuracy) = model.evaluate(  \n",
        " validation_data, validation_labels, batch_size=batch_size, verbose=1)\n",
        "\n",
        "print(\"[INFO] accuracy: {:.2f}%\".format(eval_accuracy * 100))  \n",
        "print(\"[INFO] Loss: {}\".format(eval_loss))  \n",
        "end= datetime.datetime.now()\n",
        "elapsed= end-start\n",
        "print ('Time: ', elapsed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gc8R6ijEAMIr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a7dc36f3-be66-4a07-b775-4b9a3c9acdf9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " flatten (Flatten)           (None, 25088)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 100)               2508900   \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 100)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 50)                5050      \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 50)                0         \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 6)                 306       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2,514,256\n",
            "Trainable params: 2,514,256\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "#Model summary\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "egcM1YPDAMIt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "0b1e6770-89ee-4d7b-d5ee-d52fed22da33"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU5fXA8e8hLGGTHQUCArKJyCIRf4J1wwWFyqYVRApoZVFc6161lKrVFqu1BCoqi4IiyCIqaEVxLSoBIrKIRkAMgkSQnQBJzu+P94ZMQpZJMpM7mZzP88yTueucO4F78i73fUVVMcYYY4JVwe8AjDHGlC2WOIwxxhSJJQ5jjDFFYonDGGNMkVjiMMYYUySWOIwxxhSJJQ5TYiKyRESGhXpfP4nIFhG5JAznVRFp5b3/j4g8HMy+xficISLy3+LGaUxBxJ7jKJ9E5EDAYjXgCJDhLY9S1VmlH1XkEJEtwB9UdWmIz6tAa1VNDtW+ItIc2AxUUtX0UMRpTEEq+h2A8Yeq1sh6X9BNUkQq2s3IRAr79xgZrKrK5CAiF4pIiojcJyI7gGkiUkdE3hKRVBH51XsfF3DMhyLyB+/9cBH5VEQmePtuFpErirlvCxH5WET2i8hSEUkQkZn5xB1MjH8Vkc+88/1XROoHbB8qIj+IyC4R+VMB3885IrJDRGIC1vUXkTXe+24islxE9ojIdhGZKCKV8znXdBF5NGD5Hu+Yn0Tkhlz79haR1SKyT0R+FJFxAZs/9n7uEZEDInJu1ncbcHx3EVkhInu9n92D/W6K+D3XFZFp3jX8KiILA7b1FZEk7xq+F5Fe3voc1YIiMi7r9ywizb0quxtFZCvwgbd+rvd72Ov9Gzkj4PiqIvKU9/vc6/0bqyoib4vIrbmuZ42I9M/rWk3+LHGYvJwC1AVOBUbi/p1M85abAYeBiQUcfw6wEagP/B14UUSkGPu+AnwJ1APGAUML+MxgYrwOGAE0BCoDdwOISHtgsnf+xt7nxZEHVf0COAhcnOu8r3jvM4A7ves5F+gJ3FxA3Hgx9PLiuRRoDeRuXzkI/B6oDfQGxohIP2/b+d7P2qpaQ1WX5zp3XeBt4Fnv2v4JvC0i9XJdwwnfTR4K+55fxlV9nuGd62kvhm7AS8A93jWcD2zJ7/vIwwXA6cDl3vIS3PfUEFgFBFatTgC6At1x/47vBTKBGcD1WTuJSCegCe67MUWhqvYq5y/cf+BLvPcXAkeB2AL27wz8GrD8Ia6qC2A4kBywrRqgwClF2Rd3U0oHqgVsnwnMDPKa8orxoYDlm4F3vPePALMDtlX3voNL8jn3o8BU731N3E391Hz2vQNYELCsQCvv/XTgUe/9VOCJgP3aBO6bx3mfAZ723jf39q0YsH048Kn3fijwZa7jlwPDC/tuivI9A41wN+g6eez3XFa8Bf3785bHZf2eA66tZQEx1Pb2qYVLbIeBTnnsFwv8ims3ApdgJpX2/7doeFmJw+QlVVXTshZEpJqIPOcV/ffhqkZqB1bX5LIj642qHvLe1ijivo2B3QHrAH7ML+AgY9wR8P5QQEyNA8+tqgeBXfl9Fq50MUBEqgADgFWq+oMXRxuv+maHF8fjuNJHYXLEAPyQ6/rOEZFlXhXRXmB0kOfNOvcPudb9gPtrO0t+300OhXzPTXG/s1/zOLQp8H2Q8ebl+HcjIjEi8oRX3bWP7JJLfe8Vm9dnef+mXwOuF5EKwGBcCckUkSUOk5fcXe3+CLQFzlHVk8iuGsmv+ikUtgN1RaRawLqmBexfkhi3B57b+8x6+e2squtxN94ryFlNBa7K6xvcX7UnAQ8WJwZciSvQK8AioKmq1gL+E3DewrpG/oSrWgrUDNgWRFy5FfQ9/4j7ndXO47gfgdPyOedBXGkzyyl57BN4jdcBfXHVebVwpZKsGH4B0gr4rBnAEFwV4iHNVa1ngmOJwwSjJq74v8erL/9zuD/Q+ws+ERgnIpVF5Fzgt2GK8XWgj4ic5zVkj6fw/xuvALfjbpxzc8WxDzggIu2AMUHGMAcYLiLtvcSVO/6auL/m07z2gusCtqXiqoha5nPuxUAbEblORCqKyLVAe+CtIGPLHUee37Oqbse1PUzyGtEriUhWYnkRGCEiPUWkgog08b4fgCRgkLd/PHB1EDEcwZUKq+FKdVkxZOKq/f4pIo290sm5XukQL1FkAk9hpY1is8RhgvEMUBX319znwDul9LlDcA3Mu3DtCq/hbhh5KXaMqroOuAWXDLbj6sFTCjnsVVyD7Qeq+kvA+rtxN/X9wPNezMHEsMS7hg+AZO9noJuB8SKyH9cmMyfg2EPAY8Bn4npz/V+uc+8C+uBKC7twjcV9csUdrMK+56HAMVypayeujQdV/RLX+P40sBf4iOxS0MO4EsKvwF/IWYLLy0u4Et82YL0XR6C7ga+BFcBu4Ely3uteAs7EtZmZYrAHAE2ZISKvAd+oathLPCZ6icjvgZGqep7fsZRVVuIwEUtEzhaR07yqjV64eu2FhR1nTH68asCbgSl+x1KWWeIwkewUXFfRA7hnEMao6mpfIzJllohcjmsP+pnCq8NMAayqyhhjTJFYicMYY0yRlItBDuvXr6/Nmzf3OwxjjClTVq5c+YuqNsi9vlwkjubNm5OYmOh3GMYYU6aISO4RBwCrqjLGGFNEljiMMcYUiSUOY4wxRVIu2jjycuzYMVJSUkhLSyt8Z+OL2NhY4uLiqFSpkt+hGGMClNvEkZKSQs2aNWnevDn5zzFk/KKq7Nq1i5SUFFq0aOF3OMaYAOW2qiotLY169epZ0ohQIkK9evWsRGhMBCq3iQOwpBHh7PdjTGQqt1VVxhgTldLSYMMGWLvWvR5+GGrkNwFn8Vji8MmuXbvo2bMnADt27CAmJoYGDdwDml9++SWVK1fO99jExEReeuklnn322QI/o3v37vzvf/8LXdDGmMiRng7JydkJIuv13XeQmen2qVwZhgyBjh1D+tGWOHxSr149kpKSABg3bhw1atTg7rvvPr49PT2dihXz/vXEx8cTHx9f6GdY0jAmCmRmwtatJyaIDRvg6FG3T4UK0KoVdOgA117rfnbo4NaFoVeiJY4IMnz4cGJjY1m9ejU9evRg0KBB3H777aSlpVG1alWmTZtG27Zt+fDDD5kwYQJvvfUW48aNY+vWrWzatImtW7dyxx13cNtttwFQo0YNDhw4wIcffsi4ceOoX78+a9eupWvXrsycORMRYfHixdx1111Ur16dHj16sGnTJt56K+eMolu2bGHo0KEcPHgQgIkTJ9K9e3cAnnzySWbOnEmFChW44ooreOKJJ0hOTmb06NGkpqYSExPD3LlzOe20/KaANsYAoAo7d8LXX+dMEOvWwYED2fs1a+aSwuWXZyeIdu2gatVSC9USB8Add4D313/IdO4MzzxT5MNSUlL43//+R0xMDPv27eOTTz6hYsWKLF26lAcffJB58+adcMw333zDsmXL2L9/P23btmXMmDEnPPuwevVq1q1bR+PGjenRowefffYZ8fHxjBo1io8//pgWLVowePDgPGNq2LAh7733HrGxsXz33XcMHjyYxMRElixZwhtvvMEXX3xBtWrV2L17NwBDhgzh/vvvp3///qSlpZGZVWw2xjh79riEkLsU8UvAbL7168OZZ8KIEdkJ4owzoFYt/+L2WOKIMNdccw0xMTEA7N27l2HDhvHdd98hIhw7dizPY3r37k2VKlWoUqUKDRs25OeffyYuLi7HPt26dTu+rnPnzmzZsoUaNWrQsmXL489JDB48mClTTpwY7dixY4wdO5akpCRiYmL49ttvAVi6dCkjRoygWrVqANStW5f9+/ezbds2+vfvD7iH+Iwptw4dytlQnfVKCZjSvmZNlxT6989OEB06QMOG/sVdCEscUKySQbhUr179+PuHH36Yiy66iAULFrBlyxYuvPDCPI+pUqXK8fcxMTGkp6cXa5/8PP3005x88sl89dVXZGZmWjIwJrdjx1yj9Nq1Oauavv/eVUEBVKkCp58OF17oShJZCaJpUyhjXc8tcUSwvXv30qRJEwCmT58e8vO3bduWTZs2sWXLFpo3b85rr72WbxxxcXFUqFCBGTNmkJGRAcCll17K+PHjGTJkyPGqqrp16xIXF8fChQvp168fR44cISMj43ipxJgyLTMTtmw5sQTxzTcueYBrqG7TxlVXX399doI47TTIp8NLWRMdVxGl7r33XoYNG8ajjz5K7969Q37+qlWrMmnSJHr16kX16tU5++yz89zv5ptvZuDAgbz00kvH9wXo1asXSUlJxMfHU7lyZa688koef/xxXn75ZUaNGsUjjzxCpUqVmDt3Li1btgx5/MaEjSps335igli3zlU/ZWne3CWF3r2zE0TbthDlpfJyMed4fHy85p7IacOGDZx++uk+RRQ5Dhw4QI0aNVBVbrnlFlq3bs2dd97pd1jH2e/JhN2RI7B+vesgk/Vauxa8zh4AnHxyzvaHM8+E9u1d+0QUE5GVqnpC3/+wljhEpBfwLyAGeEFVn8i1/VRgKtAA2A1cr6opItIZmAycBGQAj6nqa94x04ELgL3eaYaraoi7RJUfzz//PDNmzODo0aN06dKFUaNG+R2SMeHz66/w1VfZCWL1apc0str8qlWDTp3gmmty9mRqcMLsqeVa2BKHiMQACcClQAqwQkQWqer6gN0mAC+p6gwRuRj4GzAUOAT8XlW/E5HGwEoReVdV93jH3aOqr4cr9vLkzjvvjKgShjEhoeoemgtMEElJ8EPATKinnOLaIXr3dj87d3btEF6vRpO/cJY4ugHJqroJQERmA32BwMTRHrjLe78MWAigqt9m7aCqP4nITlypZA/GGBPo2DHX5TUwQSQluWclwPVYatMGzj0XxoxxCaJTJ5c4TLGEM3E0AX4MWE4Bzsm1z1fAAFx1Vn+gpojUU9VdWTuISDegMvB9wHGPicgjwPvA/ap6JPeHi8hIYCRAs2bNSn41xhj/7d0La9bkTBLr1mUPvVG1qhuX6dprs0sRZ54JAd3cTcn53avqbmCiiAwHPga24do0ABCRRsDLwDBVzXr8+AFgBy6ZTAHuA8bnPrGqTvG2Ex8fH/09AIyJJqqwbduJpYhNm7L3adAAunRxIz9kJYnWraOmy2teVF1zTHo6ZGRkvy/o1a5d6Dt5hfMb3gY0DViO89Ydp6o/4UociEgNYGBWO4aInAS8DfxJVT8POGa79/aIiEzDJR9jTFmVng4bN+ZMEElJsGtX9j6tWkHXrnDjjdlJolGjkD44d+SIK7x8/bUbGiqvm3CwN+vCXsU9T3FG7/nmG9dDOJTCmThWAK1FpAUuYQwCrgvcQUTqA7u90sQDuB5WiEhlYAGu4fz1XMc0UtXt4mb56QesDeM1hM1FF13E/fffz+WXX3583TPPPMPGjRuZPHlynsdceOGFTJgwgfj4eK688kpeeeUVateunWOfvEbazW3hwoW0adOG9u3bA/DII49w/vnnc8kll4TgyowpwIEDOXs1JSW5O/URr7a5ShVXtdS/f3aC6Ngx5N1e9+93Yaxa5fJVVueqfEb1Oa5CBVegyesVE5P/tsBXbGzxjivu5zVuHNKvDghj4lDVdBEZC7yL6447VVXXich4IFFVFwEXAn8TEcVVVd3iHf474HygnleNBdndbmeJSANAgCRgdLiuIZwGDx7M7NmzcySO2bNn8/e//z2o4xcvXlzsz164cCF9+vQ5njjGjz+hps+YklGFHTtOLEUkJ2cPwVG3rqtqGjs2O0m0bRvyYcB37sxODlmvwDAaNnRhXHGF+9m5M9Spk/eNukK5njM1gKpG/atr166a2/r1609YV5p27dqlDRo00CNHjqiq6ubNm7Vp06aamZmpo0eP1q5du2r79u31kUceOX7MBRdcoCtWrFBV1VNPPVVTU1NVVfXRRx/V1q1ba48ePXTQoEH6j3/8Q1VVp0yZovHx8dqxY0cdMGCAHjx4UD/77DOtU6eONm/eXDt16qTJyck6bNgwnTt3rqqqLl26VDt37qwdOnTQESNGaFpa2vHPe+SRR7RLly7aoUMH3bBhwwnXtHnzZj3vvPO0S5cu2qVLF/3ss8+Ob3viiSe0Q4cO2rFjR73vvvtUVfW7777Tnj17aseOHbVLly6anJx8wjn9/j2ZIKSnq65fr/rKK6r33qt62WWqDRuqunuze7VooTpggOr48aqLFqlu3aqamRnSMDIzVTdvVp0/X/Xhh1X79FFt3DhnGM2bq/bvr/rXv6q+9Zbqtm0hDyOq4P7IP+GeGr2tSEXgx6jqdevWpVu3bixZsoS+ffsye/Zsfve73yEiPPbYY9StW5eMjAx69uzJmjVr6JjPDF4rV65k9uzZJCUlkZ6ezllnnUXXrl0BGDBgADfddBMADz30EC+++CK33norV111FX369OHqq6/Oca60tDSGDx/O+++/T5s2bfj973/P5MmTueOOOwCoX78+q1atYtKkSUyYMIEXXnghx/E2/Ho5cPCgq1oKLEWsWQOHD7vtlSplD8ERWNWUq0q1pDIyXLNIYFVTUpJ7vg9cyeD00+Hii10pIrAkYUrOEoePsqqrshLHiy++CMCcOXOYMmUK6enpbN++nfXr1+ebOD755BP69+9/fBDBq6666vi2tWvX8tBDD7Fnzx4OHDiQo1osLxs3bqRFixa0adMGgGHDhpGQkHA8cQwYMACArl27Mn/+/BOOt+HXo8zPP+dMEElJ8O232S20tWu7u/GoUdnPRrRv76YrDaG0NJerAquaAnNVlSouN11zTXaSOPNM9xC4CQ9LHPg3qnrfvn258847WbVqFYcOHaJr165s3ryZCRMmsGLFCurUqcPw4cNJS0sr1vmHDx/OwoUL6dSpE9OnT+fDDz8sUbxZQ7PnNyy7Db9eRmVmukr/3Eli+/bsfU491SWHwOcjTj015MOB792b3QM3sNHaG5CZWrWyc9VZZ7kk0a5dVPfAjUj2dfuoRo0aXHTRRdxwww3HZ9/bt28f1atXp1atWvz8888sWbIk33k4AM4//3yGDx/OAw88QHp6Om+++ebx8ab2799Po0aNOHbsGLNmzTo+RHvNmjXZv3//Cedq27YtW7ZsITk5mVatWvHyyy9zwQUXBH09Nvx6GXD4sBvALzBBfPWVq4ICdwdu3x4uvTQ7QXTq5BqyQyyr7TywuinwMY1GjVxiuOqq7JJEixZlbuqKqGSJw2eDBw+mf//+zJ49G4BOnTrRpUsX2rVrR9OmTenRo0eBx5911llce+21dOrUiYYNG+YYGv2vf/0r55xzDg0aNOCcc845niwGDRrETTfdxLPPPsvrr2f3do6NjWXatGlcc801pKenc/bZZzN6dPCd1mz49Qjzyy85E8Tq1a5Tf1ZVU82aLjHccEN2kjjjDFf3E0KqLiHk7tm0Y0f2Pqed5koQN96YnSRsRJDIZcOqm4hmv6cgZGbC5s0nJoltAc/bxsVlJ4fOnd2duXnzkPcvTU93w0blThL79rntMTGuQNOlS3ZVU6dOETGNtsmDL8OqG2NCLOvx5tztEVlVjzExrtL/wgtzJor69Uv0saquNis11T0XsXNn9vusn998k/NZvqpVXVIYMiS7FNGhQ9TPcVQuWOIwJlLt3n3i3BEbNmTPHVG9urszDx2aXYo44wx3xw7C4cMn3vzzSgxZ77N6MeVWvbobNqplS/csX1aSaNvWRiiPVuU6cagqYi1tEas8VKMC7s/5H344ce6IrVuz92nUyCWHPn2yH0o47bQcVU1Hj7obfEFJIHDdgQN5h1OlinuaukED97N9++z3WT+z3jdoYAPPlkflNnHExsaya9cu6tWrZ8kjAqkqu3btit4uvVu3wiuvwDvvuCSx15vQUsT9qd69O+mjbmHXad3YefKZpGbWy04Ca2Dn0hMTQ9b0E7lVrJjzxt+yZd5JIOtnzZrWc8kUrNwmjri4OFJSUkhNTfU7FJOP2NhY4uLi/A4jdH79FV5/HWbORD/+mCQ6s7zptexsdTepNVqwM+YUdh6pTeruGHa+B7tfyx5PKVCFCq7JIutmf9ZZ+SeBhg3dc3qWCEwoldvEUalSJVq0aOF3GCbaHTkCixfDzJlkvvk2nx87i/l1/sD8OgvZ/GsdN9XZj+4xiawbf/v2rm07r2TQsKEbNsPaDoyfym3iMCZsMjPhs89g5kzSX5vHx3s7Mr/q9Syo/CI/HatNpQPKpZcKfxoAl13mnlcI8YCwxoSVJQ5jQmX9epg5kyOzXuf9ra2YF3Mtb1ScwC5qUhXlisuFgQOhd2+x5xZMmWaJw5iS2L4dXn2VgzNe5501jZjPQN6q+Cf2UZ2Tqit9+rhk0auX2KB7JmpY4jCmqPbvhwUL2DttPm99VJN52p93KnzAYWKpVyeTawZUYMAA6NlTQj16hzERIayJQ0R6Af/CzQD4gqo+kWv7qbjpYhsAu4HrVTXF2zYMeMjb9VFVneGt7wpMB6oCi4Hbtdx0+De+OXYM/vtfUl9cxBtvxTD/WB+WModjVKZxw2PccE0lBg6E3/ymgo3UaqJe2P6Ji0gMkABcCqQAK0RkkaquD9htAm5e8RkicjHwN2CoiNQF/gzEAwqs9I79FZgM3AR8gUscvYAl4boOU46pwpdfsu0/b7JgbjrzDl7Ox0wikxhaNE7j9sGVGDAQzjmnkk0pasqVcP5t1A1IVtVNACIyG+gLBCaO9sBd3vtlwELv/eXAe6q62zv2PaCXiHwInKSqn3vrXwL6YYnDhFJyMpv+/TbzZqUxf9f5fM6jAJwet58Hh8LA30GnTrH2bIQpt8KZOJrgeqlnSQHOybXPV8AAXHVWf6CmiNTL59gm3islj/UnEJGRwEiAZs2aFfsiTPmgO1PZ8K//Mu+lg8xPOZskbgfgrFN/4dGhaQy4LpbTT6/pc5TGRAa/a2PvBiaKyHDgY2AbkBGKE6vqFGAKuGHVQ3FOE1304CFW/esT5k/dw7zvO7GRIQiZdG/+E08N3UP/EbVp0aJko8oaE43CmTi2AU0DluO8dcep6k+4EgciUgMYqKp7RGQbcGGuYz/0jo/LtT7HOY0pSOaxDJYnrGLe87uYv+F0ftDLiSGdC0/dzG1DttF/bBMaNYqiYU6MCYNwJo4VQGsRaYG7uQ8CrgvcQUTqA7tVNRN4ANfDCuBd4HERqeMtXwY8oKq7RWSfiPwfrnH898C/w3gNJgocO6p8NPV75v/nZxZ83YodmWdTmSNc2vQb/jzoEL+9uy31G7b2O0xjyoywJQ5VTReRsbgkEANMVdV1IjIeSFTVRbhSxd9ERHFVVbd4x+4Wkb/ikg/A+KyGcuBmsrvjLsEaxk0e0tJg6Ss7mZewg0VfNWN3Riuq0YgrGycx4Jot9H6wEyc17OR3mMaUSeV26lgTfQ4cgCVzDzB/8g7eXtWI/RnVqcUeftvgcwYOgMv+dDbVmtbzO0xjygybOrYc27EDpkyBXbvctJ1ZrypVci4Xtj5wW6Q85LZnD7w5/xjznkvl3cR6pGXWoD61uLbW2wzsm8HFD/4fldv28jtMY6JKhPz3N+GwdSv84x/wwgtudriTTnJVOGlpJT93TEzRk01xElRe6w8fhrffzGTe1D28v6IW6VqJJmRyU9WXGXBlGufdcy4Vu11jk1AYEyaWOKLQ99/DE0/AjBluedgwuO8+aNXKLau6RHLkSHYiyf0KxbZ9+/LfduxYSa+yAi35lTsrzWBgz72cfdu5VLh0eOQUhYyJYva/LIqsXw+PPw6vvurmdxg1Cu65B3I//yji/nKvUsWVQvyQkZEzkeSXjI6vP5RJ2rLlpM1fjB4+zMXdj9BxTA+k30ib9NqYUmaJIwqsXg2PPQbz5rl76B//CHfd5SYIilQxMVCtGsENNZ6UBDffDMuXw3nnweTJ0KFD2GM0xuTNhmYrw5Yvh9693ZzTS5fCww/DDz/A3/8e2UkjaPv2wR13QNeukJwM06fDxx9b0jDGZ1biKGNU4cMP4dFH4YMPoF49V9q45RaiZ1Y5VZg92xWbfv4ZRo92F1mnTuHHGmPCzhJHGaEKS5a4hLF8OTRqBP/8J4yMtir+b75xWfCDDyA+HhYtgrPP9jsqY0wAq6qKcJmZMH++q63p3Ru2bYNJk2DTJrjzzihKGocOwZ/+BB07wqpV7iI//9yShjERyEocESo9HV57zfWSWr8eWreGqVPh+utdj6mosmgR3Haba6AZNsw10jRs6HdUxph8WIkjwhw9Ci++CO3auSRRoYLrXrthA4wYEWVJY/NmuOoq6NsXatSAjz5yDeCWNIyJaFbiiBCHD7uE8fe/w48/uqqpBQvcfTXqpiU9cgQmTHANNjEx7vH222+PsqxoTPSyxOGzAwfgP/9x99Gff4YePdy4UpdfHqUjZixd6hq/v/0Wrr4ann4a4mz+C2PKEkscPtmzByZOdPfN3bvhkktcm8b550dpwvjpJ9e99rXX3Ngn77zjsqMxpsyxxFHKUlPhmWdc0ti3D377W9eZ6Jzcs7FHi/R0+Pe/4c9/dg04f/kL3HuvG7HQGFMmWeIoJT/9BE895aqlDh92tTQPPgidO/sdWRh99pkbKmTNGujVy2XL007zOypjTAmFtdlVRHqJyEYRSRaR+/PY3kxElonIahFZIyJXeuuHiEhSwCtTRDp72z70zpm1LaK74Pzwg7t3tmwJ//oXDBwI69bBnDlRnDR++QVuvNGNK7V7txtEa/FiSxrGRImwlThEJAZIAC4FUoAVIrJIVdcH7PYQMEdVJ4tIe2Ax0FxVZwGzvPOcCSxU1aSA44aoakRP6fftt25o85dfdm0WI0a4oc1btvQ7sjDKzHSTfzzwgKuHu/deN4BWjRp+R2aMCaFwVlV1A5JVdROAiMwG+gKBiUOBrIG9awE/5XGewcDsMMYZUl9/7R7amzMHKld2pY177ikHHYdWrXIX+8UXcMEFkJAAZ5zhd1TGmDAIZ1VVE+DHgOUUb12gccD1IpKCK23cmsd5rgVezbVumldN9bBI3n2QRGSkiCSKSGJqamqxLqAoEhOhf383YsZbb8Hdd8OWLa56KqqTxp49cOutbmiQzU5X9coAABpySURBVJtdEWvZMksaxkQxvx8tGwxMV9U44ErgZRE5HpOInAMcUtW1AccMUdUzgd94r6F5nVhVp6hqvKrGN2jQIGwX8OmncMUV7r754Yeu89APP8CTT8LJJ4ftY/2nCrNmuUfcExJgzBjYuNE97h6V/YmNMVnCmTi2AU0DluO8dYFuBOYAqOpyIBaoH7B9ELlKG6q6zfu5H3gFVyVWqlTdc2wXXgi/+Q2sXAl/+5tLGOPGQd26pR1RKduwAS6+2CWJZs1gxQrXY6p2bb8jM8aUgnAmjhVAaxFpISKVcUlgUa59tgI9AUTkdFziSPWWKwC/I6B9Q0Qqikh9730loA+wllKiCm++CeeeC5deCt99557J2LIF7r/fv2lYS83Bg+5CO3aEr75yfYuXL3fjoxhjyo2wNY6rarqIjAXeBWKAqaq6TkTGA4mqugj4I/C8iNyJaygfrqrqneJ84MesxnVPFeBdL2nEAEuB58N1DVkyMtzQ5o895u6XzZu7e+bw4W7e7qinCm+84caT2rrVdRF78kkIYxWgMSZySfZ9OnrFx8drYmLRe++mp7uRaR9/3M0v1Late2hv8OByNB7fpk2u8XvxYjjzTDdPxnnn+R2VMaYUiMhKVY3Pvd6eHC9Ar17w/vvufvnaa+7hvZgYv6MqJWlpbtTaxx+HihXdY++33lqOMqYxJj+WOApw661ufqE+faJwaPOC/Pe/bgTb5GT43e/cHLVNcvekNsaUV5Y4CtC3r98RlLJt29x8tHPnuikH330XLrvM76iMMRGmPP0dbfJz7JgrVbRr57qN/fWv7hF4SxrGmDxYiaO8+/RT9/De2rXQuzc8+2yUD6hljCkpK3GUVzt3um61v/mNG5Bw4UJX2rCkYYwphCWO8iYjwz2E0rYtzJzpHuhbv9416NhQIcaYIFhVVXmycqWrllqxwo2XkpAA7dv7HZUxpoyxEkd5ce+9biTGrVvd4IQffGBJwxhTLFbiKA9WrnQP8w0d6ub/rlXL74iMMWWYlTjKg4QEqF7dkoYxJiSCShwiMl9EegfOlWHKiF273IBbQ4da0jDGhESwiWAScB3wnYg8ISJtwxiTCaWpU924U7fc4nckxpgoEVTiUNWlqjoEOAvYAiwVkf+JyAhviHMTiTIy3Gi2F1wAHTr4HY0xJkoEXfUkIvWA4cAfgNXAv3CJ5L2wRGZKbskSN8uUlTaMMSEUVK8qEVkAtAVeBn6rqtu9Ta+JSNEnujClY+JEaNwY+vXzOxJjTBQJtsTxrKq2V9W/BSQNAPKa5COLiPQSkY0ikiwi9+exvZmILBOR1SKyRkSu9NY3F5HDIpLkvf4TcExXEfnaO+ezIva4c56+/daNbjtqlM2hYYwJqWATR3sRqZ21ICJ1ROTmgg4QkRggAbgCaA8MFpHcT5w9BMxR1S64OcknBWz7XlU7e6/RAesnAzcBrb1XryCvoXyZPNkljJEj/Y7EGBNlgk0cN6nqnqwFVf0Vd/MuSDcgWVU3qepRYDaQe4YLBU7y3tcCfirohCLSCDhJVT/35iZ/CbB6mNwOHoRp0+Dqq+GUU/yOxhgTZYJNHDGBVUJeaaJyIcc0AX4MWE7x1gUaB1wvIinAYuDWgG0tvCqsj0TkNwHnTCnknFkxjhSRRBFJTE1NLSTUKDNrFuzda43ixpiwCDZxvINrCO8pIj2BV711JTUYmK6qccCVwMveQ4bbgWZeFdZdwCsiclIB5zmBqk5R1XhVjW/QoEEIQi0jVF2jeOfO0L2739EYY6JQsGNV3QeMAsZ4y+8BLxRyzDagacBynLcu0I14bRSqulxEYoH6qroTOOKtXyki3wNtvOPjCjln+fbpp272vueft2HSjTFhEewDgJmqOllVr/Zez6lqRiGHrQBai0gLEamMa/xelGufrUBPABE5HYgFUkWkgVcdhoi0xDWCb/J6dO0Tkf/zqs5+D7wR5LWWDxMnQu3acN11fkdijIlSwT7H0Rr4G653VGzWelXNd7o4VU0XkbHAu0AMMFVV14nIeCBRVRcBfwSeF5E7cQ3lw1VVReR8YLyIHAMygdGquts79c3AdKAqsMR7GYCffoL58+G226BaNb+jMcZEqWCrqqYBfwaeBi4CRhBEaUVVF+MavQPXPRLwfj3QI4/j5gHz8jlnImDjZ+RlyhQ3zMiYMYXva4wxxRRs43hVVX0fEFX9QVXHAb3DF5YpsqNH4bnnoFcvaNXK72iMMVEs2BLHEa+303de9dM2oEb4wjJFtmAB7NgBY8f6HYkxJsoFW+K4HagG3AZ0Ba4HhoUrKFMMCQnQsqUrcRhjTBgVWuLwejddq6p3Awdw7RsmkqxZA598AhMmQAWba8sYE17BNHBnAOeVQiymuBISIDYWRlhON8aEX7BtHKtFZBEwFziYtVJV54clKhO8PXtg5kwYMgTq1vU7GmNMORBs4ogFdgEXB6xTwBKH36ZPh0OHbFwqY0ypCSpxqKrVgUSizExXTdW9O3Tp4nc0xphyItgnx6fhShg5qOoNIY/IBO+99yA5Gf7yF78jMcaUI8FWVb0V8D4W6E8hc2eYUjBxIpx8spt3wxhjSkmwVVU5hv8QkVeBT8MSkQnO5s3w9tvwpz9B5cKmRjHGmNApbqf/1kDDUAZiimjyZPfMxqhRfkdijClngm3j2E/ONo4duDk6jB8OH4YXX4R+/SAurvD9jTEmhIKtqqoZ7kBMEcyeDbt327hUxhhfBFVVJSL9RaRWwHJtEekXvrBMvrKmhj3jDLjgAr+jMcaUQ8G2cfxZVfdmLajqHtz8HAUSkV4islFEkkXk/jy2NxORZSKyWkTWiMiV3vpLRWSliHzt/bw44JgPvXMmea/y1dbyxRewapV74M+mhjXG+CDY7rh5JZgCj/UGR0wALgVSgBUissibvCnLQ8AcVZ0sIu1xkz41B34BfquqP4lIB9wsgk0CjhviTehU/iQkQM2acP31fkdijCmngi1xJIrIP0XkNO/1T2BlIcd0A5JVdZOqHgVmA31z7aPASd77WnjPhqjqalXNek5kHVBVRKoEGWv02rkT5syB4cNd8jDGGB8EmzhuBY4Cr+ESQBpQ2OBITYAfA5ZTyFlqABgHXC8iKbjSxq15nGcgsEpVjwSsm+ZVUz0sUo7qa154wc30d/PNfkdijCnHgu1VdRA4oY0iBAYD01X1KRE5F3hZRDqoaiaAiJwBPAlcFnDMEFXdJiI1cfOSDwVeyn1iERkJjARo1qxZGEIvZenp7tmNSy6Bdu38jsYYU44F26vqPRGpHbBcR0TeLeSwbUDTgOU4b12gG4E5AKq6HDecSX3vM+KABcDvVfX7rANUdZv3cz/wCq5K7ASqOkVV41U1vkGDBoVfZKRbtAhSUmwUXGOM74Ktqqrv9aQCQFV/pfAnx1cArUWkhYhUBgYBi3LtsxXoCSAip+MSR6qXpN4G7lfVz7J2FpGKIpKVWCoBfYC1QV5D2ZaQAM2aQZ8+fkdijCnngk0cmSJyvL5HRJqTx2i5gVQ1HRiL6xG1Add7ap2IjBeRq7zd/gjcJCJfAa8Cw1VVveNaAY/k6nZbBXhXRNYASbgSzPNBXkPZtX49fPABjBkDFYPtCGeMMeEh7j5dyE4ivYApwEeAAL8BRqpqYdVVESE+Pl4TE8tw792xY+H5511VVTRUuxljygQRWamq8bnXB9s4/o6IxOMam1cDC4HDoQ3R5GnfPpgxAwYNsqRhjIkIwQ5y+AfgdlwDdxLwf8Byck4la8Lh5ZfhwAFrFDfGRIxg2zhuB84GflDVi4AuwJ6CDzElpuoaxc8+G7rl2XnMGGNKXbAtrWmqmiYiiEgVVf1GRNqGNTIDy5bBhg0wfbrfkRhjzHHBJo4Ur4vsQuA9EfkV+CF8YRnAjYJbrx5ce63fkRhjzHHBNo73996OE5FluHGl3glbVAa2boU33oB77oHYWL+jMcaY44r8UICqfhSOQEwuzz3nfo4e7W8cxhiTS3HnHDfhdOSIe26jTx9o3tzvaIwxJgdLHJFo7lxITbWpYY0xEckSRyRKSIA2baBnT78jMcaYE1jiiDQrV8Lnn7sH/irYr8cYE3nszhRpEhKgenUYNszvSIwxJk+WOCLJrl3w6qswdCjUquV3NMYYkydLHJFk6lRIS7NxqYwxEc0SR6TIyIBJk+CCC6BDB7+jMcaYfFniiBRLlsCWLVbaMMZEvLAmDhHpJSIbRSRZRO7PY3szEVkmIqtFZI2IXBmw7QHvuI0icnmw5yyzJk6Exo2hXz+/IzHGmAKFLXGISAyQAFwBtAcGi0j7XLs9hJtStgtuTvJJ3rHtveUzgF7AJBGJCfKcZc9338G778KoUVCpkt/RGGNMgcJZ4ugGJKvqJlU9CswG+ubaR4GTvPe1gJ+8932B2ap6RFU3A8ne+YI5Z9kzaZJLGCNH+h2JMcYUKpyJownwY8Byircu0DjgehFJARYDtxZybDDnBEBERopIoogkpqamFvcawu/gQZg2DQYOhFNO8TsaY4wplN+N44OB6aoaB1wJvCwiIYlJVaeoaryqxjeI5Lm6Z82CvXttXCpjTJlR5GHVi2Ab0DRgOc5bF+hGXBsGqrpcRGKB+oUcW9g5y46sqWE7dYLu3f2OxhhjghLOEscKoLWItBCRyrjG7kW59tkK9AQQkdOBWCDV22+QiFQRkRZAa+DLIM9Zdnz6KaxZ40obIn5HY4wxQQlbiUNV00VkLPAuEANMVdV1IjIeSFTVRcAfgedF5E5cQ/lwVVVgnYjMAdYD6cAtqpoBkNc5w3UNYZeQALVrw3XX+R2JMcYETdx9OrrFx8drYmKi32Hk9NNPcOqpcNtt8NRTfkdjjDEnEJGVqhqfe73fjePl15QpkJ4OY8b4HYkxxhSJJQ4/HD3q5hS/4gpo1crvaIwxpkgscfhhwQLYscO64BpjyiRLHH5ISICWLaFXL78jMcaYIrPEUdrWrIFPPoGbb7apYY0xZZLduUpbQgLExsKIEX5HYowxxWKJozTt2QMzZ8KQIVC3rt/RGGNMsVjiKE3Tp8OhQzZZkzGmTLPEUVoyM101Vffu0KWL39EYY0yxWeIoLe+9B8nJVtowxpR5ljhKy8SJcPLJcPXVfkdijDElYomjNGzeDG+/DTfdBJUr+x2NMcaUiCWO0jB5sntmY9QovyMxxpgSs8QRbocPw4svQr9+EBfndzTGGFNiljjCbfZs2L3bxqUyxkQNSxzhpOoaxc84Ay64wO9ojDEmJMKaOESkl4hsFJFkEbk/j+1Pi0iS9/pWRPZ46y8KWJ8kImki0s/bNl1ENgds6xzOayiRL76AVatcF1ybGtYYEyXCNnWsiMQACcClQAqwQkQWqer6rH1U9c6A/W8FunjrlwGdvfV1gWTgvwGnv0dVXw9X7CGTkAA1a8L11/sdiTHGhEw4SxzdgGRV3aSqR4HZQN8C9h8MvJrH+quBJap6KAwxhs/OnTBnDgwf7pKHMcZEiXAmjibAjwHLKd66E4jIqUAL4IM8Ng/ixITymIis8aq6quRzzpEikigiiampqUWPvqReeMHN9HfzzaX/2cYYE0aR0jg+CHhdVTMCV4pII+BM4N2A1Q8A7YCzgbrAfXmdUFWnqGq8qsY3aNAgPFHnJz3dPbtxySXQrl3pfrYxxoRZOBPHNqBpwHKcty4veZUqAH4HLFDVY1krVHW7OkeAabgqscjy5puQkmLjUhljolI4E8cKoLWItBCRyrjksCj3TiLSDqgDLM/jHCe0e3ilEEREgH7A2hDHXXITJ0KzZtCnj9+RGGNMyIUtcahqOjAWV820AZijqutEZLyIXBWw6yBgtqpq4PEi0hxXYvko16lnicjXwNdAfeDR8FxBMW3YAB98AKNHQ8WwdVozxhjfSK77dVSKj4/XxMTE0vmwsWPh+eddVVVpt60YY0wIichKVY3PvT5SGsejw759MGMGXHutJQ1jTNSyxBFKL78MBw7YuFTGmKhmiSNUVN2T4vHx0C3yOnoZY0yoWOttqCxb5hrGp0/3OxJjjAkrK3GEysSJUK+ea98wxpgoZokjFLZuhTfegD/8AWJj/Y7GGGPCyhJHKDz3nGvjGD3a70iMMSbsLHGU1JEj7rmN3/4Wmjf3OxpjjAk7SxwlNXcupKZaF1xjTLlhiaOkEhKgTRvo2dPvSIwxplRY4iiJlSvh88/dKLgV7Ks0xpQPdrcriYQEqF4dhg3zOxJjjCk1ljiKa9cuePVVGDoUatXyOxpjjCk1ljiKa+pUSEuzyZqMMeWOJY7iyMiASZPgggugQwe/ozHGmFJliaM4liyBLVustGGMKZfCmjhEpJeIbBSRZBG5P4/tT4tIkvf6VkT2BGzLCNi2KGB9CxH5wjvna960tKVr4kRo3Bj69Sv1jzbGGL+FLXGISAyQAFwBtAcGi0j7wH1U9U5V7ayqnYF/A/MDNh/O2qaqgVPNPgk8raqtgF+BG8N1DXn67jt4910YNQoqVSrVjzbGmEgQzhJHNyBZVTep6lFgNtC3gP0HA68WdEIREeBi4HVv1QygdP/snzTJJYyRI0v1Y40xJlKEM3E0AX4MWE7x1p1ARE4FWgAfBKyOFZFEEflcRLKSQz1gj6qmB3HOkd7xiampqSW5jmwHD8K0aTBwIJxySmjOaYwxZUykTOQ0CHhdVTMC1p2qqttEpCXwgYh8DewN9oSqOgWYAhAfH68hiXLWLNi718alMsaUa+EscWwDmgYsx3nr8jKIXNVUqrrN+7kJ+BDoAuwCaotIVsIr6JyhlTU1bKdO0L17qXykMcZEonAmjhVAa68XVGVccliUeycRaQfUAZYHrKsjIlW89/WBHsB6VVVgGXC1t+sw4I0wXkO2Tz+FNWtcaUOkVD7SGGMiUdgSh9cOMRZ4F9gAzFHVdSIyXkQCe0kNAmZ7SSHL6UCiiHyFSxRPqOp6b9t9wF0ikoxr83gxXNeQQ0IC1K4N111XKh9njDGRSnLer6NTfHy8JiYmFv8E27dDs2Zw223w1FOhC8wYYyKYiKxU1fjc6+3J8WBMmQLp6TBmjN+RGGOM7yxxFObYMTen+BVXQKtWfkdjjDG+i5TuuJFrwQJXVfX8835HYowxEcFKHIWZOBFatoRevfyOxBhjIoIljoKsWQOffOLaNmJi/I7GGGMigiWOgiQkQGws3HCD35EYY0zEsMRRkNNOgzvugLp1/Y7EGGMihjWOF+Tee/2OwBhjIo6VOIwxxhSJJQ5jjDFFYonDGGNMkVjiMMYYUySWOIwxxhSJJQ5jjDFFYonDGGNMkVjiMMYYUyTlYiInEUkFfijm4fWBX0IYjp+i5Vqi5TrAriVSRcu1lPQ6TlXVBrlXlovEURIikpjXDFhlUbRcS7RcB9i1RKpouZZwXYdVVRljjCkSSxzGGGOKxBJH4ab4HUAIRcu1RMt1gF1LpIqWawnLdVgbhzHGmCKxEocxxpgiscRhjDGmSCxxFEBEeonIRhFJFpH7/Y6nuERkqojsFJG1fsdSEiLSVESWich6EVknIrf7HVNxiUisiHwpIl951/IXv2MqCRGJEZHVIvKW37GUhIhsEZGvRSRJRBL9jqckRKS2iLwuIt+IyAYROTdk57Y2jryJSAzwLXApkAKsAAar6npfAysGETkfOAC8pKod/I6nuESkEdBIVVeJSE1gJdCvjP5OBKiuqgdEpBLwKXC7qn7uc2jFIiJ3AfHASarax+94iktEtgDxqlrmH/4TkRnAJ6r6gohUBqqp6p5QnNtKHPnrBiSr6iZVPQrMBvr6HFOxqOrHwG6/4ygpVd2uqqu89/uBDUATf6MqHnUOeIuVvFeZ/CtOROKA3sALfsdiHBGpBZwPvAigqkdDlTTAEkdBmgA/BiynUEZvUtFIRJoDXYAv/I2k+LzqnSRgJ/CeqpbVa3kGuBfI9DuQEFDgvyKyUkRG+h1MCbQAUoFpXhXiCyJSPVQnt8RhyhwRqQHMA+5Q1X1+x1Ncqpqhqp2BOKCbiJS5akQR6QPsVNWVfscSIuep6lnAFcAtXjVvWVQROAuYrKpdgINAyNppLXHkbxvQNGA5zltnfOS1B8wDZqnqfL/jCQWvCmEZ0MvvWIqhB3CV1zYwG7hYRGb6G1Lxqeo27+dOYAGuyrosSgFSAkqxr+MSSUhY4sjfCqC1iLTwGpYGAYt8jqlc8xqUXwQ2qOo//Y6nJESkgYjU9t5XxXXC+MbfqIpOVR9Q1ThVbY77P/KBql7vc1jFIiLVvU4XeNU6lwFlsieiqu4AfhSRtt6qnkDIOpFUDNWJoo2qpovIWOBdIAaYqqrrfA6rWETkVeBCoL6IpAB/VtUX/Y2qWHoAQ4GvvbYBgAdVdbGPMRVXI2CG13uvAjBHVct0V9YocDKwwP19QkXgFVV9x9+QSuRWYJb3h+8mYESoTmzdcY0xxhSJVVUZY4wpEkscxhhjisQShzHGmCKxxGGMMaZILHEYY4wpEkscxkQ4EbmwrI86a6KLJQ5jjDFFYonDmBARkeu9OTaSROQ5bxDDAyLytDfnxvsi0sDbt7OIfC4ia0RkgYjU8da3EpGl3jwdq0TkNO/0NQLmVpjlPUVvjC8scRgTAiJyOnAt0MMbuDADGAJUBxJV9QzgI+DP3iEvAfepakfg64D1s4AEVe0EdAe2e+u7AHcA7YGWuKfojfGFDTliTGj0BLoCK7zCQFXccOmZwGvePjOB+d5cCbVV9SNv/QxgrjdOUhNVXQCgqmkA3vm+VNUUbzkJaI6b/MmYUmeJw5jQEGCGqj6QY6XIw7n2K+4YP0cC3mdg/3eNj6yqypjQeB+4WkQaAohIXRE5Ffd/7Gpvn+uAT1V1L/CriPzGWz8U+Mib1TBFRPp556giItVK9SqMCYL91WJMCKjqehF5CDd7XAXgGHALbgKdbt62nbh2EIBhwH+8xBA4culQ4DkRGe+d45pSvAxjgmKj4xoTRiJyQFVr+B2HMaFkVVXGGGOKxEocxhhjisRKHMYYY4rEEocxxpgiscRhjDGmSCxxGGOMKRJLHMYYY4rk/wGAeeMnZCmcQwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "#Graphing our training and validation\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",
        "epochs = range(len(acc))\n",
        "plt.plot(epochs, acc, 'r', label='Training acc')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.ylabel('accuracy')  \n",
        "plt.xlabel('epoch')\n",
        "plt.legend()\n",
        "plt.figure()\n",
        "# plt.plot(epochs, loss, 'r', label='Training loss')\n",
        "# plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
        "# plt.title('Training and validation loss')\n",
        "# plt.ylabel('loss')  \n",
        "# plt.xlabel('epoch')\n",
        "# plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i9ZrSWWMAMIu"
      },
      "source": [
        "## Model Evaluation on Testing Set"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "inzpFlDcAMIu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f355a96-9281-4a26-ce07-5e854a41a12f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "58/58 [==============================] - 1s 9ms/step - loss: 0.2321 - acc: 0.9241\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.23205307126045227, 0.924119234085083]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ],
      "source": [
        "model.evaluate(test_data, test_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fw4qhV3qAMIv"
      },
      "source": [
        "## Classification metrics and Confusion Matrix"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V8qSXGPOAMIv"
      },
      "source": [
        "### Classification Metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": false,
        "id": "6tIRlUCWAMIw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1dd18910-8e01-4a67-b420-9b9618210e48"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "58/58 [==============================] - 1s 9ms/step\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            " butterflies       0.98      0.88      0.93       371\n",
            "    chickens       0.89      0.89      0.89       203\n",
            "   elephants       0.89      0.89      0.89       152\n",
            "      horses       0.98      0.93      0.95       472\n",
            "     spiders       0.90      0.96      0.93       403\n",
            "   squirrels       0.92      0.91      0.92       244\n",
            "\n",
            "   micro avg       0.94      0.92      0.93      1845\n",
            "   macro avg       0.93      0.91      0.92      1845\n",
            "weighted avg       0.94      0.92      0.93      1845\n",
            " samples avg       0.92      0.92      0.92      1845\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in samples with no predicted labels. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ],
      "source": [
        "animals = ['butterflies', 'chickens', 'elephants', 'horses', 'spiders', 'squirrels']\n",
        "preds = np.round(model.predict(test_data),0) \n",
        "classification_metrics = metrics.classification_report(test_labels, preds, target_names=animals )\n",
        "print(classification_metrics)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7GuEOmfuAMIw"
      },
      "source": [
        "### Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_zcwn69PAMIw"
      },
      "outputs": [],
      "source": [
        "# converting from dataframe to numpy\n",
        "categorical_test_labels = pd.DataFrame(test_labels).idxmax(axis=1)\n",
        "categorical_preds = pd.DataFrame(preds).idxmax(axis=1)\n",
        "# print(categorical_preds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3mKBlwE_AMIx"
      },
      "outputs": [],
      "source": [
        "cm= confusion_matrix(categorical_test_labels, categorical_preds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yb2iHsn3AMIx"
      },
      "outputs": [],
      "source": [
        "#To get better visual of the confusion matrix:\n",
        "def plot_confusion_matrix(cm, classes,\n",
        "             normalize=False,\n",
        "             title='Confusion matrix',\n",
        "             cmap=plt.cm.Blues):\n",
        "    #Add Normalization Option\n",
        "    '''prints pretty confusion metric with normalization option '''\n",
        "    if normalize:\n",
        "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
        "        print(\"Normalized confusion matrix\")\n",
        "    else:\n",
        "        print('Confusion matrix, without normalization')\n",
        "    \n",
        "#     print(cm)\n",
        "    \n",
        "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
        "    plt.title(title)\n",
        "    plt.colorbar()\n",
        "    tick_marks = np.arange(len(classes))\n",
        "    plt.xticks(tick_marks, classes, rotation=45)\n",
        "    plt.yticks(tick_marks, classes)\n",
        "    \n",
        "    fmt = '.2f' if normalize else 'd'\n",
        "    thresh = cm.max() / 2.\n",
        "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
        "        plt.text(j, i, format(cm[i, j], fmt), horizontalalignment=\"center\", color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "    \n",
        "    plt.tight_layout()\n",
        "    plt.ylabel('True label')\n",
        "    plt.xlabel('Predicted label')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Uc884xvGAMIx"
      },
      "outputs": [],
      "source": [
        "plot_confusion_matrix(cm, animals)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3xOtldYBAMIx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 328
        },
        "outputId": "110eeb3a-b7a8-4cee-891f-b36b045dcfbd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Normalized confusion matrix\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "\n",
        "plot_confusion_matrix(cm, \n",
        "                      animals,\n",
        "                     normalize=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O3_O1rIxAMIx"
      },
      "source": [
        "## Testing images on model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yu3qtmRfAMIy"
      },
      "outputs": [],
      "source": [
        "def read_image(file_path):\n",
        "    print(\"[INFO] loading and preprocessing image...\")  \n",
        "    image = load_img(file_path, target_size=(224, 224))  \n",
        "    image = img_to_array(image)  \n",
        "    image = np.expand_dims(image, axis=0)\n",
        "    image /= 255.  \n",
        "    return image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KosUNiUMAMIy"
      },
      "outputs": [],
      "source": [
        "def test_single_image(path):\n",
        "    image = read_image(path)\n",
        "    time.sleep(.5)\n",
        "    bt_prediction = vgg16.predict(image)  \n",
        "    preds = model.predict(bt_prediction)\n",
        "    for idx, animal, x in zip(range(0,6), animals , preds[0]):\n",
        "        print(\"ID: {}, Label: {} {}%\".format(idx, animal, round(x*100,2) ))\n",
        "    print('Final Decision:')\n",
        "    time.sleep(.5)\n",
        "    for x in range(3):\n",
        "        print('.'*(x+1))\n",
        "        time.sleep(.2)\n",
        "    class_predicted = np.argmax(model.predict(bt_prediction), axis=-1)\n",
        "    class_dictionary = generator_top.class_indices  \n",
        "    inv_map = {v: k for k, v in class_dictionary.items()}  \n",
        "    print(\"ID: {}, Label: {}\".format(class_predicted[0], inv_map[class_predicted[0]]))  \n",
        "    return load_img(path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DeeLyXL7AMIy"
      },
      "outputs": [],
      "source": [
        "# path = 'data/test/butterears2.jpg'\n",
        "path = '/content/test images/elephant01.jpeg'\n",
        "test_single_image(path)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "# print(list(uploaded.keys()))\n",
        "bruh = list(uploaded.keys())[0]\n",
        "print('User uploaded file \"{name}\" with length {length} bytes'.format(name=bruh, length=len(uploaded[bruh])))\n",
        "test_single_image(bruh)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 518
        },
        "id": "wXcEHVp_sJDy",
        "outputId": "a872c22b-ee41-435c-bcd0-577705a23738"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-ed42fb2b-5987-4721-839b-80cde3de0af6\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-ed42fb2b-5987-4721-839b-80cde3de0af6\">\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": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving download.jpeg to download.jpeg\n",
            "User uploaded file \"download.jpeg\" with length 7231 bytes\n",
            "[INFO] loading and preprocessing image...\n",
            "1/1 [==============================] - 1s 592ms/step\n",
            "1/1 [==============================] - 0s 18ms/step\n",
            "ID: 0, Label: butterflies 61.07%\n",
            "ID: 1, Label: chickens 1.08%\n",
            "ID: 2, Label: elephants 0.02%\n",
            "ID: 3, Label: horses 0.78%\n",
            "ID: 4, Label: spiders 35.33%\n",
            "ID: 5, Label: squirrels 1.72%\n",
            "Final Decision:\n",
            ".\n",
            "..\n",
            "...\n",
            "1/1 [==============================] - 0s 19ms/step\n",
            "ID: 0, Label: butterflies\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=300x168 at 0x7F914D8A44F0>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    }
  ],
  "metadata": {
    "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.8.10"
    },
    "vscode": {
      "interpreter": {
        "hash": "9ec81b5741290afa0545a4f5062f07e05d97808451c29876a22c76fe0d3ca11f"
      }
    },
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "Fm7QO8_N5xrh"
      ],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}