fx_cnn.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ameram/dcnn-classification/blob/master/fx_cnn.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Intro\n",
        "This project is my final project, where I try to use a DCNN and VGG16 (which is also a DCNN) for getting the features out the input pictures. After that using a SVM model to classify the features."
      ],
      "metadata": {
        "id": "XWmvJK08C7gv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PART I\n",
        "# Fetching and preparing the data"
      ],
      "metadata": {
        "id": "Z9WpvjdZChZK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Connecting to google drive for getting the data\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JR8Aqiz42Ew1",
        "outputId": "0dec9d5d-eded-4526-ca5e-7c45773822f8"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Importing necessary library for creating the model, navigating through Google Drive\n",
        "import os\n",
        "import matplotlib.pyplot as plt\n",
        "import keras\n",
        "from keras import layers, Sequential\n",
        "from skimage.io import imread\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "from keras.optimizers import SGD\n",
        "from tensorflow.keras.preprocessing import image_dataset_from_directory\n",
        "\n",
        "os.chdir('drive/MyDrive/data')"
      ],
      "metadata": {
        "id": "n2eAdMaGKIlM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        },
        "outputId": "f0202cec-4da6-49ec-89af-a37b3e6eb95d"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-bca335a3ba1c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mtensorflow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpreprocessing\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mimage_dataset_from_directory\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'drive/MyDrive/data'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'drive/MyDrive/data'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Creating test and validation datasets\n",
        "\n",
        "\n",
        "test = image_dataset_from_directory('.', class_names=['fruits', 'humans'], seed = 42, subset = 'training', validation_split=0.2, image_size=(100, 100))\n",
        "val = image_dataset_from_directory('.', class_names=['fruits', 'humans'], seed = 42, subset = 'validation', validation_split=0.2, image_size=(100, 100))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hEDYhSnu7UoS",
        "outputId": "df7837f6-3eda-4eb6-d471-5d54a6048d83"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 100 files belonging to 2 classes.\n",
            "Using 80 files for training.\n",
            "Found 100 files belonging to 2 classes.\n",
            "Using 20 files for validation.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This is another way to import our data, which seems to perform better the preivous method.\n",
        "# In this method images are converted to a numpy array, and then we get an array for data\n",
        "# and another one for labels. After that we can scale it and split it.\n",
        "# So finally there are 4 arrays (2 features, 2 labels) instead of 2 datasets.\n",
        "\n",
        "\n",
        "Categories=['humans','fruits']\n",
        "\n",
        "flat_data_arr=[]  #input array\n",
        "target_arr=[]     #output array\n",
        "\n",
        "# This variable is for navigating folder structure, we don't need it.\n",
        "datadir='' \n",
        "\n",
        "# Get the data for each category which is also the name of folder\n",
        "# Structure should be something like this\n",
        "# / (wd)\n",
        "#   class1/\n",
        "#       file1.jpg\n",
        "#       file2.jpg\n",
        "#       ...\n",
        "#   class2/\n",
        "#       file1.jpg\n",
        "#       file2.jpg\n",
        "#       ...\n",
        "\n",
        "\n",
        "for i in Categories:\n",
        "    \n",
        "    print(f'Loading... category : {i}')\n",
        "    path=os.path.join(datadir,i)\n",
        "\n",
        "    for img in os.listdir(path):\n",
        "        img_array=imread(os.path.join(path,img))\n",
        "        flat_data_arr.append(np.asarray(img_array))\n",
        "        target_arr.append(Categories.index(i))\n",
        "    print(f'loaded category:{i} successfully')\n",
        "print(f\"{len(flat_data_arr)} added successfully\")"
      ],
      "metadata": {
        "id": "VHQyXaYCf4WU",
        "outputId": "89d8e0d5-27f0-4a48-c6a2-3253677e53a7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading... category : humans\n",
            "loaded category:humans successfully\n",
            "Loading... category : fruits\n",
            "loaded category:fruits successfully\n",
            "100 added successfully\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Preprocessing after we get the data\n",
        "# 1. Convert lists to np.array\n",
        "X_array = np.array(flat_data_arr)\n",
        "y_array = np.array(target_arr)\n",
        "\n",
        "# 2. Split the data\n",
        "x_train, x_test, y_train, y_test = train_test_split(X_array, y_array, test_size=0.2,random_state=42,stratify=y_array)\n",
        "\n",
        "# 3. Normalize the data\n",
        "x_train = x_train / 255.0\n",
        "x_test = x_test / 255.0\n",
        "\n",
        "print(f'Shape of training array: {x_train.shape}')\n",
        "print(f'Shape of testing array: {x_test.shape}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "acHk1FrJ915K",
        "outputId": "e707a427-4c78-4ec6-c672-9d48a7cc5982"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape of training array: (80, 100, 100, 3)\n",
            "Shape of testing array: (20, 100, 100, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PART II\n",
        "# Experimenting with DCNN and NN"
      ],
      "metadata": {
        "id": "SP-OdFQOCbzT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Time to create the convolutional classifier\n",
        "# this is not the main task and was create for the sake of \n",
        "# experimenting. We can safely skip this part.\n",
        "\n",
        "# inputs = keras.Input(shape=(100, 100, 3))\n",
        "# x = layers.Rescaling(1)(inputs)\n",
        "# x = layers.Conv2D(filters=16, kernel_size=3, activation=\"relu\")(x)\n",
        "# x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "# x = layers.Conv2D(filters=32, kernel_size=3, activation=\"relu\")(x)\n",
        "# x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "# x = layers.Conv2D(filters=64, kernel_size=3, activation=\"relu\")(x)\n",
        "# x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "# x = layers.Conv2D(filters=128, kernel_size=3, activation=\"relu\")(x)\n",
        "# x = layers.MaxPooling2D(pool_size=2)(x)\n",
        "# x = layers.Conv2D(filters=128, kernel_size=3, activation=\"relu\")(x)\n",
        "# x = layers.Flatten()(x)\n",
        "# outputs = layers.Dense(1, activation=\"tanh\")(x)\n",
        "# model = keras.Model(inputs=inputs, outputs=x)\n",
        "\n",
        "\n",
        "model = Sequential([\n",
        "    layers.Conv2D(filters=8,kernel_size=(3,3),  input_shape = (100, 100, 3),activation='relu'),\n",
        "    layers.MaxPooling2D(pool_size=(2,2)),\n",
        "\n",
        "    layers.Conv2D(filters=16,kernel_size=(3,3), activation='relu'),\n",
        "    layers.MaxPooling2D(pool_size=(2,2)),\n",
        "    # layers.Dropout(0.25),\n",
        "\n",
        "    layers.Conv2D(filters=32,kernel_size=(3,3), activation='relu'),\n",
        "    layers.MaxPooling2D(pool_size=(2,2)),\n",
        "    layers.Dropout(0.25),\n",
        "\n",
        "    layers.Flatten(),\n",
        "    layers.Dense(128, activation='relu'),\n",
        "    # layers.Dropout(0.25),\n",
        "    layers.Dense(1, activation='softmax')\n",
        "])"
      ],
      "metadata": {
        "id": "741ehfbT4ZA9"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Same here, just a normal dense neural network for classification.\n",
        "nn_model = keras.models.Sequential()\n",
        "nn_model.add(keras.layers.Flatten(input_shape=[100, 100, 3]))\n",
        "nn_model.add(keras.layers.Dense(2200, activation=\"relu\"))\n",
        "nn_model.add(keras.layers.Dense(1000, activation=\"relu\"))\n",
        "nn_model.add(keras.layers.Dense(90, activation=\"relu\"))\n",
        "nn_model.add(keras.layers.Dense(1, activation=\"sigmoid\"))"
      ],
      "metadata": {
        "id": "em9KiF1vsAcU"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZWL_Wmid47yx",
        "outputId": "3da369be-5b58-4921-cf56-5a99df56ee80"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 98, 98, 8)         224       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 49, 49, 8)        0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 47, 47, 16)        1168      \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 23, 23, 16)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 21, 21, 32)        4640      \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 10, 10, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 10, 10, 32)        0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 3200)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 128)               409728    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 129       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 415,889\n",
            "Trainable params: 415,889\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn_model.summary()"
      ],
      "metadata": {
        "id": "duy1JEZvr5yA",
        "outputId": "7485d00d-df55-4f2f-e3a7-e3c4ce0c72be",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " flatten_1 (Flatten)         (None, 30000)             0         \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 2200)              66002200  \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 1000)              2201000   \n",
            "                                                                 \n",
            " dense_4 (Dense)             (None, 90)                90090     \n",
            "                                                                 \n",
            " dense_5 (Dense)             (None, 1)                 91        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 68,293,381\n",
            "Trainable params: 68,293,381\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# LOSSES: categorical_crossentropy\n",
        "# OPTIMIZERS: tf.keras.optimizers.RMSprop(learning_rate=0.001)\n",
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "4gx-gRxK5fBC"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nn_model.compile(loss=\"binary_crossentropy\",\n",
        "                 optimizer=\"sgd\", metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "id": "IjP6t1FBs0gq"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# This is with numpy \n",
        "cnn_history_np = model.fit(x_train, y_train,\n",
        "                           epochs=4, validation_data=(x_test, y_test))"
      ],
      "metadata": {
        "id": "wkoT5cM6n9cs",
        "outputId": "8a5965e2-42c3-4d46-c6ee-3b6f990ef7de",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "3/3 [==============================] - 2s 435ms/step - loss: 0.6789 - accuracy: 0.5000 - val_loss: 0.6550 - val_accuracy: 0.5000\n",
            "Epoch 2/4\n",
            "3/3 [==============================] - 2s 481ms/step - loss: 0.6637 - accuracy: 0.5000 - val_loss: 0.6496 - val_accuracy: 0.5000\n",
            "Epoch 3/4\n",
            "3/3 [==============================] - 1s 483ms/step - loss: 0.6554 - accuracy: 0.5000 - val_loss: 0.6397 - val_accuracy: 0.5000\n",
            "Epoch 4/4\n",
            "3/3 [==============================] - 1s 427ms/step - loss: 0.6443 - accuracy: 0.5000 - val_loss: 0.6321 - val_accuracy: 0.5000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This one is with default TF Datasets\n",
        "\n",
        "cnn_history = model.fit(\n",
        "    test,\n",
        "    epochs=5,\n",
        "    validation_data=val)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-kHETBBh9iru",
        "outputId": "de5bfd0b-79f5-4388-bdb3-cc58915e4900"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "3/3 [==============================] - 2s 411ms/step - loss: 16670138.0000 - accuracy: 0.4750 - val_loss: 28760756224.0000 - val_accuracy: 0.6000\n",
            "Epoch 2/5\n",
            "3/3 [==============================] - 1s 290ms/step - loss: nan - accuracy: 0.5000 - val_loss: nan - val_accuracy: 0.4000\n",
            "Epoch 3/5\n",
            "3/3 [==============================] - 1s 164ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n",
            "Epoch 4/5\n",
            "3/3 [==============================] - 1s 165ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n",
            "Epoch 5/5\n",
            "3/3 [==============================] - 1s 165ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn_history = nn_model.fit(test, epochs=5, validation_data=val)"
      ],
      "metadata": {
        "id": "-bh1A9VVl9RB",
        "outputId": "bb00a5a1-f79e-4e6f-84f1-507a6719ddb9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "3/3 [==============================] - 2s 533ms/step - loss: 1591381458944.0000 - accuracy: 0.5500 - val_loss: 15063544332136753397760.0000 - val_accuracy: 0.6000\n",
            "Epoch 2/5\n",
            "3/3 [==============================] - 2s 726ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n",
            "Epoch 3/5\n",
            "3/3 [==============================] - 2s 488ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n",
            "Epoch 4/5\n",
            "3/3 [==============================] - 1s 459ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n",
            "Epoch 5/5\n",
            "3/3 [==============================] - 1s 461ms/step - loss: nan - accuracy: 0.5250 - val_loss: nan - val_accuracy: 0.4000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nn_history_np = nn_model.fit(x_train, y_train, epochs=4, validation_data=(x_test, y_test))"
      ],
      "metadata": {
        "id": "_Mz-Oyn5tOCh",
        "outputId": "85b1b49a-2f5e-4316-bd04-086763808332",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "3/3 [==============================] - 2s 557ms/step - loss: nan - accuracy: 0.5000 - val_loss: nan - val_accuracy: 0.5000\n",
            "Epoch 2/4\n",
            "3/3 [==============================] - 1s 459ms/step - loss: nan - accuracy: 0.5000 - val_loss: nan - val_accuracy: 0.5000\n",
            "Epoch 3/4\n",
            "3/3 [==============================] - 1s 464ms/step - loss: nan - accuracy: 0.5000 - val_loss: nan - val_accuracy: 0.5000\n",
            "Epoch 4/4\n",
            "3/3 [==============================] - 2s 657ms/step - loss: nan - accuracy: 0.5000 - val_loss: nan - val_accuracy: 0.5000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy = cnn_history.history[\"accuracy\"]\n",
        "val_accuracy = cnn_history.history[\"val_accuracy\"]\n",
        "loss = cnn_history.history[\"loss\"]\n",
        "val_loss = cnn_history.history[\"val_loss\"]\n",
        "epochs = range(1, len(accuracy) + 1)\n",
        "\n",
        "plt.plot(epochs, accuracy, \"r\", label=\"Training accuracy\")\n",
        "plt.plot(epochs, val_accuracy, \"b\", label=\"Validation accuracy\")\n",
        "plt.title(\"Training and validation accuracy\")\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.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "id": "eoIrZeUx-mLW",
        "outputId": "b64e9f34-09f7-4e20-99d1-d45facc19e1d"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEICAYAAABWJCMKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU5fn/8feHsIkgyqIii8GKC4psERVcQFxQKQhRBKwQE8WNWm3VWrXqF+v3V1vr9q22tbK4Fi1Ui6LiSrVSlYC4gKKIWEBEBFkUQZb798dzJgxhkkzWyWTu13XNlZmzzX1OknOf85xz7kdmhnPOucxTL9UBOOecSw1PAM45l6E8ATjnXIbyBOCccxnKE4BzzmUoTwDOOZehPAG4IpKekzS6qqdNJUlLJJ1UDcs1SQdG7/8s6dfJTFuB7zlX0gsVjdO50sifA0hvkr6N+9gE2Axsiz5fZGaP1nxUtYekJcAFZvZSFS/XgE5mtqiqppWUDXwGNDCzrVURp3OlqZ/qAFzlmFnT2PvSdnaS6vtOxdUW/vdYO3gTUB0lqa+kZZJ+KelLYKKkvSQ9I2mVpG+i9+3i5pkp6YLofZ6kf0u6PZr2M0mnVXDajpJek7RB0kuS7pX0SAlxJxPjLZLeiJb3gqRWcePPk/S5pNWSri9l+xwl6UtJWXHDhkh6L3rfS9J/JK2VtELSHyU1LGFZkyT9Ju7z1dE8X0jKLzbtGZLekbRe0lJJN8eNfi36uVbSt5KOiW3buPl7S5otaV30s3ey26ac27mFpInROnwj6am4cYMlzYvW4VNJA6LhOzW3Sbo59nuWlB01hRVI+i/wSjT879HvYV30N3JY3Py7SfpD9PtcF/2N7SZpuqSfFluf9yQNSbSurmSeAOq2fYEWwP7AGMLve2L0uQPwPfDHUuY/ClgItAJ+B4yXpApM+xjwNtASuBk4r5TvTCbGkcD5wN5AQ+AqAEmdgT9Fy98v+r52JGBmbwHfAScWW+5j0fttwJXR+hwD9AcuLSVuohgGRPGcDHQCil9/+A4YBewJnAFcIunMaNzx0c89zaypmf2n2LJbANOBe6J1uwOYLqllsXXYZdskUNZ2fpjQpHhYtKw7oxh6AQ8BV0frcDywpKTtkcAJwKHAqdHn5wjbaW9gLhDfZHk70BPoTfg7vgbYDjwI/CQ2kaSuQFvCtnHlYWb+qiMvwj/iSdH7vsAPQONSpu8GfBP3eSahCQkgD1gUN64JYMC+5ZmWsHPZCjSJG/8I8EiS65QoxhviPl8KPB+9vxGYHDdu92gbnFTCsn8DTIjeNyPsnPcvYdorgCfjPhtwYPR+EvCb6P0E4Ldx0x0UP22C5d4F3Bm9z46mrR83Pg/4d/T+PODtYvP/B8gra9uUZzsDbQg72r0STPeXWLyl/f1Fn2+O/Z7j1u2AUmLYM5qmOSFBfQ90TTBdY+AbwnUVCInivpr+f6sLLz8DqNtWmdmm2AdJTST9JTqlXk9octgzvhmkmC9jb8xsY/S2aTmn3Q9YEzcMYGlJAScZ45dx7zfGxbRf/LLN7DtgdUnfRTjaHyqpETAUmGtmn0dxHBQ1i3wZxfG/hLOBsuwUA/B5sfU7StKrUdPLOuDiJJcbW/bnxYZ9Tjj6jSlp2+ykjO3cnvA7+ybBrO2BT5OMN5GibSMpS9Jvo2ak9ew4k2gVvRon+q7ob/px4CeS6gEjCGcsrpw8AdRtxW/x+gVwMHCUme3BjiaHkpp1qsIKoIWkJnHD2pcyfWViXBG/7Og7W5Y0sZktIOxAT2Pn5h8ITUkfEY4y9wCuq0gMhDOgeI8B04D2ZtYc+HPccsu6Je8LQpNNvA7A8iTiKq607byU8DvbM8F8S4EflbDM7whnfzH7Jpgmfh1HAoMJzWTNCWcJsRi+BjaV8l0PAucSmuY2WrHmMpccTwCZpRnhtHpt1J58U3V/YXREXQjcLKmhpGOAH1dTjFOAgZKOjS7YjqPsv/HHgJ8RdoB/LxbHeuBbSYcAlyQZwxNAnqTOUQIqHn8zwtH1pqg9fWTcuFWEppcDSlj2s8BBkkZKqi/pHKAz8EySsRWPI+F2NrMVhLb5+6KLxQ0kxRLEeOB8Sf0l1ZPUNto+APOA4dH0OcBZScSwmXCW1oRwlhWLYTuhOe0OSftFZwvHRGdrRDv87cAf8KP/CvMEkFnuAnYjHF29CTxfQ997LuFC6mpCu/vjhH/8RCoco5nNBy4j7NRXENqJl5Ux298IFyZfMbOv44ZfRdg5bwD+GsWcTAzPRevwCrAo+hnvUmCcpA2EaxZPxM27EbgVeEPh7qOjiy17NTCQcPS+mnBRdGCxuJNV1nY+D9hCOAv6inANBDN7m3CR+U5gHfAvdpyV/JpwxP4N8D/sfEaVyEOEM7DlwIIojnhXAe8Ds4E1wG3svM96COhCuKbkKsAfBHM1TtLjwEdmVu1nIK7ukjQKGGNmx6Y6lnTlZwCu2kk6UtKPoiaDAYR236fKms+5kkTNa5cC96c6lnTmCcDVhH0Jtyh+S7iH/RIzeyelEbm0JelUwvWSlZTdzORK4U1AzjmXofwMwDnnMlRaFYNr1aqVZWdnpzoM55xLK3PmzPnazFoXH55WCSA7O5vCwsJUh+Gcc2lFUvEnyAFvAnLOuYzlCcA55zKUJwDnnMtQaXUNwDm3w5YtW1i2bBmbNm0qe2KXERo3bky7du1o0KBBUtN7AnAuTS1btoxmzZqRnZ1Nyf30uExhZqxevZply5bRsWPHpOZJqglI0gBJCyUtknRtCdMMk7RA0nxJj8UNHy3pk+g1Om54T0nvR8u8p5SeppxzCWzatImWLVv6zt8BIImWLVuW64ywzDOAqIOIewld3C0DZkuaFtVSj03TCfgV0MfMvpG0dzQ8VmY2h1AHfE407zeEeusXAm8RytwOIJSgdc4lyXf+Ll55/x6SOQPoRejub7GZ/QBMJhTzinchcG+sByEz+yoafirwopnFehd6ERggqQ2wh5m9aaEWxUPAmVSTJ56Av/ylupbunHPpKZkE0Jadu7hbxs5d0EHo9/QgSW9IejOq+FjavG3ZuU57omUCIGmMpEJJhatWrUoi3F1NmQLXXw+bS6pA75wrt9WrV9OtWze6devGvvvuS9u2bYs+//DDD6XOW1hYyOWXX17md/Tu3buqwnUJVNVF4PpAJ0JH5O2A1yR1qYoFm9n9RCVfc3JyKlS5rqAA/v53ePppOKusPoqcc0lp2bIl8+bNA+Dmm2+madOmXHXVVUXjt27dSv36iXcxOTk55OTklPkds2bNqppga9C2bdvIyiqpm+3aJZkzgOXs3MdpO3btg3QZMM3MtpjZZ8DHhIRQ0rzLo/elLbPKnHQStG8P48dX1zc45wDy8vK4+OKLOeqoo7jmmmt4++23OeaYY+jevTu9e/dm4cKFAMycOZOBAwcCIXnk5+fTt29fDjjgAO65556i5TVt2rRo+r59+3LWWWdxyCGHcO655xKrZPzss89yyCGH0LNnTy6//PKi5cZbsmQJxx13HD169KBHjx47JZbbbruNLl260LVrV669NtzjsmjRIk466SS6du1Kjx49+PTTT3eKGWDs2LFMmjQJCGVqfvnLX9KjRw/+/ve/89e//pUjjzySrl27kpuby8aNGwFYuXIlQ4YMoWvXrnTt2pVZs2Zx4403ctdddxUt9/rrr+fuu++u9O8iGcmcAcwGOknqSNhJD2fnfkwhdO4xApgoqRWhSWgx8Cnwv5L2iqY7BfiVma2RtD7q8u4tYBTwf5VemxJkZUFeHvzmN7B0aUgGztUpV1wB0dF4lenWDeJ2TMlatmwZs2bNIisri/Xr1/P6669Tv359XnrpJa677jqmTp26yzwfffQRr776Khs2bODggw/mkksu2eVe9nfeeYf58+ez33770adPH9544w1ycnK46KKLeO211+jYsSMjRoxIGNPee+/Niy++SOPGjfnkk08YMWIEhYWFPPfcc/zzn//krbfeokmTJqxZswaAc889l2uvvZYhQ4awadMmtm/fztKlSxMuO6Zly5bMnTsXCM1jF154IQA33HAD48eP56c//SmXX345J5xwAk8++STbtm3j22+/Zb/99mPo0KFcccUVbN++ncmTJ/P222+Xe7tXRJkJwMy2ShoLzACygAlmNl/SOKDQzKZF406RtADYBlwd9V+KpFsISQRgnJmtid5fCkwi9Ev6HNV8B1BeHtxyCzz4INxwQ3V+k3OZ7eyzzy5qAlm3bh2jR4/mk08+QRJbtmxJOM8ZZ5xBo0aNaNSoEXvvvTcrV66kXbt2O03Tq1evomHdunVjyZIlNG3alAMOOKDovvcRI0Zw//27dhK2ZcsWxo4dy7x588jKyuLjjz8G4KWXXuL888+nSZMmALRo0YINGzawfPlyhgwZAoSHq5JxzjnnFL3/4IMPuOGGG1i7di3ffvstp556KgCvvPIKDz30EABZWVk0b96c5s2b07JlS9555x1WrlxJ9+7dadmyZVLfWVlJXQMws2cJt2rGD7sx7r0BP49exeedAExIMLwQOLyc8VbYAQfAiSfCxIlw3XVQz4tguLqkAkfq1WX33Xcvev/rX/+afv368eSTT7JkyRL69u2bcJ5GjRoVvc/KymLr1q0VmqYkd955J/vssw/vvvsu27dvT3qnHq9+/fps37696HPx++3j1zsvL4+nnnqKrl27MmnSJGbOnFnqsi+44AImTZrEl19+SX5+frljq6iM2g3m58PixfCvf6U6Eucyw7p162jbNtzgF2svr0oHH3wwixcvZsmSJQA8/vjjJcbRpk0b6tWrx8MPP8y2bdsAOPnkk5k4cWJRG/2aNWto1qwZ7dq146mnQrfVmzdvZuPGjey///4sWLCAzZs3s3btWl5++eUS49qwYQNt2rRhy5YtPProo0XD+/fvz5/+9CcgXCxet24dAEOGDOH5559n9uzZRWcLNSGjEsDQodC8OUzY5XzEOVcdrrnmGn71q1/RvXv3ch2xJ2u33XbjvvvuY8CAAfTs2ZNmzZrRvHnzXaa79NJLefDBB+natSsfffRR0dH6gAEDGDRoEDk5OXTr1o3bb78dgIcffph77rmHI444gt69e/Pll1/Svn17hg0bxuGHH86wYcPo3r17iXHdcsstHHXUUfTp04dDDjmkaPjdd9/Nq6++SpcuXejZsycLFoTnaRs2bEi/fv0YNmxYjd5BlFZ9Aufk5FhlO4S59NLQDLRiBey5ZxUF5lwKfPjhhxx66KGpDiPlvv32W5o2bYqZcdlll9GpUyeuvPLKVIdVLtu3by+6g6hTp06VWlaivwtJc8xsl/tuM+oMAMIzAZs2wd/+lupInHNV4a9//SvdunXjsMMOY926dVx00UWpDqlcFixYwIEHHkj//v0rvfMvr4w7AzALd7c1bAizZ5c9vXO1lZ8BuET8DKAUUjgLKCyE995LdTTOOZc6GZcAAM49N5wB+MVg51wmy8gE0LIlnHkmPPywF4hzzmWujEwAEJqB1qyBadNSHYlzzqVGxiaA/v29QJxzldGvXz9mzJix07C77rqLSy65pMR5+vbtS+xGjtNPP521a9fuMs3NN99cdD9+SZ566qmie+gBbrzxRl566aXyhO/I4ASQlQXnnw8vvBAKxDnnymfEiBFMnjx5p2GTJ08usSBbcc8++yx7VvBhnOIJYNy4cZx00kkVWlaqxJ5GTqWMTQAQCsSZQTU8oe5cnXfWWWcxffr0os5flixZwhdffMFxxx3HJZdcQk5ODocddhg33XRTwvmzs7P5+uuvAbj11ls56KCDOPbYY4tKRgMJyyrPmjWLadOmcfXVV9OtWzc+/fRT8vLymDJlCgAvv/wy3bt3p0uXLuTn57M5utCXnZ3NTTfdRI8ePejSpQsfffTRLjFlWtnoquoQJi117BiagiZODD2GeYE4l65SUQ26RYsW9OrVi+eee47BgwczefJkhg0bhiRuvfVWWrRowbZt2+jfvz/vvfceRxxxRMLlzJkzh8mTJzNv3jy2bt1Kjx496NmzJwBDhw5NWFZ50KBBDBw4kLOK9fC0adMm8vLyePnllznooIMYNWoUf/rTn7jiiisAaNWqFXPnzuW+++7j9ttv54EHHthp/kwrG53xu7z8fPjsMyijWJ9zLoH4ZqD45p8nnniCHj160L17d+bPn79Tc01xr7/+OkOGDKFJkybsscceDBo0qGjcBx98wHHHHUeXLl149NFHmT9/fqnxLFy4kI4dO3LQQQcBMHr0aF577bWi8UOHDgWgZ8+eRQXk4m3ZsoULL7yQLl26cPbZZxfFnWzZ6Nj40hQvG51o/V555ZWiaymxstHZ2dlFZaNfeOGFKikbndFnAABDhoSaQBMmhHLRzqWjVFWDHjx4MFdeeSVz585l48aN9OzZk88++4zbb7+d2bNns9dee5GXl7dL6eRklbesclliJaVLKiedaWWjM/4MYLfdYORImDoVEtyQ4JwrRdOmTenXrx/5+flFR//r169n9913p3nz5qxcuZLnniu9r6fjjz+ep556iu+//54NGzbw9NNPF40rqaxys2bN2LBhwy7LOvjgg1myZAmLFi0CQlXPE044Ien1ybSy0UklAEkDJC2UtEjStQnG50laJWle9LogGt4vbtg8SZsknRmNmyTps7hx3Sq9NhUUKxD32GOpisC59DVixAjefffdogTQtWtXunfvziGHHMLIkSPp06dPqfP36NGDc845h65du3Laaadx5JFHFo0rqazy8OHD+f3vf0/37t359NNPi4Y3btyYiRMncvbZZ9OlSxfq1avHxRdfnPS6ZFrZ6DKLwUnKInTyfjKh8/fZwAgzWxA3TR6QY2ZjS1lOC2AR0M7MNkqaBDxjZlOSDbYqisElYgbdu0P9+qFGkHPpwIvBZZ5kykZXdTG4XsAiM1tsZj8Ak4HB5Q+ds4DnzGxjBeatVrECcXPmwLvvpjoa55zbVXWUjU4mAbQF4u9rWhYNKy5X0nuSpkhqn2D8cKB4Ff5bo3nulNQowTxIGiOpUFLhqlWrkgi3YkaO9AJxzrnaq3PnzixevJg//OEPVbbMqroI/DSQbWZHAC8CD8aPlNQG6ALEPzf+K+AQ4EigBfDLRAs2s/vNLMfMclq3bl1F4e6qZctwR9Ajj3iBOJc+0qk/D1f9yvv3kEwCWA7EH9G3i4bFf+lqM4vtNh8AehZbxjDgSTPbEjfPCgs2AxMJTU0pFSsQ989/pjoS58rWuHFjVq9e7UnAAWHnv3r16nLduprMcwCzgU6SOhJ2/MOBkfETSGpjZiuij4OAD4stYwThiH+XeSQJOBP4IOmoq0n//tChQygQN2xYqqNxrnTt2rVj2bJlVGfTqEsvjRs3pl27dklPX2YCMLOtksYSmm+ygAlmNl/SOKDQzKYBl0saBGwF1gB5sfklZRPOIP5VbNGPSmoNCJgHJH+vVjWpVy8UiBs3Dv7735AMnKutGjRoQMeOHVMdhktjGdcncFmWLIEDDoCbb4Ybb6zWr3LOuRrhfQInKTt7R4G4uKe5nXOuzvEEkEB+fjgTePXVVEfinHPVxxNAArECcd5bmHOuLvMEkEDjxnDuufCPf8A336Q6Guecqx6eAEpQUBAeCPMCcc65usoTQAm6dw89InlpCOdcXeUJoBQFBTB3btV3teecc7WBJ4BSjBwJjRr5WYBzrm7yBFCKFi12FIirYI92zjlXa3kCKENBQbgTyAvEOefqGk8AZTjxRNh/f38mwDlX93gCKEOsQNxLL8Hnn6c6GuecqzqeAJKQlxd+TpqUyiicc65qeQJIwv77w0kneYE451zd4gkgSfn5oQnolVdSHYlzzlUNTwBJOvNM2GsvvxjsnKs7kkoAkgZIWihpkaRrE4zPk7RK0rzodUHcuG1xw6fFDe8o6a1omY9Lalg1q1Q9YgXinnwy9BvsnHPprswEICkLuBc4DegMjJDUOcGkj5tZt+j1QNzw7+OGD4obfhtwp5kdCHwDFFR8NWqGF4hzztUlyZwB9AIWmdliM/sBmAwMrsyXRh3BnwhMiQY9SOgYvlbr1i0UifPSEM65uiCZBNAWWBr3eVk0rLhcSe9JmiKpfdzwxpIKJb0pKbaTbwmsNbOtZSwTSWOi+QtXrVqVRLjVq6AA3nknvJxzLp1V1UXgp4FsMzsCeJFwRB+zf9QZ8UjgLkk/Ks+Czex+M8sxs5zWrVtXUbgV5wXinHN1RTIJYDkQf0TfLhpWxMxWm9nm6OMDQM+4ccujn4uBmUB3YDWwp6T6JS2zttprLxg6FB591AvEOefSWzIJYDbQKbprpyEwHJgWP4GkNnEfBwEfRsP3ktQoet8K6AMsMDMDXgXOiuYZDaRNubVYgbinnkp1JM45V3FlJoConX4sMIOwY3/CzOZLGicpdlfP5ZLmS3oXuBzIi4YfChRGw18FfmtmC6JxvwR+LmkR4ZpA2txh368fZGf7MwHOufSmcDCeHnJycqywsDDVYQAwbhzcfDMsXhySgXPO1VaS5kTXYnfiTwJXkBeIc86lO08AFdShA5x8cigQt21bqqNxzrny8wRQCfn58N//eoE451x68gRQCWeeGfoN9ovBzrl05AmgEho18gJxzrn05QmgkgoK4IcfwoNhzjmXTjwBVFLXrtCjh5eGcM6lH08AVaCgAObNg7lzUx2Jc84lzxNAFRg5MnQY42cBzrl04gmgCuy5544Ccd9/n+ponHMuOZ4AqkhBAaxd6wXinHPpwxNAFenbFzp29GcCnHPpwxNAFalXD84/H15+GT77LNXROOdc2TwBVKHRo0HyAnHOufTgCaAKdegAp5ziBeKcc+khqQQgaYCkhZIWSbo2wfg8SaskzYteF0TDu0n6T9RZzHuSzombZ5Kkz+Lm6VZ1q5U6+fmwdGloCnLOudqsflkTSMoC7gVOBpYBsyVNi+vZK+ZxMxtbbNhGYJSZfSJpP2COpBlmtjYaf7WZTankOtQqgwfvKBB3yimpjsY550pWZgIAegGLok7dkTQZGAwUTwC7MLOP495/IekroDWwtuS50lujRvCTn8Cf/wyrV0PLlqmOyFUrM3j3XXjnnVRH4uq6IUPCQ0dVKJkE0BZYGvd5GXBUgulyJR0PfAxcaWbx8yCpF9AQ+DRu8K2SbgReBq41s83FFyppDDAGoEOHDkmEm3oFBXDPPeHBsMsvT3U0rsqZwdtvw9Sp4bV4caojcpngmGOqPAGU2SewpLOAAWYWa9c/DzgqvrlHUkvgWzPbLOki4BwzOzFufBtgJjDazN6MG/YlISncD3xqZuNKi6U29QlcliOPDFVC580Ldwa5NLdtG8yaBVOmwD/+AcuWQf360L8/5OZCv37QoEGqo3R12X77VfhvrKQ+gZM5A1gOtI/73C4aVsTMVsd9fAD4XdwX7wFMB66P7fyjeVZEbzdLmghclUQsaSM/Hy69NBSI69kz1dG4Ctm6FWbODEf5Tz4JK1eGNr5TT4Vbb4Uf/xj22ivVUTpXYckkgNlAJ0kdCTv+4cDI+AkktYnboQ8CPoyGNwSeBB4qfrE3No8kAWcCH1RqTWqZESPg5z8PBeI8AaSRzZvhpZfCTv+f/ww9/TRpAqefHo70zzgDmjVLdZTOVYkyE4CZbZU0FpgBZAETzGy+pHFAoZlNAy6XNAjYCqwB8qLZhwHHAy0lxYblmdk84FFJrQEB84CLq261Um/PPcP+4tFH4fbbYbfdUh2RK9HGjTBjRtjpP/00rF8Pe+wRjvBzc8MRf5MmqY7SuSpX5jWA2iSdrgEAvPoqnHhiSAIjR5Y9vatBGzbA9Olhp//ssyEJtGgR7uPNzYWTTgrNPc7VAZW5BuAq6IQTdhSI8wRQC3zzTTjCnzo1HPFv3gz77AOjRoWd/gkn+IVcl1E8AVSjevXCxeBf/zrcKXjAAamOKAOtWhVqdE+dGh7P3roV2rWDiy8OO/3evSErK9VROpcSXguomnmBuBT44gu4995wa+a++8KYMfDJJ3DllfDmm/D553DXXXDccb7zdxnNrwHUgNNOgw8+gCVLfH9TbT7/fMeDWbNmhWGHHhqO8nNzoWtXfyDDZSy/BpBC+fkwbFi4u/DUU1MdTR3yySdhhz9lCsyZE4Z17QrjxoWdfufOqY3PuVrOE0ANGDQo1AQaP94TQKWYwfz5O470338/DO/VC267Lez0f/Sj1MboXBrxBFADYgXi7rsPvv4aWrVKdURpxCw8Th3b6X/8cWjK6dMntOMPHQrt25e9HOfcLvwicA0pKIAtW8IzAa4M27fDf/4DV10Vbp3KyYHf/S7s6O+7L1zkff11+NnPfOfvXCX4ReAa1KsXbNoUqgf79chitm0LO/VY3Z3ly8M9+SefHJp2Bg3yUyfnKsgvAtcC+flwySXhemXOLr+KDLRlS3hcesqUcK/+qlXQuDEMGAC//S0MHFjl5W+dczt4AqhBI0aEW9EnTMjgBLBpE7z4YjjSnzYtPJ3btGkospabG+6Zbdo01VE6lxE8AdSg5s3hrLPgscfgD3/IoAJx330Hzz8fjvSnTw91eJo331F355RTwpG/c65GeQKoYQUF8Mgj4QD4Jz9JdTTVaP16eOaZsKLPPQfffx/a8M85J+z0TzwRGjZMdZTOZTRPADXs+OPDjS0TJtTBBLBmTaihP3VqaOb54Qdo0yZc/MjNDaUX6vufnHO1hf831rBYgbgbboBPP60Dzy2tXLmj2Norr4S7eTp0gMsuC+1dRx8dVto5V+v4f2YKjB4d9olpWyBu2bLQ6/0JJ4Qj/IsvDoWOrr4aZs8O7++4I1Ta9J2/c7VWUv+dkgZIWihpkaRrE4zPk7RK0rzodUHcuNGSPoleo+OG95T0frTMe6KuITNCu3ahJMSkSeGAOS0sXgy//304om/fPjyEtXo13HgjvPceLFwI/+//hdubMudX6VxaK7MJSFIWcC9wMrAMmC1pmpktKDbp42Y2tti8LYCbgBzAgDnRvN8AfwIuBN4CngUGAM9Vcn3SRn4+nH12aCofMCDV0ZTgo492lGB4550wrEeP0CF6bi4cfHBq43POVUoy1wB6AYvMbDGApMnAYKB4Auy3HUwAABQpSURBVEjkVOBFM1sTzfsiMEDSTGAPM3szGv4QoWP4jEkAsQdbx4+vRQnALBRYmzIl7PQXRL/iY44JHRsPHRq6OHPO1QnJJIC2wNK4z8uAoxJMlyvpeOBj4EozW1rCvG2j17IEw3chaQwwBqBDhw5JhJseGjaE886DP/4xxQXizKCwcMeR/qJFod3+uONCO/+QIaHNyjlX51TVFbqngWwzOwJ4EXiwipaLmd1vZjlmltO6deuqWmytkJ8fqiE88kgNf/H27fDvf4fHkrOzQ5GiP/wh3J/6l7/AihUwcyb89Ke+83euDkvmDGA5EF9ysV00rIiZrY77+ADwu7h5+xabd2Y0vF2x4TstMxMcfnjY906YEK6pVuu1061b4bXXwlH+P/4BX34ZTkNOOSV0oPLjH0OLFtUYgHOutknmDGA20ElSR0kNgeHAtPgJJLWJ+zgI+DB6PwM4RdJekvYCTgFmmNkKYL2ko6O7f0YB/6zkuqSl/PzQ7F4tRU5/+CE8hXvBBeF2zf79w61HffqEehSrVsHTT4f7Un3n71zGKfMMwMy2ShpL2JlnARPMbL6kcUChmU0DLpc0CNgKrAHyonnXSLqFkEQAxsUuCAOXApOA3QgXfzPmAnC84cNDS8z48XDkkVWwwO+/hxkzwpH+00/DunXQrFk4ws/NDVecmzSpgi9yzqU77w+gFhg1KlRQWLGigvvmb7+FZ58NO/3p00Pxtb322lFs7eSTQ7dkzrmM5P0B1GIFBfDww2H/fd55Sc60dm04wp86NRzxb9oEe+8dCgzl5kLfvqFDFeecK4EngFrg+ONDTaAJE8pIAF9/HU4VpkyBl18OtxC1bQtjxoSdfp8+kJVVY3E759KbJ4BaQAoXg6+/PkGBuBUrQheJU6fCv/4Vakd07BhuG8rNDbcReb0d51wF+J6jlogViJs4Efjvf+HOO+HYY8MR/mWXhY7Qr70W5s4NWSJWl8d3/s65CvIzgFqi7feLGNBJTPpdU/7n1o5ksR2OOAJuvjmUVe7cOdUhOufqGE8AqbRgwY66O++9Rz5DOYupvHD+ZE67rjsceGCqI3TO1WGeAGqSGcybt6PuzkcfhQsAvXvDHXfw44FDad0Hxq8/m9N83++cq2aeAKrb9u3w9ts7dvqffRba7fv2DbV2hgwJT+kCDQl3Af3f/4WHdOtY6SPnXC3jVxCrw7Ztoe7Oz34Wukc85hi4+2445BB44IHQjeLLL8Ollxbt/GNSViDOOZdx/EngqrJlS6igOXVquG3zq6+gcePQ9VdubijFsOeeSS3q6KPDw73vv++daznnKs+fBK4OmzeHLr2mToVp02DNGth9dzjjjLDTP/10aNq03IvNz4eLLgrd6/bqVQ1xO+ccngDKb+NGeP75sNN/5hlYvx6aN99RbO3UU2G33Sr1FcOHwxVXhAJxngCcc9XFE0Ay1q8PRdamTg3llTduhJYtQ6e+ubmhzHLDhlX2dXvsERb9t7+F58G8eKdzrjp4AijJN9+EZp0pU+CFF0Jt/X33hby8sNM//nioX32br6AAHnoofP2oUdX2Nc65DOYJIN5XX8FTT4Uj/VdeCb1otW8f7tbJzQ3369dQ6YXjjgvPgU2Y4AnAOVc9PAEsXx66SJw6FV5/Pdy3f+CB8ItfhJ1+Tk5KbsWJFYi77rrQT7s/FOycq2pJHc5KGiBpoaRFkq4tZbpcSSYpJ/p8rqR5ca/tkrpF42ZGy4yN27tqVikJS5aETtB79w6dnl9+eXjy6vrr4d134eOP4be/DV10pfA+zFGj4grEOedcFSvzOQBJWcDHwMnAMkL3jiPMbEGx6ZoB0wkPtI41s8Ji47sAT5nZj6LPM4Grik9Xmko9B7Bw4Y6ncefODcO6dw9H+bm54SGtWmjgQHjnHfj882q95OCcq8NKeg4gmTOAXsAiM1tsZj8Ak4HBCaa7BbgN2FTCckZE89a8IUPCDv7660MvWb//fSipPHduGFZLd/4QmoG++CJch3bOuaqUzDFlW2Bp3OdlwFHxE0jqAbQ3s+mSri5hOeewa+KYKGkbMBX4jSU4HZE0BhgD0KFDhyTCTWDQIOjXD4YODU0+aWTgwFATaPz48FyZc85VlUo3KkiqB9wB5JUyzVHARjP7IG7wuWa2PGo6mgqcBzxUfF4zux+4H0ITUIWCPP/8Cs1WGzRsGK4F3H23F4hzzlWtZJqAlgPt4z63i4bFNAMOB2ZKWgIcDUyLXQiODAf+Fr9QM1se/dwAPEZoanIJ5OeHO1IffjjVkTjn6pJkEsBsoJOkjpIaEnbm02IjzWydmbUys2wzywbeBAbFLu5GZwjDiGv/l1RfUqvofQNgIBB/duDidO4cCsSNHx+6FHDOuapQZgIws63AWGAG8CHwhJnNlzRO0qAkvuN4YKmZLY4b1giYIek9YB7hjOKv5Y4+g+Tnhw7E3n471ZE45+oKLwedJtavD10HnHsu3H9/qqNxzqWTytwG6mqBWIG4yZPhu+9SHY1zri7wBJBGCgpgw4ZQIM455yrLE0AaOfZY6NQpFIhzzrnK8gSQRmIF4l57DT75JNXROOfSnSeANOMF4pxzVcUTQJrZb79QEmLSpPBwmHPOVZQngDRUUAArVsCMGamOxDmXzjwBpKEzzoC99w5PBjvnXEV5AkhDDRqEawFPPx16sXTOuYrwBJCmvECcc66yPAGkqUMPhWOO8QJxzrmK8wSQxvLz4cMP4a23Uh2Jcy4deQJIY+ecA02a+MVg51zFeAJIY82awbBhXiDOOVcxngDSXEEBfPst/P3vqY7EOZdukkoAkgZIWihpkaRrS5kuV5LFuoOUlC3pe0nzotef46btKen9aJn3SFLlVyfz9OkDBx3kBeKcc+VXZgKQlAXcC5wGdAZGSOqcYLpmwM+A4pckPzWzbtHr4rjhfwIuBDpFrwEVW4XMFisQ9/rr8PHHqY7GOZdOkjkD6AUsMrPFZvYDoW/fwQmmuwW4DdhU1gIltQH2MLM3LXRJ9hBwZvJhu3ijRkFWlheIc86VTzIJoC2wNO7zsmhYEUk9gPZmNj3B/B0lvSPpX5KOi1vmstKWGbfsMZIKJRWuWrUqiXAzT5s2oUDcgw96gTjnXPIqfRFYUj3gDuAXCUavADqYWXfg58BjkvYoz/LN7H4zyzGznNatW1c23DorViDu+edTHYlzLl0kkwCWA+3jPreLhsU0Aw4HZkpaAhwNTJOUY2abzWw1gJnNAT4FDormb1fKMl05nX467LOPPxPgnEteMglgNtBJUkdJDYHhwLTYSDNbZ2atzCzbzLKBN4FBZlYoqXV0ERlJBxAu9i42sxXAeklHR3f/jAL+WbWrllliBeKeeQZWrkx1NM65dFBmAjCzrcBYYAbwIfCEmc2XNE7SoDJmPx54T9I8YApwsZmticZdCjwALCKcGTxXwXVwES8Q55wrD1kaVRLLycmxwsLCVIdRq/XpA2vWwIIF4RZR55yTNMfMcooP9yeB65j8fPjoI3jzzVRH4pyr7TwB1DHDhsHuu/vFYOdc2TwB1DGxAnGPPx5qBDnnXEk8AdRBXiDOOZcMTwB1UO/ecPDBXiDOOVc6TwB1UKxA3L//DQsXpjoa51xt5QmgjvICcc65sngCqKP23RfOOMMLxDnnSuYJoA4rKIAvv4Rnn011JM652sgTQB122mmhQJxfDHbOJeIJoA5r0ABGjw4F4r78MtXROOdqG08Addz558O2bV4gzjm3K08Addwhh4QCcePHQxrV/XPO1QBPABkgPz88D/Cf/6Q6EudcbeIJIAN4gTjnXCKeADJA06ZwzjleIM45t7OkEoCkAZIWSlok6dpSpsuVZJJyos8nS5oj6f3o54lx086Mljkveu1d+dVxJSkogO++gyeeSHUkzrnaoswEEPXpey9wGtAZGCGpc4LpmgE/A96KG/w18GMz6wKMBorfi3KumXWLXl9VcB1cEo45xgvEOed2lswZQC9gkZktNrMfgMnA4ATT3QLcBmyKDTCzd8zsi+jjfGA3SY0qGbOrACmcBbzxRugxzDnnkkkAbYGlcZ+XRcOKSOoBtDez6aUsJxeYa2ab44ZNjJp/fi0l7sFW0hhJhZIKV61alUS4riReIM45F6/SF4El1QPuAH5RyjSHEc4OLoobfG7UNHRc9Dov0bxmdr+Z5ZhZTuvWrSsbbkbbZx8YODAUiNuyJdXROOdSLZkEsBxoH/e5XTQsphlwODBT0hLgaGBa3IXgdsCTwCgz+zQ2k5ktj35uAB4jNDW5alZQACtXeoE451xyCWA20ElSR0kNgeHAtNhIM1tnZq3MLNvMsoE3gUFmVihpT2A6cK2ZvRGbR1J9Sa2i9w2AgcAHVbZWrkSnnRZKRfvFYOdcmQnAzLYCY4EZwIfAE2Y2X9I4SYPKmH0scCBwY7HbPRsBMyS9B8wjnFH8tTIr4pJTv34oEDd9OqxYkeponHOpJEujAjE5OTlWWFiY6jDS3sKFoUbQbbfBNdekOhrnXHWTNMfMcooP9yeBM9DBB8Oxx3qBOOcynSeADJWfDx9/DLNmpToS51yqeALIUGefHWoEeYE45zKXJ4AMFSsQ98QTsGFDqqNxzqWCJ4AM5gXinMtsngAy2NFHh7uB/JkA5zKTJ4AMFisQN2sWfPhhqqNxztU0TwAZ7rzzwsNhfhbgXObxBJDhYgXiHnrIC8Q5l2k8ATgKCuCrr0J5COdc5vAE4BgwANq08WYg5zKNJwBXVCDu2We9QJxzmcQTgAPg/PNh27ZwLcA5lxk8ATgADjoIjjsuNAN5gTjnMoMnAFckViDujTfKntY5l/48AbgiXiDOucySVAKQNEDSQkmLJF1bynS5kizWH3A07FfRfAslnVreZbqas/vuMHy4F4hzLlOUmQAkZQH3AqcBnYERkjonmK4Z8DPgrbhhnQl9CB8GDADuk5SV7DJdzSsogI0b4fHHUx2Jc6661U9iml7AIjNbDCBpMjAYWFBsuluA24Cr44YNBiab2WbgM0mLouWR5DJdDTvqKDj0ULjqKrjzzlRH45yLefppOOCAql1mMgmgLbA07vMy4Kj4CST1ANqb2XRJVxeb981i87aN3pe6zLhljwHGAHTo0CGJcF1lSGHH/8ADqY7EORevUaOqX2YyCaBUkuoBdwB5lY4mATO7H7gfQqfw1fEdbmennhpezrm6LZkEsBxoH/e5XTQsphlwODBTEsC+wDRJg8qYt7RlOuecq2bJ3AU0G+gkqaOkhoSLutNiI81snZm1MrNsM8smNPkMMrPCaLrhkhpJ6gh0At4ua5nOOeeqX5lnAGa2VdJYYAaQBUwws/mSxgGFZlbijjua7gnCxd2twGVmtg0g0TIrvzrOOeeSJUuj5/5zcnKssLAw1WE451xakTTHzHKKD/cngZ1zLkN5AnDOuQzlCcA55zKUJwDnnMtQaXURWNIq4PMKzt4K+LoKw6kqHlf5eFzl43GVT12Na38za118YFolgMqQVJjoKniqeVzl43GVj8dVPpkWlzcBOedchvIE4JxzGSqTEsD9qQ6gBB5X+Xhc5eNxlU9GxZUx1wCcc87tLJPOAJxzzsXxBOCccxmqTiUASRMkfSXpgxLGS9I9UUf070U9mdWGuPpKWidpXvS6sYbiai/pVUkLJM2X9LME09T4NksyrhrfZpIaS3pb0rtRXP+TYJpGkh6PttdbkrJrSVx5klbFba8LqjuuuO/OkvSOpGcSjKvx7ZVkXCnZXpKWSHo/+s5dKl9W+f+jmdWZF3A80AP4oITxpwPPAQKOBt6qJXH1BZ5JwfZqA/SI3jcDPgY6p3qbJRlXjW+zaBs0jd43AN4Cji42zaXAn6P3w4HHa0lcecAfa/pvLPrunwOPJfp9pWJ7JRlXSrYXsARoVcr4Kv1/rFNnAGb2GrCmlEkGAw9Z8Cawp6Q2tSCulDCzFWY2N3q/AfiQHX02x9T4NksyrhoXbYNvo48NolfxuygGAw9G76cA/RV1lZfiuFJCUjvgDKCkXqZrfHslGVdtVaX/j3UqASQhUQf3Kd+xRI6JTuGfk3RYTX95dOrdnXD0GC+l26yUuCAF2yxqNpgHfAW8aGYlbi8z2wqsA1rWgrgAcqNmgymS2icYXx3uAq4BtpcwPiXbK4m4IDXby4AXJM2RNCbB+Cr9f8y0BFBbzSXU6ugK/B/wVE1+uaSmwFTgCjNbX5PfXZoy4krJNjOzbWbWjdCPdS9Jh9fE95YlibieBrLN7AjgRXYcdVcbSQOBr8xsTnV/V3kkGVeNb6/IsWbWAzgNuEzS8dX5ZZmWAMrq4D4lzGx97BTezJ4FGkhqVRPfLakBYSf7qJn9I8EkKdlmZcWVym0Wfeda4FVgQLFRRdtLUn2gObA61XGZ2Woz2xx9fADoWQPh9AEGSVoCTAZOlPRIsWlSsb3KjCtF2wszWx79/Ap4EuhVbJIq/X/MtAQwDRgVXUk/GlhnZitSHZSkfWPtnpJ6EX4v1b7TiL5zPPChmd1RwmQ1vs2SiSsV20xSa0l7Ru93A04GPio22TRgdPT+LOAVi67epTKuYu3EgwjXVaqVmf3KzNqZWTbhAu8rZvaTYpPV+PZKJq5UbC9Ju0tqFnsPnAIUv3OwSv8fy+wUPp1I+hvh7pBWkpYBNxEuiGFmfwaeJVxFXwRsBM6vJXGdBVwiaSvwPTC8uv8JIn2A84D3o/ZjgOuADnGxpWKbJRNXKrZZG+BBSVmEhPOEmT0jaRxQaGbTCInrYUmLCBf+h1dzTMnGdbmkQcDWKK68GogroVqwvZKJKxXbax/gyei4pj7wmJk9L+liqJ7/Ry8F4ZxzGSrTmoCcc85FPAE451yG8gTgnHMZyhOAc85lKE8AzjmXoTwBOOdchvIE4JxzGer/A0KHTchsGP3dAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy = nn_history.history[\"accuracy\"]\n",
        "val_accuracy = nn_history.history[\"val_accuracy\"]\n",
        "loss = nn_history.history[\"loss\"]\n",
        "val_loss = nn_history.history[\"val_loss\"]\n",
        "epochs = range(1, len(accuracy) + 1)\n",
        "\n",
        "plt.plot(epochs, accuracy, \"r\", label=\"Training accuracy\")\n",
        "plt.plot(epochs, val_accuracy, \"b\", label=\"Validation accuracy\")\n",
        "plt.title(\"Training and validation accuracy\")\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.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "6YX6LBACbszl",
        "outputId": "fb4a52cf-bddf-4772-f957-99682b4df61a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        }
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy = nn_history_np.history[\"accuracy\"]\n",
        "val_accuracy = nn_history_np.history[\"val_accuracy\"]\n",
        "loss = nn_history_np.history[\"loss\"]\n",
        "val_loss = nn_history_np.history[\"val_loss\"]\n",
        "epochs = range(1, len(accuracy) + 1)\n",
        "\n",
        "plt.plot(epochs, accuracy, \"r\", label=\"Training accuracy\")\n",
        "plt.plot(epochs, val_accuracy, \"b\", label=\"Validation accuracy\")\n",
        "plt.title(\"Training and validation accuracy\")\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.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "BVRVwcKBs-8e",
        "outputId": "62ce27de-6c2b-45af-cb43-d07b8f4cce3d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        }
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note: These models don't seem to work very well, so instead we use dcnn and vgg16 for _feature extraction_ and then reshape it so that we can feed it through __SVM__ classifier."
      ],
      "metadata": {
        "id": "VDNOcR7L_fTv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PART III\n",
        "# USING SVM"
      ],
      "metadata": {
        "id": "xRxJ13CRt6eU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Normal convolutional neural netowrk just for getting the features out of a\n",
        "# picutre.\n",
        "\n",
        "# The architecture is as follows:\n",
        "# CONV 2D -> MaxPooling -> CONV2D -> CONV2D -> MaxPooling -> BatchNorm\n",
        "# Initially I didn't include batch normalization, however SVM classifier\n",
        "# wouldn't converge if we didn't normalize the final data.\n",
        "\n",
        "fx_model = Sequential([\n",
        "    layers.Conv2D(filters=8,kernel_size=(3,3),  input_shape = (100, 100, 3),activation='relu'),\n",
        "    layers.MaxPooling2D(pool_size=(2,2)),\n",
        "\n",
        "    layers.Conv2D(filters=16,kernel_size=(3,3), activation='relu'),\n",
        "    # layers.MaxPooling2D(pool_size=(2,2)),\n",
        "\n",
        "    layers.Conv2D(filters=32,kernel_size=(3,3), activation='relu'),\n",
        "    layers.MaxPooling2D(pool_size=(2,2)),\n",
        "    layers.BatchNormalization()\n",
        "])"
      ],
      "metadata": {
        "id": "QLjBAxWn09Kl"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fx_model.summary()"
      ],
      "metadata": {
        "id": "JS7uCoeM1MnF",
        "outputId": "723db73c-4e86-41ff-e32b-1419dc017441",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_3 (Conv2D)           (None, 98, 98, 8)         224       \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 49, 49, 8)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_4 (Conv2D)           (None, 47, 47, 16)        1168      \n",
            "                                                                 \n",
            " conv2d_5 (Conv2D)           (None, 45, 45, 32)        4640      \n",
            "                                                                 \n",
            " max_pooling2d_4 (MaxPooling  (None, 22, 22, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 22, 22, 32)       128       \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 6,160\n",
            "Trainable params: 6,096\n",
            "Non-trainable params: 64\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fx_model.compile(loss='binary_crossentropy',\n",
        "              optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),\n",
        "              metrics=['accuracy'])\n"
      ],
      "metadata": {
        "id": "sZ-attkF1O_E"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Getting the features out of the dcnn and adding it all to a np array.\n",
        "\n",
        "fx_features = []\n",
        "fx_features.append(fx_model.predict(x_train))\n",
        "fx_features.append(fx_model.predict(x_test))\n",
        "fx_features = np.concatenate(fx_features)\n",
        "fx_features.shape"
      ],
      "metadata": {
        "id": "psa5vCWz1ekv",
        "outputId": "48c4beb9-ead8-4a90-f077-bd64333ba8de",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3/3 [==============================] - 0s 51ms/step\n",
            "1/1 [==============================] - 0s 66ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100, 22, 22, 32)"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Same for the labels\n",
        "\n",
        "fx_labels = []\n",
        "fx_labels.append(y_train)\n",
        "fx_labels.append(y_test)\n",
        "fx_labels = np.concatenate(fx_labels)\n",
        "fx_labels.shape"
      ],
      "metadata": {
        "id": "yv0qbNF51pxK",
        "outputId": "6523d0fb-0106-42f9-ecf9-a879ecc621b3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100,)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshaping and splitting the data for using them\n",
        "# in the svm classifier.\n",
        "svm_x_train, svm_x_test, svm_y_train, svm_y_test = train_test_split(fx_features, fx_labels, test_size=0.2,random_state=42,stratify=fx_labels)"
      ],
      "metadata": {
        "id": "dbfxnFqn3NxH"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Since the data is 4 dimentional data. We have to reshape it to 2D for svm.\n",
        "flat_svm_x_train = svm_x_train.reshape(80, -1)\n",
        "flat_svm_x_test = svm_x_test.reshape(20, -1)"
      ],
      "metadata": {
        "id": "B8EPzIFt4RvM"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating the SVM model and feeding the features through.\n",
        "\n",
        "from sklearn.svm import LinearSVC\n",
        "\n",
        "lsvm_2 = LinearSVC(C=1, loss='hinge')\n",
        "lsvm_2.fit(flat_svm_x_train, svm_y_train)"
      ],
      "metadata": {
        "id": "cpI4Ryd53AcB",
        "outputId": "58b7bead-b3dd-4dca-c936-6b17f5317a9d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearSVC(C=1, loss='hinge')"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Getting the prediction and comparing them with real outputs.\n",
        "\n",
        "y_pred = lsvm_2.predict(flat_svm_x_test)\n",
        "print(\"The predicted Data is :\")\n",
        "print(y_pred)\n",
        "print(\"The actual data is:\")\n",
        "print(np.array(svm_y_test))\n",
        "print(f'The model is {accuracy_score(y_pred, svm_y_test) * 100} accurate.')"
      ],
      "metadata": {
        "id": "g5X-qjfF4L_6",
        "outputId": "ab418502-7e94-47e9-a498-c354ae7fc339",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The predicted Data is :\n",
            "[1 1 1 1 0 0 0 1 1 0 1 1 1 0 0 1 1 0 1 1]\n",
            "The actual data is:\n",
            "[1 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 1 1]\n",
            "The model is 85.0 accurate.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Second way of feature extraction using VGG16 pretrained model."
      ],
      "metadata": {
        "id": "lrK5OEl8BHkL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# First we have to download the vgg16 model and give the weights, while\n",
        "# removing the top classifier part.\n",
        "conv_base = keras.applications.vgg16.VGG16(weights='imagenet',\n",
        "                                           include_top=False,\n",
        "                                           input_shape=(100, 100, 3))\n",
        "conv_base.summary()"
      ],
      "metadata": {
        "id": "BsXWLjyOt-Ig",
        "outputId": "9e65bbd5-151e-4861-d107-988142d8f88a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 44,
      "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 [==============================] - 1s 0us/step\n",
            "Model: \"vgg16\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 100, 100, 3)]     0         \n",
            "                                                                 \n",
            " block1_conv1 (Conv2D)       (None, 100, 100, 64)      1792      \n",
            "                                                                 \n",
            " block1_conv2 (Conv2D)       (None, 100, 100, 64)      36928     \n",
            "                                                                 \n",
            " block1_pool (MaxPooling2D)  (None, 50, 50, 64)        0         \n",
            "                                                                 \n",
            " block2_conv1 (Conv2D)       (None, 50, 50, 128)       73856     \n",
            "                                                                 \n",
            " block2_conv2 (Conv2D)       (None, 50, 50, 128)       147584    \n",
            "                                                                 \n",
            " block2_pool (MaxPooling2D)  (None, 25, 25, 128)       0         \n",
            "                                                                 \n",
            " block3_conv1 (Conv2D)       (None, 25, 25, 256)       295168    \n",
            "                                                                 \n",
            " block3_conv2 (Conv2D)       (None, 25, 25, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv3 (Conv2D)       (None, 25, 25, 256)       590080    \n",
            "                                                                 \n",
            " block3_pool (MaxPooling2D)  (None, 12, 12, 256)       0         \n",
            "                                                                 \n",
            " block4_conv1 (Conv2D)       (None, 12, 12, 512)       1180160   \n",
            "                                                                 \n",
            " block4_conv2 (Conv2D)       (None, 12, 12, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv3 (Conv2D)       (None, 12, 12, 512)       2359808   \n",
            "                                                                 \n",
            " block4_pool (MaxPooling2D)  (None, 6, 6, 512)         0         \n",
            "                                                                 \n",
            " block5_conv1 (Conv2D)       (None, 6, 6, 512)         2359808   \n",
            "                                                                 \n",
            " block5_conv2 (Conv2D)       (None, 6, 6, 512)         2359808   \n",
            "                                                                 \n",
            " block5_conv3 (Conv2D)       (None, 6, 6, 512)         2359808   \n",
            "                                                                 \n",
            " block5_pool (MaxPooling2D)  (None, 3, 3, 512)         0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 14,714,688\n",
            "Trainable params: 14,714,688\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Just a helper method like the one before for getting features out\n",
        "# of vgg model and preparing it for the svm.\n",
        "\n",
        "def get_features_and_labels(dataset):\n",
        "  all_features = []\n",
        "  all_labels = []\n",
        "  for images, labels in dataset:\n",
        "    preprocesses_images = keras.applications.vgg16.preprocess_input(images)\n",
        "    features = conv_base.predict(preprocesses_images)\n",
        "    all_features.append(features)\n",
        "    all_labels.append(labels)\n",
        "  return np.concatenate(all_features), np.concatenate(all_labels)"
      ],
      "metadata": {
        "id": "m41OA8UsyYGO"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Sine we can feed the whole data set to vgg, we don't have to use the splitted \n",
        "# dataset for prediction. And now the new complete dataset is created.\n",
        "data_for_vgg = image_dataset_from_directory('.', class_names=['fruits', 'humans'], seed = 42, image_size=(100, 100))"
      ],
      "metadata": {
        "id": "jWxVniU0_EhL",
        "outputId": "79111223-3b68-4bbc-90a0-74050bbcbbac",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 100 files belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Getting the features\n",
        "\n",
        "vgg_features, vgg_label = get_features_and_labels(data_for_vgg)"
      ],
      "metadata": {
        "id": "Z-QxEDOa2HxA",
        "outputId": "6988b6d1-8a3d-4c42-d781-109a69bb12b6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 4s 4s/step\n",
            "1/1 [==============================] - 7s 7s/step\n",
            "1/1 [==============================] - 3s 3s/step\n",
            "1/1 [==============================] - 1s 885ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshaping it for the svm.\n",
        "\n",
        "vgg_features = vgg_features.reshape(100, -1)\n",
        "vgg_features.shape"
      ],
      "metadata": {
        "id": "S_meyNOq_wb5",
        "outputId": "144a29b2-c7d2-4a3d-9cb0-82600e4aeab2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100, 4608)"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Preparing for svm.\n",
        "\n",
        "vgg_x_train, vgg_x_test, vgg_y_train, vgg_y_test  = train_test_split(vgg_features, vgg_label, test_size=0.2,random_state=42,stratify=vgg_label)"
      ],
      "metadata": {
        "id": "HiCjZ6PL_c31"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Getting the results.\n",
        "\n",
        "vgg_svc = LinearSVC(C=1, loss='hinge')\n",
        "vgg_svc.fit(vgg_x_train, vgg_y_train)\n",
        "\n",
        "y_pred = vgg_svc.predict(vgg_x_test)\n",
        "print(\"The predicted Data is :\")\n",
        "print(y_pred)\n",
        "print(\"The actual data is:\")\n",
        "print(np.array(vgg_y_test))\n",
        "print(f'The model is {accuracy_score(y_pred, vgg_y_test) * 100} accurate.')"
      ],
      "metadata": {
        "id": "dQ0H5Y9L95M-",
        "outputId": "bf3d1306-47f1-4430-a3f5-121e720718a9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The predicted Data is :\n",
            "[1 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 1 1]\n",
            "The actual data is:\n",
            "[1 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 1 1]\n",
            "The model is 100.0 accurate.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4vOyN4rq_N0m"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}