breastCancer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/moronya/BreastCancer/blob/develop/breastCancer.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63mckWRzK-Qu"
      },
      "source": [
        "import necessary libraries\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nQMof2AVK23Z",
        "outputId": "75d6304e-f9d4-4c2a-c50b-e90663ca0695"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "from tensorflow import keras\n",
        "from keras import layers, models\n",
        "import os, shutil\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "_VN7XRgJUnAq"
      },
      "outputs": [],
      "source": [
        "# load data from local disk and create partitions i.e train and validation folders\n",
        "original_dataset = \"/content/gdrive/My Drive/Breast Cancer Images\"\n",
        "base_dir = \"C:/Users/Amos/Documents/Models/Partitioned\" # The folder will store partitioned data\n",
        "os.makedirs(base_dir, exist_ok = True)\n",
        "train_dir = os.path.join(base_dir, \"training\")\n",
        "os.mkdir(train_dir)\n",
        "validation_dir = os.path.join(base_dir, \"validation\")\n",
        "os.mkdir(validation_dir)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "4okpzPfSaue-"
      },
      "outputs": [],
      "source": [
        "# Move data to their respective partitions\n",
        "train_normal_dir = os.path.join(train_dir, 'normal')\n",
        "os.mkdir(train_normal_dir)\n",
        "train_benign_dir = os.path.join(train_dir, 'benign')\n",
        "os.mkdir(train_benign_dir)\n",
        "train_malignant_dir = os.path.join(train_dir, 'malignant')\n",
        "os.mkdir(train_malignant_dir)\n",
        "\n",
        "validate_normal_dir = os.path.join(validation_dir, 'normal')\n",
        "os.mkdir(validate_normal_dir)\n",
        "validate_benign_dir = os.path.join(validation_dir, 'benign')\n",
        "os.mkdir(validate_benign_dir)\n",
        "validate_malignant_dir = os.path.join(validation_dir, 'malignant')\n",
        "os.mkdir(validate_malignant_dir)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "VMGJH-XqcxhA"
      },
      "outputs": [],
      "source": [
        "# Loading the data\n",
        "# Copy the first 100 images to train_normal_dir\n",
        "fnames = ['normal ({}).png'.format(i) for i in range(1, 101)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/normal\",fname)\n",
        "  dst = os.path.join(train_normal_dir, fname)\n",
        "  shutil.copyfile(src, dst)\n",
        "fnames = ['normal ({})_mask.png'.format(i) for i in range(1, 101)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/normal\",fname)\n",
        "  dst = os.path.join(train_normal_dir, fname)\n",
        "  shutil.copyfile(src, dst)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "l5gHsBHhfwWa"
      },
      "outputs": [],
      "source": [
        "# Copy the remaining 33 images to validate_normal_dir\n",
        "fnames = ['normal ({}).png'.format(i) for i in range(101, 134)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/normal\",fname)\n",
        "  dst = os.path.join(validate_normal_dir, fname)\n",
        "  shutil.copyfile(src, dst)\n",
        "fnames = ['normal ({})_mask.png'.format(i) for i in range(101, 134)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/normal\",fname)\n",
        "  dst = os.path.join(validate_normal_dir, fname)\n",
        "  shutil.copyfile(src, dst)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "ukTJ9rH-gz2j"
      },
      "outputs": [],
      "source": [
        "# Benign Data\n",
        "# Copy the first 300 images to train_benign_dir\n",
        "fnames = ['benign ({}).png'.format(i) for i in range(1, 301)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/benign\",fname)\n",
        "  dst = os.path.join(train_benign_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n",
        "fnames = ['benign ({})_mask.png'.format(i) for i in range(1, 301)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/benign\",fname)\n",
        "  dst = os.path.join(train_benign_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "xANPWF_5jwyN"
      },
      "outputs": [],
      "source": [
        "# Copy the remaning 127 images to validate_benign_dir\n",
        "fnames = ['benign ({}).png'.format(i) for i in range(301, 438)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/benign\",fname)\n",
        "  dst = os.path.join(validate_benign_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n",
        "fnames = ['benign ({})_mask.png'.format(i) for i in range(301, 438)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/benign\",fname)\n",
        "  dst = os.path.join(validate_benign_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "-KTJFiWKkGZ7"
      },
      "outputs": [],
      "source": [
        "# Malignant Data\n",
        "# Copy the first 150 images to train_malignant_dir\n",
        "fnames = ['malignant ({}).png'.format(i) for i in range(1, 151)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/malignant\",fname)\n",
        "  dst = os.path.join(train_malignant_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n",
        "fnames = ['malignant ({})_mask.png'.format(i) for i in range(1, 151)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/malignant\",fname)\n",
        "  dst = os.path.join(train_malignant_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n",
        "\n",
        "# Copy the remaining 121 images to validate_malignant_dir\n",
        "fnames = ['malignant ({}).png'.format(i) for i in range(151, 210)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/malignant\",fname)\n",
        "  dst = os.path.join(validate_malignant_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n",
        "fnames = ['malignant ({})_mask.png'.format(i) for i in range(151, 210)]\n",
        "for fname in fnames:\n",
        "  src = os.path.join(original_dataset+\"/malignant\",fname)\n",
        "  dst = os.path.join(validate_malignant_dir, fname)\n",
        "  if(os.path.exists(src)):\n",
        "    shutil.copyfile(src, dst)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Checking the total number of images in each split\n",
        "print('Total training normal images :', len(os.listdir(train_normal_dir)))\n",
        "print('Total training benign images: ', len(os.listdir(train_benign_dir)))\n",
        "print('Total training malignant images: ', len(os.listdir(train_malignant_dir)))\n",
        "print('======================================================================')\n",
        "print('Total validation normal images: ', len(os.listdir(validate_normal_dir)))\n",
        "print('Total validation benign images: ', len(os.listdir(validate_benign_dir)))\n",
        "print('Total validation malignant images: ', len(os.listdir(validate_malignant_dir)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "77t5rJ5d9xII",
        "outputId": "4af36408-b9c9-4881-c833-472965c78182"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total training normal images : 200\n",
            "Total training benign images:  600\n",
            "Total training malignant images:  300\n",
            "======================================================================\n",
            "Total validation normal images:  66\n",
            "Total validation benign images:  274\n",
            "Total validation malignant images:  118\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bL_eI6U4NnhA"
      },
      "source": [
        "**Build the model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q19oS9-VNgQJ",
        "outputId": "93c806a4-de49-4dcf-9a1b-b239281bc6bd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 148, 148, 32)      320       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 74, 74, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 72, 72, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 36, 36, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 17, 17, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 15, 15, 128)       147584    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 7, 7, 128)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 240,256\n",
            "Trainable params: 240,256\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model = models.Sequential()\n",
        "model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150,150,1)))\n",
        "model.add(layers.MaxPooling2D((2,2)))\n",
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2,2)))\n",
        "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2,2)))\n",
        "model.add(layers.Conv2D(128, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2,2)))\n",
        "model.summary()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K74KHSx6PH8j",
        "outputId": "e3569b3f-3121-450a-d17e-cab7f7f4ff25"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 148, 148, 32)      320       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 74, 74, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 72, 72, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 36, 36, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 17, 17, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 15, 15, 128)       147584    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 7, 7, 128)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 6272)              0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 6272)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 64)                401472    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 3)                 195       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 641,923\n",
            "Trainable params: 641,923\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dropout(0.5))\n",
        "model.add(layers.Dense(64, activation='relu'))\n",
        "model.add(layers.Dense(3, activation='softmax'))\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras import optimizers\n",
        "model.compile(optimizer=optimizers.Adam(learning_rate=0.001),loss='categorical_crossentropy',metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "iSYycJBIqq3C"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Data** preprocessing"
      ],
      "metadata": {
        "id": "WoDpsKvErDGY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#from keras.layers.preprocessing.image_preprocessing import TARGETS\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "train_datagen = ImageDataGenerator(rescale = 1./255)\n",
        "test_datagen = ImageDataGenerator(rescale = 1./255)\n",
        "\n",
        "train_generator = train_datagen.flow_from_directory(train_dir, target_size = (150, 150),batch_size = 50, class_mode = 'categorical', color_mode=\"grayscale\")\n",
        "validation_generator = test_datagen.flow_from_directory(validation_dir, target_size = (150, 150), batch_size = 50, class_mode = 'categorical', color_mode=\"grayscale\")\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zmYRar8dq_ol",
        "outputId": "e9779aca-8dd5-4cde-cd84-b1cdda392ec0"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 1100 images belonging to 3 classes.\n",
            "Found 458 images belonging to 3 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(train_generator, steps_per_epoch = 10, epochs = 20, validation_data = validation_generator, validation_steps = 10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zX_Mux76u-eN",
        "outputId": "5e4e62d9-2f9b-4f72-f7ef-1a8770cb9149"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "10/10 [==============================] - 16s 600ms/step - loss: 0.9923 - accuracy: 0.5240 - val_loss: 0.8558 - val_accuracy: 0.5939\n",
            "Epoch 2/20\n",
            "10/10 [==============================] - 6s 636ms/step - loss: 0.8644 - accuracy: 0.5780 - val_loss: 0.8350 - val_accuracy: 0.5961\n",
            "Epoch 3/20\n",
            "10/10 [==============================] - 5s 488ms/step - loss: 0.8123 - accuracy: 0.5780 - val_loss: 0.8772 - val_accuracy: 0.5655\n",
            "Epoch 4/20\n",
            "10/10 [==============================] - 5s 510ms/step - loss: 0.8048 - accuracy: 0.5760 - val_loss: 0.8410 - val_accuracy: 0.5917\n",
            "Epoch 5/20\n",
            "10/10 [==============================] - 6s 628ms/step - loss: 0.7602 - accuracy: 0.5820 - val_loss: 0.7904 - val_accuracy: 0.5983\n",
            "Epoch 6/20\n",
            "10/10 [==============================] - 8s 820ms/step - loss: 0.7440 - accuracy: 0.6260 - val_loss: 0.8345 - val_accuracy: 0.6594\n",
            "Epoch 7/20\n",
            "10/10 [==============================] - 5s 476ms/step - loss: 0.7043 - accuracy: 0.6980 - val_loss: 0.8113 - val_accuracy: 0.6790\n",
            "Epoch 8/20\n",
            "10/10 [==============================] - 5s 527ms/step - loss: 0.6369 - accuracy: 0.7260 - val_loss: 0.8375 - val_accuracy: 0.6528\n",
            "Epoch 9/20\n",
            "10/10 [==============================] - 6s 569ms/step - loss: 0.6227 - accuracy: 0.7300 - val_loss: 0.8686 - val_accuracy: 0.6397\n",
            "Epoch 10/20\n",
            "10/10 [==============================] - 5s 478ms/step - loss: 0.6278 - accuracy: 0.7420 - val_loss: 0.7356 - val_accuracy: 0.6900\n",
            "Epoch 11/20\n",
            "10/10 [==============================] - 8s 817ms/step - loss: 0.5608 - accuracy: 0.7440 - val_loss: 0.7110 - val_accuracy: 0.7074\n",
            "Epoch 12/20\n",
            "10/10 [==============================] - 5s 483ms/step - loss: 0.5583 - accuracy: 0.7360 - val_loss: 0.7513 - val_accuracy: 0.6987\n",
            "Epoch 13/20\n",
            "10/10 [==============================] - 6s 645ms/step - loss: 0.5585 - accuracy: 0.7480 - val_loss: 0.7397 - val_accuracy: 0.6878\n",
            "Epoch 14/20\n",
            "10/10 [==============================] - 5s 480ms/step - loss: 0.4875 - accuracy: 0.7540 - val_loss: 0.7261 - val_accuracy: 0.7031\n",
            "Epoch 15/20\n",
            "10/10 [==============================] - 5s 494ms/step - loss: 0.4877 - accuracy: 0.7620 - val_loss: 0.7843 - val_accuracy: 0.7052\n",
            "Epoch 16/20\n",
            "10/10 [==============================] - 6s 613ms/step - loss: 0.5044 - accuracy: 0.7960 - val_loss: 0.7250 - val_accuracy: 0.7140\n",
            "Epoch 17/20\n",
            "10/10 [==============================] - 5s 501ms/step - loss: 0.4400 - accuracy: 0.8120 - val_loss: 0.8014 - val_accuracy: 0.6921\n",
            "Epoch 18/20\n",
            "10/10 [==============================] - 6s 579ms/step - loss: 0.4059 - accuracy: 0.8240 - val_loss: 0.7960 - val_accuracy: 0.6965\n",
            "Epoch 19/20\n",
            "10/10 [==============================] - 5s 485ms/step - loss: 0.3665 - accuracy: 0.8500 - val_loss: 0.7596 - val_accuracy: 0.7314\n",
            "Epoch 20/20\n",
            "10/10 [==============================] - 6s 646ms/step - loss: 0.3556 - accuracy: 0.8480 - val_loss: 0.7709 - val_accuracy: 0.7074\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize\n",
        "import matplotlib.pyplot as plt\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "val_loss = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "epochs = range(1, len(acc)+1)\n",
        "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend()\n",
        "plt.figure()\n",
        "plt.plot(epochs, loss, 'bo', 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()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 887
        },
        "id": "uJQl521BLWnK",
        "outputId": "f456c5cf-bcbe-4d9c-9d09-873182ee9a82"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGzCAYAAAD9pBdvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABccElEQVR4nO3deVxUVf8H8M+ArCJgLuyCmnuKhkpqqCmFy+MSLliWaKUtrpmlprn1JD2Ziru2qG0aLmiL5kZQLqQmWmZKaqiIgEsJCgg6c35/nB8jI9sMzHBnhs/79ZoXzJlz7z2XyzBfzvK9KiGEABEREZFCbJRuABEREVVvDEaIiIhIUQxGiIiISFEMRoiIiEhRDEaIiIhIUQxGiIiISFEMRoiIiEhRDEaIiIhIUQxGiIiISFEMRoj0NHLkSAQEBFRo2zlz5kClUhm3QWbmwoULUKlUWL9+fZUeNyEhASqVCgkJCdoyfa+VqdocEBCAkSNHGnWf+li/fj1UKhUuXLhQ5ccmqgwGI2TxVCqVXo+iH1ZElXXo0CHMmTMHN2/eVLopRBavhtINIKqsL774Quf5559/jr179xYrb9GiRaWO8/HHH0Oj0VRo25kzZ2LatGmVOj7przLXSl+HDh3C3LlzMXLkSLi7u+u8lpycDBsb/q9HpC8GI2TxnnvuOZ3nv/zyC/bu3Vus/EG5ublwdnbW+zh2dnYVah8A1KhRAzVq8O1WVSpzrYzBwcFB0eMTWRqG7lQtdO/eHY888giOHTuGrl27wtnZGW+//TYA4JtvvkHfvn3h7e0NBwcHNG7cGO+++y7UarXOPh6ch1A43+DDDz/ERx99hMaNG8PBwQEdOnTA0aNHdbYtac6ISqXCuHHjsH37djzyyCNwcHBAq1atsGvXrmLtT0hIQPv27eHo6IjGjRtjzZo1es9D2b9/P4YMGYIGDRrAwcEBfn5+eP3115GXl1fs/FxcXJCWloaBAwfCxcUF9erVw5QpU4r9LG7evImRI0fCzc0N7u7uiIyM1Gu44tdff4VKpcJnn31W7LXdu3dDpVLh+++/BwBcvHgRr732Gpo1awYnJyfUqVMHQ4YM0Ws+RElzRvRt8++//46RI0eiUaNGcHR0hKenJ1544QXcuHFDW2fOnDl48803AQANGzbUDgUWtq2kOSN///03hgwZgoceegjOzs547LHHsGPHDp06hfNfNm3ahPfeew++vr5wdHREz549ce7cuXLPuzQrV65Eq1at4ODgAG9vb4wdO7bYuZ89exaDBg2Cp6cnHB0d4evri2HDhiErK0tbZ+/evXj88cfh7u4OFxcXNGvWTPs+IqoM/qtG1caNGzfQu3dvDBs2DM899xw8PDwAyEl/Li4umDx5MlxcXPDjjz9i1qxZyM7OxoIFC8rd74YNG3Dr1i28/PLLUKlU+OCDDxAeHo6///673P/QDxw4gNjYWLz22muoVasWli5dikGDBuHSpUuoU6cOAOD48ePo1asXvLy8MHfuXKjVasybNw/16tXT67w3b96M3NxcvPrqq6hTpw6OHDmCZcuW4fLly9i8ebNOXbVajbCwMAQHB+PDDz/Evn37sHDhQjRu3BivvvoqAEAIgQEDBuDAgQN45ZVX0KJFC2zbtg2RkZHltqV9+/Zo1KgRNm3aVKx+TEwMateujbCwMADA0aNHcejQIQwbNgy+vr64cOECVq1ahe7du+PPP/80qFfLkDbv3bsXf//9N0aNGgVPT0+cOnUKH330EU6dOoVffvkFKpUK4eHh+Ouvv7Bx40YsXrwYdevWBYBSr0lmZiY6d+6M3NxcTJgwAXXq1MFnn32G/v37Y8uWLXj66ad16r///vuwsbHBlClTkJWVhQ8++ADDhw/H4cOH9T7nQnPmzMHcuXMRGhqKV199FcnJyVi1ahWOHj2KgwcPws7ODgUFBQgLC0N+fj7Gjx8PT09PpKWl4fvvv8fNmzfh5uaGU6dO4T//+Q/atGmDefPmwcHBAefOncPBgwcNbhNRMYLIyowdO1Y8+KvdrVs3AUCsXr26WP3c3NxiZS+//LJwdnYWd+7c0ZZFRkYKf39/7fOUlBQBQNSpU0f8888/2vJvvvlGABDfffedtmz27NnF2gRA2Nvbi3PnzmnLfvvtNwFALFu2TFvWr18/4ezsLNLS0rRlZ8+eFTVq1Ci2z5KUdH5RUVFCpVKJixcv6pwfADFv3jyduu3atRNBQUHa59u3bxcAxAcffKAtu3fvnggJCREAxLp168psz/Tp04WdnZ3Ozyw/P1+4u7uLF154ocx2JyYmCgDi888/15bFx8cLACI+Pl7nXIpeK0PaXNJxN27cKACIn3/+WVu2YMECAUCkpKQUq+/v7y8iIyO1zydNmiQAiP3792vLbt26JRo2bCgCAgKEWq3WOZcWLVqI/Px8bd0lS5YIAOLkyZPFjlXUunXrdNp09epVYW9vL5566intMYQQYvny5QKAWLt2rRBCiOPHjwsAYvPmzaXue/HixQKAuHbtWpltIKoIDtNQteHg4IBRo0YVK3dyctJ+f+vWLVy/fh0hISHIzc3FmTNnyt1vREQEateurX0eEhICQHbLlyc0NBSNGzfWPm/Tpg1cXV2126rVauzbtw8DBw6Et7e3tt7DDz+M3r17l7t/QPf8cnJycP36dXTu3BlCCBw/frxY/VdeeUXneUhIiM657Ny5EzVq1ND2lACAra0txo8fr1d7IiIicPfuXcTGxmrL9uzZg5s3byIiIqLEdt+9exc3btzAww8/DHd3dyQlJel1rIq0uehx79y5g+vXr+Oxxx4DAIOPW/T4HTt2xOOPP64tc3FxwZgxY3DhwgX8+eefOvVHjRoFe3t77XNDfqeK2rdvHwoKCjBp0iSdCbWjR4+Gq6urdpjIzc0NgBwqy83NLXFfhZN0v/nmG5NPDqbqh8EIVRs+Pj46f+ALnTp1Ck8//TTc3Nzg6uqKevXqaSe/Fh0vL02DBg10nhcGJv/++6/B2xZuX7jt1atXkZeXh4cffrhYvZLKSnLp0iWMHDkSDz30kHYeSLdu3QAUPz9HR8diQw1F2wPIuRxeXl5wcXHRqdesWTO92hMYGIjmzZsjJiZGWxYTE4O6deuiR48e2rK8vDzMmjULfn5+cHBwQN26dVGvXj3cvHlTr+tSlCFt/ueffzBx4kR4eHjAyckJ9erVQ8OGDQHo9/tQ2vFLOlbhCq+LFy/qlFfmd+rB4wLFz9Pe3h6NGjXSvt6wYUNMnjwZn3zyCerWrYuwsDCsWLFC53wjIiLQpUsXvPTSS/Dw8MCwYcOwadMmBiZkFJwzQtVG0f94C928eRPdunWDq6sr5s2bh8aNG8PR0RFJSUmYOnWqXn9obW1tSywXQph0W32o1Wo8+eST+OeffzB16lQ0b94cNWvWRFpaGkaOHFns/Eprj7FFRETgvffew/Xr11GrVi18++23eOaZZ3RWHI0fPx7r1q3DpEmT0KlTJ7i5uUGlUmHYsGEm/QAcOnQoDh06hDfffBNt27aFi4sLNBoNevXqVWUfvKb+vSjJwoULMXLkSHzzzTfYs2cPJkyYgKioKPzyyy/w9fWFk5MTfv75Z8THx2PHjh3YtWsXYmJi0KNHD+zZs6fKfnfIOjEYoWotISEBN27cQGxsLLp27aotT0lJUbBV99WvXx+Ojo4lrqTQZ3XFyZMn8ddff+Gzzz7DiBEjtOV79+6tcJv8/f0RFxeH27dv6/Q0JCcn672PiIgIzJ07F1u3boWHhweys7MxbNgwnTpbtmxBZGQkFi5cqC27c+dOhZKM6dvmf//9F3FxcZg7dy5mzZqlLT979myxfRqSUdff37/En0/hMKC/v7/e+zJE4X6Tk5PRqFEjbXlBQQFSUlIQGhqqU79169Zo3bo1Zs6ciUOHDqFLly5YvXo1/vvf/wIAbGxs0LNnT/Ts2ROLFi3C/PnzMWPGDMTHxxfbF5EhOExD1Vrhf3NF/+MsKCjAypUrlWqSDltbW4SGhmL79u24cuWKtvzcuXP44Ycf9Noe0D0/IQSWLFlS4Tb16dMH9+7dw6pVq7RlarUay5Yt03sfLVq0QOvWrRETE4OYmBh4eXnpBIOFbX+wJ2DZsmXFlhkbs80l/bwAIDo6utg+a9asCQB6BUd9+vTBkSNHkJiYqC3LycnBRx99hICAALRs2VLfUzFIaGgo7O3tsXTpUp1z+vTTT5GVlYW+ffsCALKzs3Hv3j2dbVu3bg0bGxvk5+cDkMNXD2rbti0AaOsQVRR7Rqha69y5M2rXro3IyEhMmDABKpUKX3zxhUm7ww01Z84c7NmzB126dMGrr74KtVqN5cuX45FHHsGJEyfK3LZ58+Zo3LgxpkyZgrS0NLi6umLr1q0Gzz0oql+/fujSpQumTZuGCxcuoGXLloiNjTV4PkVERARmzZoFR0dHvPjii8Uylv7nP//BF198ATc3N7Rs2RKJiYnYt2+fdsmzKdrs6uqKrl274oMPPsDdu3fh4+ODPXv2lNhTFhQUBACYMWMGhg0bBjs7O/Tr108bpBQ1bdo0bNy4Eb1798aECRPw0EMP4bPPPkNKSgq2bt1qsmyt9erVw/Tp0zF37lz06tUL/fv3R3JyMlauXIkOHTpo50b9+OOPGDduHIYMGYKmTZvi3r17+OKLL2Bra4tBgwYBAObNm4eff/4Zffv2hb+/P65evYqVK1fC19dXZ2IuUUUwGKFqrU6dOvj+++/xxhtvYObMmahduzaee+459OzZU5vvQmlBQUH44YcfMGXKFLzzzjvw8/PDvHnzcPr06XJX+9jZ2eG7777Tjv87Ojri6aefxrhx4xAYGFih9tjY2ODbb7/FpEmT8OWXX0KlUqF///5YuHAh2rVrp/d+IiIiMHPmTOTm5uqsoim0ZMkS2Nra4quvvsKdO3fQpUsX7Nu3r0LXxZA2b9iwAePHj8eKFSsghMBTTz2FH374QWc1EwB06NAB7777LlavXo1du3ZBo9EgJSWlxGDEw8MDhw4dwtSpU7Fs2TLcuXMHbdq0wXfffaftnTCVOXPmoF69eli+fDlef/11PPTQQxgzZgzmz5+vzYMTGBiIsLAwfPfdd0hLS4OzszMCAwPxww8/aFcS9e/fHxcuXMDatWtx/fp11K1bF926dcPcuXO1q3GIKkolzOlfQCLS28CBA3Hq1KkS5zMQEVkSzhkhsgAPpm4/e/Ysdu7cie7duyvTICIiI2LPCJEF8PLy0t4v5eLFi1i1ahXy8/Nx/PhxNGnSROnmERFVCueMEFmAXr16YePGjcjIyICDgwM6deqE+fPnMxAhIqvAnhEiIiJSFOeMEBERkaIYjBAREZGiLGLOiEajwZUrV1CrVi2DUjATERGRcoQQuHXrFry9vctM7mcRwciVK1fg5+endDOIiIioAlJTU+Hr61vq6xYRjNSqVQuAPBlXV1eFW0NERET6yM7Ohp+fn/ZzvDQWEYwUDs24uroyGCEiIrIw5U2x4ARWIiIiUhSDESIiIlIUgxEiIiJSlEXMGSEiIuMRQuDevXtQq9VKN4UsnK2tLWrUqFHptBsMRoiIqpGCggKkp6cjNzdX6aaQlXB2doaXlxfs7e0rvA8GI0RE1YRGo0FKSgpsbW3h7e0Ne3t7JpKkChNCoKCgANeuXUNKSgqaNGlSZmKzshgcjPz8889YsGABjh07hvT0dGzbtg0DBw4sc5uEhARMnjwZp06dgp+fH2bOnImRI0dWqMFERFQxBQUF0Gg08PPzg7Ozs9LNISvg5OQEOzs7XLx4EQUFBXB0dKzQfgwOYXJychAYGIgVK1boVT8lJQV9+/bFE088gRMnTmDSpEl46aWXsHv3boMbS0RElVfR/16JSmKM3yeDe0Z69+6N3r17611/9erVaNiwIRYuXAgAaNGiBQ4cOIDFixcjLCysxG3y8/ORn5+vfZ6dnW1oM8ulVgP79wPp6YCXFxASAtjaGv0wREREVA6Th8eJiYkIDQ3VKQsLC0NiYmKp20RFRcHNzU37MPZ9aWJjgYAA4IkngGeflV8DAmQ5ERERVS2TByMZGRnw8PDQKfPw8EB2djby8vJK3Gb69OnIysrSPlJTU43WnthYYPBg4PJl3fK0NFnOgISIqGxqNZCQAGzcKL9a4grhgIAAREdH610/ISEBKpUKN2/eNFmbAGD9+vVwd3c36THMkVkOHDo4OGjvQ2PM+9Go1cDEiYAQxV8rLJs0yTLfWEREVaGqe5ZVKlWZjzlz5lRov0ePHsWYMWP0rt+5c2ekp6fDzc2tQsejspl8aa+npycyMzN1yjIzM+Hq6gonJydTH17H/v3Fe0SKEgJITZX1unevsmYREVmEwp7lB/+hK+xZ3rIFCA837jHT09O138fExGDWrFlITk7Wlrm4uGi/F0JArVajRo3yP9rq1atnUDvs7e3h6elp0DakP5P3jHTq1AlxcXE6ZXv37kWnTp1MfehiivxOG6UeEVF1oVTPsqenp/bh5uYGlUqlfX7mzBnUqlULP/zwA4KCguDg4IADBw7g/PnzGDBgADw8PODi4oIOHTpg3759Ovt9cJhGpVLhk08+wdNPPw1nZ2c0adIE3377rfb1B4dpCodTdu/ejRYtWsDFxQW9evXSCZ7u3buHCRMmwN3dHXXq1MHUqVMRGRlZbjqMB61atQqNGzeGvb09mjVrhi+++EL7mhACc+bMQYMGDeDg4ABvb29MmDBB+/rKlSvRpEkTODo6wsPDA4MHDzbo2FXF4GDk9u3bOHHiBE6cOAFALt09ceIELl26BEDO9xgxYoS2/iuvvIK///4bb731Fs6cOYOVK1di06ZNeP31141zBgbw8jJuPSKi6sKQnuWqNm3aNLz//vs4ffo02rRpg9u3b6NPnz6Ii4vD8ePH0atXL/Tr10/7OVWauXPnYujQofj999/Rp08fDB8+HP/880+p9XNzc/Hhhx/iiy++wM8//4xLly5hypQp2tf/97//4auvvsK6detw8OBBZGdnY/v27Qad27Zt2zBx4kS88cYb+OOPP/Dyyy9j1KhRiI+PBwBs3boVixcvxpo1a3D27Fls374drVu3BgD8+uuvmDBhAubNm4fk5GTs2rULXbt2Nej4VUYYKD4+XgAo9oiMjBRCCBEZGSm6detWbJu2bdsKe3t70ahRI7Fu3TqDjpmVlSUAiKysLEObq+PePSF8fYVQqYSQbx3dh0olhJ+frEdEZG3y8vLEn3/+KfLy8gzedsOGkv9uPvjYsMEEDf9/69atE25ubtrnhZ9H27dvL3fbVq1aiWXLlmmf+/v7i8WLF2ufAxAzZ87UPr99+7YAIH744QedY/3777/atgAQ586d026zYsUK4eHhoX3u4eEhFixYoH1+79490aBBAzFgwAC9z7Fz585i9OjROnWGDBki+vTpI4QQYuHChaJp06aioKCg2L62bt0qXF1dRXZ2dqnHM4ayfq/0/fw2uGeke/fuEEIUe6xfvx6A7LpKSEgots3x48eRn5+P8+fPK5Z91dYWWLJEfv9gBuTC59HRzDdCRPQgc+5Zbt++vc7z27dvY8qUKWjRogXc3d3h4uKC06dPl9sz0qZNG+33NWvWhKurK65evVpqfWdnZzRu3Fj73MvLS1s/KysLmZmZ6Nixo/Z1W1tbBAUFGXRup0+fRpcuXXTKunTpgtOnTwMAhgwZgry8PDRq1AijR4/Gtm3bcO/ePQDAk08+CX9/fzRq1AjPP/88vvrqK7O9J5FZrqYxpfBwOcnKx0e33NfXNJOviIisQUiI/DtZ2q1sVCrAz0/Wq2o1a9bUeT5lyhRs27YN8+fPx/79+3HixAm0bt0aBQUFZe7Hzs5O57lKpYJGozGovihpUo0J+fn5ITk5GStXroSTkxNee+01dO3aFXfv3kWtWrWQlJSEjRs3wsvLC7NmzUJgYKDJlydXRLULRgAZcFy4AMTHAxs2yK8pKQxEiIhKY0k9ywcPHsTIkSPx9NNPo3Xr1vD09MSFCxeqtA1ubm7w8PDA0aNHtWVqtRpJSUkG7adFixY4ePCgTtnBgwfRsmVL7XMnJyf069cPS5cuRUJCAhITE3Hy5EkAQI0aNRAaGooPPvgAv//+Oy5cuIAff/yxEmdmGtX2rr22tly+S0RkiMKe5YkTdSez+vrKQMRc/qFr0qQJYmNj0a9fP6hUKrzzzjtl9nCYyvjx4xEVFYWHH34YzZs3x7Jly/Dvv/8adKfkN998E0OHDkW7du0QGhqK7777DrGxsdrVQevXr4darUZwcDCcnZ3x5ZdfwsnJCf7+/vj+++/x999/o2vXrqhduzZ27twJjUaDZs2ameqUK6zaBiNERGS48HBgwADzvrfXokWL8MILL6Bz586oW7cupk6dapJ7nJVn6tSpyMjIwIgRI2Bra4sxY8YgLCwMtgb8sAYOHIglS5bgww8/xMSJE9GwYUOsW7cO3f//v2l3d3e8//77mDx5MtRqNVq3bo3vvvsOderUgbu7O2JjYzFnzhzcuXMHTZo0wcaNG9GqVSsTnXHFqURVD3BVQHZ2Ntzc3JCVlWW0bKxERNXNnTt3kJKSgoYNG1b4Vu9UcRqNBi1atMDQoUPx7rvvKt0coynr90rfz2/2jBAREZnAxYsXsWfPHnTr1g35+flYvnw5UlJS8OyzzyrdNLNTLSewEhERmZqNjQ3Wr1+PDh06oEuXLjh58iT27duHFi1aKN00s8OeESIiIhPw8/MrthKGSsaeESIiIlIUgxEiIiJSFIMRIiIiUhSDESIiIlIUgxEiIiJSFIMRIiIiUhSDESIisnrdu3fHpEmTtM8DAgIQHR1d5jYqlQrbt2+v9LGNtZ+yzJkzB23btjXpMUyJwQgREZmtfv36oVevXiW+tn//fqhUKvz+++8G7/fo0aMYM2ZMZZuno7SAID09Hb179zbqsawNgxEiIjJbL774Ivbu3YvLRW8T/P/WrVuH9u3bo02bNgbvt169enB2djZGE8vl6ekJBweHKjmWpWIwQkRUTQkB5OQo89D3Fq3/+c9/UK9ePaxfv16n/Pbt29i8eTNefPFF3LhxA8888wx8fHzg7OyM1q1bY+PGjWXu98FhmrNnz6Jr165wdHREy5YtsXfv3mLbTJ06FU2bNoWzszMaNWqEd955B3fv3gUArF+/HnPnzsVvv/0GlUoFlUqlbfODwzQnT55Ejx494OTkhDp16mDMmDG4ffu29vWRI0di4MCB+PDDD+Hl5YU6depg7Nix2mPpQ6PRYN68efD19YWDgwPatm2LXbt2aV8vKCjAuHHj4OXlBUdHR/j7+yMqKgoAIITAnDlz0KBBAzg4OMDb2xsTJkzQ+9gVwXTwRETVVG4u4OKizLFv3wZq1iy/Xo0aNTBixAisX78eM2bMgEqlAgBs3rwZarUazzzzDG7fvo2goCBMnToVrq6u2LFjB55//nk0btwYHTt2LPcYGo0G4eHh8PDwwOHDh5GVlaUzv6RQrVq1sH79enh7e+PkyZMYPXo0atWqhbfeegsRERH4448/sGvXLuzbtw8A4ObmVmwfOTk5CAsLQ6dOnXD06FFcvXoVL730EsaNG6cTcMXHx8PLywvx8fE4d+4cIiIi0LZtW4wePbr8HxqAJUuWYOHChVizZg3atWuHtWvXon///jh16hSaNGmCpUuX4ttvv8WmTZvQoEEDpKamIjU1FQCwdetWLF68GF9//TVatWqFjIwM/Pbbb3odt8KEBcjKyhIARFZWltJNISKyWHl5eeLPP/8UeXl5Qgghbt8WQvZRVP3j9m3923369GkBQMTHx2vLQkJCxHPPPVfqNn379hVvvPGG9nm3bt3ExIkTtc/9/f3F4sWLhRBC7N69W9SoUUOkpaVpX//hhx8EALFt27ZSj7FgwQIRFBSkfT579mwRGBhYrF7R/Xz00Ueidu3a4naRH8COHTuEjY2NyMjIEEIIERkZKfz9/cW9e/e0dYYMGSIiIiJKbcuDx/b29hbvvfeeTp0OHTqI1157TQghxPjx40WPHj2ERqMptq+FCxeKpk2bioKCglKPV9SDv1dF6fv5zZ4RIqJqytlZ9lAodWx9NW/eHJ07d8batWvRvXt3nDt3Dvv378e8efMAAGq1GvPnz8emTZuQlpaGgoIC5Ofn6z0n5PTp0/Dz84O3t7e2rFOnTsXqxcTEYOnSpTh//jxu376Ne/fuwdXVVf8T+f9jBQYGomaRbqEuXbpAo9EgOTkZHh4eAIBWrVrB1tZWW8fLywsnT57U6xjZ2dm4cuUKunTpolPepUsXbQ/HyJEj8eSTT6JZs2bo1asX/vOf/+Cpp54CAAwZMgTR0dFo1KgRevXqhT59+qBfv36oUcN0IQPnjBARVVMqlRwqUeLx/6MtenvxxRexdetW3Lp1C+vWrUPjxo3RrVs3AMCCBQuwZMkSTJ06FfHx8Thx4gTCwsJQUFBgtJ9VYmIihg8fjj59+uD777/H8ePHMWPGDKMeoyg7Ozud5yqVChqNxmj7f/TRR5GSkoJ3330XeXl5GDp0KAYPHgxA3m04OTkZK1euhJOTE1577TV07drVoDkrhmIwQkREZm/o0KGwsbHBhg0b8Pnnn+OFF17Qzh85ePAgBgwYgOeeew6BgYFo1KgR/vrrL7333aJFC6SmpiI9PV1b9ssvv+jUOXToEPz9/TFjxgy0b98eTZo0wcWLF3Xq2NvbQ61Wl3us3377DTk5OdqygwcPwsbGBs2aNdO7zWVxdXWFt7c3Dh48qFN+8OBBtGzZUqdeREQEPv74Y8TExGDr1q34559/AABOTk7o168fli5dioSEBCQmJurdM1MRHKYhIiKz5+LigoiICEyfPh3Z2dkYOXKk9rUmTZpgy5YtOHToEGrXro1FixYhMzNT54O3LKGhoWjatCkiIyOxYMECZGdnY8aMGTp1mjRpgkuXLuHrr79Ghw4dsGPHDmzbtk2nTkBAAFJSUnDixAn4+vqiVq1axZb0Dh8+HLNnz0ZkZCTmzJmDa9euYfz48Xj++ee1QzTG8Oabb2L27Nlo3Lgx2rZti3Xr1uHEiRP46quvAACLFi2Cl5cX2rVrBxsbG2zevBmenp5wd3fH+vXroVarERwcDGdnZ3z55ZdwcnKCv7+/0dr3IPaMEBGRRXjxxRfx77//IiwsTGd+x8yZM/Hoo48iLCwM3bt3h6enJwYOHKj3fm1sbLBt2zbk5eWhY8eOeOmll/Dee+/p1Onfvz9ef/11jBs3Dm3btsWhQ4fwzjvv6NQZNGgQevXqhSeeeAL16tUrcXmxs7Mzdu/ejX/++QcdOnTA4MGD0bNnTyxfvtywH0Y5JkyYgMmTJ+ONN95A69atsWvXLnz77bdo0qQJALky6IMPPkD79u3RoUMHXLhwATt37oSNjQ3c3d3x8ccfo0uXLmjTpg327duH7777DnXq1DFqG4tSCaHvam/lZGdnw83NDVlZWQZPFiIiIunOnTtISUlBw4YN4ejoqHRzyEqU9Xul7+c3e0aIiIhIUQxGiIiISFEMRoiIiEhRDEaIiIhIUQxGiIiqGQtYt0AWxBi/TwxGiIiqicKsnrm5uQq3hKxJ4e/Tg1ljDcGkZ0RE1YStrS3c3d1x9epVADLnhcrQvOxE/08IgdzcXFy9ehXu7u4699IxFIMRIqJqxNPTEwC0AQlRZbm7u2t/ryqKwQgRUTWiUqng5eWF+vXrm/TGZ1Q92NnZVapHpBCDESKiasjW1tYoHyJExsAJrERERKQoBiNERESkKAYjREREpCgGI0RERKQoBiNERESkqAoFIytWrEBAQAAcHR0RHByMI0eOlFr37t27mDdvHho3bgxHR0cEBgZi165dFW4wERERWReDg5GYmBhMnjwZs2fPRlJSEgIDAxEWFlZqAp2ZM2dizZo1WLZsGf7880+88sorePrpp3H8+PFKN56IiIgsn0oYeIeb4OBgdOjQAcuXLwcAaDQa+Pn5Yfz48Zg2bVqx+t7e3pgxYwbGjh2rLRs0aBCcnJzw5Zdf6nXM7OxsuLm5ISsrC66uroY0l4iIiBSi7+e3QT0jBQUFOHbsGEJDQ+/vwMYGoaGhSExMLHGb/Px8ODo66pQ5OTnhwIEDpR4nPz8f2dnZOg8iIiKyTgYFI9evX4darYaHh4dOuYeHBzIyMkrcJiwsDIsWLcLZs2eh0Wiwd+9exMbGIj09vdTjREVFwc3NTfvw8/MzpJlERERkQUy+mmbJkiVo0qQJmjdvDnt7e4wbNw6jRo2CjU3ph54+fTqysrK0j9TUVFM3k4iIiBRiUDBSt25d2NraIjMzU6c8MzOz1Dv21atXD9u3b0dOTg4uXryIM2fOwMXFBY0aNSr1OA4ODnB1ddV5EBERkXUyKBixt7dHUFAQ4uLitGUajQZxcXHo1KlTmds6OjrCx8cH9+7dw9atWzFgwICKtZiIiIisisF37Z08eTIiIyPRvn17dOzYEdHR0cjJycGoUaMAACNGjICPjw+ioqIAAIcPH0ZaWhratm2LtLQ0zJkzBxqNBm+99ZZxz4SIiIgsksHBSEREBK5du4ZZs2YhIyMDbdu2xa5du7STWi9duqQzH+TOnTuYOXMm/v77b7i4uKBPnz744osv4O7ubrSTICIiIstlcJ4RJTDPCBERkeUxSZ4RIiIiImNjMEJERESKYjBCREREimIwQkRERIpiMEJERESKYjBCREREimIwQkRERIoyOOkZ6UetBvbvB9LTAS8vICQEsLVVulVERETmh8GICcTGAhMnApcv3y/z9QWWLAHCw5VrFxERkTniMI2RxcYCgwfrBiIAkJYmy2NjlWkXERGRuWIwYkRqtewRKSnBfmHZpEmyHhEREUkMRoxo//7iPSJFCQGkpsp6REREJDEYMaL0dOPWIyIiqg4YjBiRl5dx6xEREVUHDEaMKCRErppRqUp+XaUC/PxkPSIiIpIYjBiRra1cvgsUD0gKn0dHM98IERFRUQxGjCw8HNiyBfDx0S339ZXlzDNCRESki0nPTCA8HBgwgBlYiYiI9MFgxERsbYHu3ZVuBRERkfnjMA0REREpisEIERERKYrBCBERESmKwQgREREpisEIERERKYrBCBERESmKwQgREREpisEIERERKYrBCBERESmKwQgREREpisEIERERKYrBCBERESmKwQgREREpisEIERERKYrBCBERESmqhtINoIpRq4H9+4H0dMDLCwgJAWxtlW4VERGR4RiMWKDYWGDiRODy5ftlvr7AkiVAeLhy7SIiIqoIDtNYmNhYYPBg3UAEANLSZHlsrDLtIiIiqigGIxZErZY9IkIUf62wbNIkWY+IiMhSMBixIPv3F+8RKUoIIDVV1qsMtRpISAA2bpRfGdwQEZEpcc6IBUlPN269knA+ChERVTX2jFgQLy/j1nsQ56MQEZESGIxYkJAQ2UuhUpX8ukoF+PnJeobifBQiIlJKhYKRFStWICAgAI6OjggODsaRI0fKrB8dHY1mzZrByckJfn5+eP3113Hnzp0KNbg6s7WVwyVA8YCk8Hl0dMXyjVTVfBQiIqIHGRyMxMTEYPLkyZg9ezaSkpIQGBiIsLAwXL16tcT6GzZswLRp0zB79mycPn0an376KWJiYvD2229XuvHVUXg4sGUL4OOjW+7rK8srOq+jKuajEBERlUQlREkd86ULDg5Ghw4dsHz5cgCARqOBn58fxo8fj2nTphWrP27cOJw+fRpxcXHasjfeeAOHDx/GgQMH9DpmdnY23NzckJWVBVdXV0Oaa7WMnYE1IQF44ony68XHA927V/w4RERUfej7+W1Qz0hBQQGOHTuG0NDQ+zuwsUFoaCgSExNL3KZz5844duyYdijn77//xs6dO9GnT59Sj5Ofn4/s7GydB+mytZVBwTPPyK+VTQVvyvkoREREZTEoGLl+/TrUajU8PDx0yj08PJCRkVHiNs8++yzmzZuHxx9/HHZ2dmjcuDG6d+9e5jBNVFQU3NzctA8/Pz9DmkkVYMr5KERERGUx+WqahIQEzJ8/HytXrkRSUhJiY2OxY8cOvPvuu6VuM336dGRlZWkfqamppm4mwXTzUYiIiMpiUNKzunXrwtbWFpmZmTrlmZmZ8PT0LHGbd955B88//zxeeuklAEDr1q2Rk5ODMWPGYMaMGbCxKR4POTg4wMHBwZCmkZGEhwMDBvCOwEREVHUM6hmxt7dHUFCQzmRUjUaDuLg4dOrUqcRtcnNziwUctv//yWbg3FmqIsaej0JERFQWg9PBT548GZGRkWjfvj06duyI6Oho5OTkYNSoUQCAESNGwMfHB1FRUQCAfv36YdGiRWjXrh2Cg4Nx7tw5vPPOO+jXr582KCEiIqLqy+BgJCIiAteuXcOsWbOQkZGBtm3bYteuXdpJrZcuXdLpCZk5cyZUKhVmzpyJtLQ01KtXD/369cN7771nvLMgIiIii2VwnhElMM8IERGR5TFJnhEiIiIiY2MwQkRERIpiMEJERESKYjBCREREimIwQkRERIpiMEJERESKYjBCREREimIwQkRERIpiMEJERESKMjgdPFFlqdW8KzAREd3HYISqVGwsMHEicPny/TJfX2DJEiA8XLl2ERGRcjhMQ1UmNhYYPFg3EAGAtDRZHhurTLuIiEhZDEaoSqjVskekpNsyFpZNmiTrERFR9cJghKrE/v3Fe0SKEgJITZX1iIioemEwQlUiPd249YiIyHowGKEq4eVl3HpERGQ9GIxQlQgJkatmVKqSX1epAD8/WY+IiKoXBiNUJWxt5fJdoHhAUvg8Opr5RoiIqiMGI1RlwsOBLVsAHx/dcl9fWW6sPCNqNZCQAGzcKL9yhQ4RkXlj0jOqUuHhwIABpsvAyqRqRESWRyVESZkfzEt2djbc3NyQlZUFV1dXpZtDZqowqdqDv9GFw0DG7H0hIqLy6fv5zWEasgpMqkZEZLkYjJBVYFI1IiLLxWCErAKTqhERWS4GI2QVmFSNiMhyMRghq8CkakRElovBCFkFJlUjIrJcDEbIalRVUjUiIjIuBiNkVcLDgQsXgPh4YMMG+TUlhYEIEVkmIYDly4G2bYEPPgDy8pRukWkw6RkREZEZun0bGD0a+Prr+2Xe3sCcOcCoUUANC8ihzqRnREREFurMGSA4WAYiNWoAEyYA/v7AlSvAmDHAI48AW7eWnOjREjEYISIiMiNbtgAdOgB//il7QhIS5AT95GRg8WKgbl35/eDBMmD58UelW1x5DEaIiIjMwL17wJQpwJAhcoimWzcgKQno0kW+7uAgb2tx/jwwaxZQsyZw9CjQsycQFibrWioGI0RERArLyJBBxcKF8vmbbwL79gEeHsXruroCc+fKoGT8eMDODtizBwgKAoYNA86dq9q2GwODESIiIgXt3w+0awf8/DNQq5acC/LBB+VPUPXwAJYulfNLhg+XOZViYoAWLYDXXpMBjqVgMEJERKQAIeQckCeekIFDq1Zy2MXQVASNGgFffgkcPw707i2He1atAho3BmbOBLKyTNN+Y2IwQkREVMVu3ZJDKpMnA2o18MwzwOHDQLNmFd9nYCCwc6ec8PrYY0BuLvDeezJYWbgQuHPHaM03OgYjRESkCLVaDjFs2CDnSIwfD/z2m9KtMr3Tp4GOHYFNm+RQzLJlwFdfyQmpxtCtG3DoELBtmxyy+ecfOTG2SRNg7VrZc2JumPSMiIhM7u5duVQ1KUk+jh8HTpwAcnKK1+3fXw4vdOhQ5c00uU2bgBdflKtlvL3lMt5OnUx3PLUa+PxzYPZsIDVVlrVoAcyfDwwYUPrNRY1F389vBiNEBlKr5YSz9HTAy0veCZg34CO6Ly8POHnyfuCRlCSfFxQUr+vkJFOdt2sHXL8ObN58P5FXWJgMSh5/vEqbbxJ37wJvvSVv2AnIeSJffw3Ur181x79zB1ixQgYh//wjyx57DHj/fdmTYioMRohMIDYWmDgRuHz5fpmvr0xIxPvfmJ5GA5w9K1cRuLsr3RoCgOxs2cNx/Pj9wOP0aRm0P8jNTQYdjz56/2uzZrrBfHIyEBUlJ2QW7qNbNxmU9Oxp+v/kTSE9HRg6FDhwQD6fOhX473+VSeeelQUsWCAnzubmyrLeveXPPDDQ+MdjMEJkZLGxMuPhg++Ywj+OvDOw6Vy5AqxfL8e7z5+XZY0b3/9AK/xwq6r/MqsjtRq4cUPO6SgcZklKksFhSerVu39tCh8NG+ofTPz9N/C//wHr1sleBUD+Jz9zJtCnj+UEJT//LAORzEyZH+Szz4CBA5VulQyQ3n0X+PhjOYdEpZLzVp55xrjHMWkwsmLFCixYsAAZGRkIDAzEsmXL0LFjxxLrdu/eHT/99FOx8j59+mDHjh16HY/BCClNrQYCAnR7RIpSqWQPSUoKh2yM5e5dYMcO4NNP5QoBjUaW29uX3N0PAD4+usHJo4/K62IpH1zGIoQcKrl1S85NuH37/vcPftX3tbLuFuvnV/zn7u1tnJ97aqr8T/7jj++vBmnXTgYlAwcCNma6DEMIYNEi2QuiVst7ycTGykmk5uTcOeCdd4Ddu2WgX7u2cfev9+e3MNDXX38t7O3txdq1a8WpU6fE6NGjhbu7u8jMzCyx/o0bN0R6err28ccffwhbW1uxbt06vY+ZlZUlAIisrCxDm0tkFPHxQsg/L2U/4uOVbqnlS04W4q23hPDw0P3ZPv64EOvXC3H7thDXrwuxd68Q//ufEMOGCdG0aenXpG5dIZ58UoipU4WIiRHi7Fkh1Gqlz9J4NBohkpKEmDZNiObNhXB1FcLGRr/f14o8Hn5YiKFDhXj/fSH27BHi2rWqOc/0dCHefFOImjXvt6VlSyG++kqIu3erpg36ys4WYvDg++0cPlz+3pqz69dNs199P78N7hkJDg5Ghw4dsHz5cgCARqOBn58fxo8fj2nTppW7fXR0NGbNmoX09HTU1HMdE3tGSGkbNwLPPlt+vQ0bjN/NWR3k5Mhhrk8/lZODC9WvD0RGAi+8ADRvXvY+srPlEELRuQt//lny3IVatYoP8TRvbhm3ZC/0xx8y2+amTcBff5Vez8VFPmrVKv69oV9dXOT9UZR044acBLp0qbzmAPDww8DbbwPPPSdToyvpzz/lcG1ysmzL4sUyG2p1650rZJJhmoKCAjg7O2PLli0YWGTQKzIyEjdv3sQ333xT7j5at26NTp064aOPPiq1Tn5+PvLz87XPs7Oz4efnx2CEFJOQIGe/lyc+Huje3dStsQ5CAMeOAZ98IoO9wg8WGxs5oe6ll4C+fSv34ZKXJz+0iy4n/f13oMifFy1HRzmBLyhIrt7o2lUO+5iT5GQZgMTEyA+9Qo6O8mc1dKgMrAoDCGdn8x3GqKybN+XqkMWLZYACAP7+clhk1Cj5M6lqMTFy2W5Ojhwe3LxZznOpzkwyTJOWliYAiEOHDumUv/nmm6Jjx47lbn/48GEBQBw+fLjMerNnzxYAij04TENKuXdPCF9fIVSqkruuVSoh/PxkPSrbjRtCLFkiRJs2uj/DRo2E+O9/hbh82bTHLygQ4rff5JDPhAly+MfFpeTr2qiRECNHCrFunRDnz8shkap2/rwQ8+cLERio2zZ7eyH695fDFNnZVd8uc3HrlhALFugO63l7C7F4sRA5OaY97l9/CfHTT0J8/bUQL798//g9eghx9arpjm1JTDJMc+XKFfj4+ODQoUPoVCRLy1tvvYWffvoJhw8fLnP7l19+GYmJifj999/LrMeeETJHhatpAN0VNVxNUz6NRvYaffKJzApZ+PZ2cAAGDZK9IN26KfdfvEYjJ/IlJQG//CKHik6cuD9ptpCPj+wxKXy0aGGa7vdLl+TwS0wM8Ouv98tr1ACefBKIiJAJq7i8+b68PDnM97//3Z9oXq+eTLf+2mtyJUt5hJC9LOnp8l4x6eklPzIy5KTekkyfLlepcCK7ZHbDNDk5OfD29sa8efMwceJEfQ8JgHNGyHyUlGfEz0+OYTMQKe7yZbk0c906udKoUNu2MgB59lnjz943lqwsmVL755/l4+jR+0tMC9WtqxuctGlT8Q+hK1dkt35MDJCYeL/cxgbo0UMGIE8/DdSpU/Fzqg7y82XG0aio+79ztWvL923v3nKJbdGg4sEg48FrXBYXF5n40NNTrh6KjJTHoPtMtrQ3ODgYHTt2xLJlywDICawNGjTAuHHjypzAun79erzyyitIS0tDHQPfTQxGyJwwA2vZCgqA77+XvSC7d9/vXXBzk8HHSy/JSaOWJjdX9poUBieJicVvPObqen++Sbducv5JWXNeMjPl7eJjYuTvVOFfY5VK7iMiQvYcMX+K4e7elXOR5s+Xc20MUaeOfG8XfXh6Fi9zcTFN262JyYKRmJgYREZGYs2aNejYsSOio6OxadMmnDlzBh4eHhgxYgR8fHwQFRWls11ISAh8fHzw9ddfm+xkiEhZ584BoaHAxYv3y7p1k5P6Bg2SEyqtRUGBHEIpDE4OHJA5OYpydpb3HSnsOQkOlkFNbKwMQOLjdYeCOneWAcjgwfI/bao8tVoGfB9+CKSlFQ8oHgw4PD1lLhsyDn0/vw1eyBYREYFr165h1qxZyMjIQNu2bbFr1y54eHgAAC5dugSbBwZ+k5OTceDAAezZs8fQwxGRhcjMBHr1koGIh4dc0fDCC+aX5MlY7O1l8NC5MzBtmsxi+dtv94OTn3+W9wCJi5MPQPaSCKF719QOHWQAMmQI0KCBMudizWxt5SqjoUOVbgmVhengiajSbt+WS5qPHQMaNZJzLf7//5NqS6OR92gpDEx++kkO7QFyzkxEhPyAbNRI0WYSmRTvTUNEVeLuXaBfPzk/pG5dGYhYa29IZQgh77diYyPv0UJUHZhsmIaIqJAQckLq7t1yfsSOHQxESqNSyZv7EVFxVpqbj8h0hABOnSq+kqI6evttuYzS1lbmWSnlfplERGViMEKkp8KkSm3ayDtwNm8uZ+mb/0CnaSxbBrz/vvz+k0+YX4GIKo7BCFE5rlyRt9hu0EAOSfzxhyy/eFEuwezZEzh5Utk2VrXNm2USKQB47z1g5EhFm0NEFo7BCFEpjh0Dnn8eCAgA/vtf4Pp1GZAsWCAzi86aJW/GFR8vV0eMGyeXclq7hAR5d1QhZJrt6dOVbhERWToGI0RF3Lsn5z6EhADt2wNffilXizz+uCw/fx6YMkXeo2TuXLl0c9AguYxzxQo5eXPlSt08Etbk5Elg4ECZ8Cs8XN7GvbreGp2IjIfBCBHk7cg//FCudhgyRGbTtLOTPQBHj8pU3YMGyRuVFRUQIIOUuDg5j+Sff4CxY2Ua8IQEBU7EhC5dkknNsrJksPbVV0yDT0TGwWCEqrW//pLDK76+wJtvyg/cunWBmTOBCxeAL76QPSTl6dEDOH4cWL5c3pTr99+BJ56QSa2Kpka3VP/8IwORK1eAVq2Ab76RQ1RERMbAYISqHSGAffuA//wHaNZMDq/k5ACtW8vVMpcuyVuAG3pvkBo1ZK/I2bPAq6/K5FabN8tVN3PmyHuSWKK8PKB/fzkk5eMD/PCD+d5pl4gsE4MRqjby8oCPP5ZBx5NPygRdKpXMHhoXJ+8r8sILgJNT5Y5Tp46cN5KUJG8Sd+eOnF/SooUMTixpKbBaLe+0e/Ag4O4uk5v5+SndKiKyNgxGyOqlpQEzZsgP0TFjZMKymjWB8ePlrcW//VYOsxh7ImZgoFxps2mTXIVz6ZIctnniCTmMY+6EkENY27cDDg7y59SqldKtIiJrxGCErNaRI8Dw4XKS6fz5wI0b8vuFC+XS3KVLTZ+6XKWSE2JPnwZmz5bzLH76CWjXTi6LvXHDtMevjPfeA1avluewYYOctEpEZAoMRsjq5OYCYWFAcLD8EL13D+jaFYiNBc6dAyZPlkMOVcnZWc4bOXNGBicaDbBqlQyGli83v6XAa9fKRG+AzLQaHq5se4jIujEYIaszaRKwZ49cmjtihExe9tNPwNNPK78U1d9fDtvEx8u08v/+K4eL2rUDfvxR2bYV2rFDDmcB8t4zY8cq2x4isn4MRsiqxMTISaoqlVz18dlnwKOPKt2q4rp3l0HSypXAQw/JFPM9e8r08hcuKNeuw4dlz41aLVO8//e/yrWFiKoPBiNkNf7+Gxg9Wn7/9tvyw92c1aghlwCfPSt7H2xs5I33WrSQQyQpKVXbnr/+Avr2lauOevcGPvqI2VWJqGqohDD/hYbZ2dlwc3NDVlYWXF1dlW4OmaGCApmy/ehRoEsXmf30wWyp5u7kSXnzufj4+2UtWgB9+sgg4fHH5dCTKaSnA507y16Z9u1lG1xcTHMsIqo+9P38Zs8IWYW335aBSO3actKqpQUigMx/Ehcn08t37Srnt5w+LVf/9OghM8MOHgysWwdkZBjvuNnZMuC5cAF4+GE5Z4SBCBFVJfaMkMXbuVP2HADAtm3yRm7W4OZNORF35075uHZN9/WgoPu9Jh06yGEeQxUUyH3ExQH16wOJiUCjRkZpPhGR3p/fDEbIol25IpOLXb8uV6UsXap0i0xDowF+/VUGJTt2yO+LqldP3jumb1/gqaf0S9eu0QDPPy97klxc5NBWUJBJmk9E1RSDEbJ6arVM6x4fD7RtK/+rt/Sbt6nV8g7B6emAl5dMNFbScuTMTLlaaOdOmaI9O/v+a7a2cv5H376y1+ORR0qeiDplihwCqlFDBjhPPWW68yKi6onBCFm9d98FZs2Sqd2TkoCmTZVuUeXExsoJrJcv3y/z9QWWLCk76djdu/LeMYW9Jn/+qfu6n9/94ZwePeTPa/FimfwNAD7/XPaQEBEZG4MRsmr798tcHRqNdXyYxsbKyakPvhsLezS2bNE/C+qFC/cDkx9/lDfqK+TgADz2mEwCBwD/+x/w1luVbj4RUYkYjJDVunFDDstcviwzrH72mdItqhy1Wt4zp2iPSFEqlewhSUkxPINsXp4cxioMToomVJswAYiOZi4RIjIdBiNklYQABgwAvvtODsscO2b5y1ATEuSdfMsTHy97gypKCHlvnJ075cqbiRMrtgKHiEhf+n5+W2A2BqrOli2TgYi9vUz9bumBCCAnqxqzXmlUKplErUWLyu2nLPpOwCUiKorBCFmMpCTgzTfl9wsXyqEaa+DlZdx6SqnoBFwiInbSkkW4dQuIiJBJugYOtK47yYaEyA/t0uZuqFRyRUxISNW2yxCFE3AfnPeSlibLY2OVaRcRWQYGI2T2hJA3lDt3Tn4of/qpdU26tLWVvQdA8fMqfB4dbZzhDrVazlHZuFF+VauNs8+JE4uvBALul02aZJxjEZF1YjBCZu+zz4CvvpIfxhs3Ag89pHSLjC88XC7f9fHRLff1NWxZb1liY+WqnSeeAJ59Vn4NCKh8r8X+/aWvBAJkQJKaKusREZWEc0bIrJ05c39IZu5ceUdeaxUeLlcKmWICaGl5TAqHUSoT8FTVBFwisl4MRshs3bkj54nk5gI9ewLTpindItOzta3c8t2SlDeMolLJYZQBAyoW+FjLBFwiUg6HachsvfEG8Pvv8iZwX3zBJaIVZephFGuYgEtEymIwQmYpNhZYuVJ+//nn/K+6Mkw9jFKVE3CJyDoxGCGzc/Ei8OKL8vu33gJ69VK2PZauKoZRqmICLhFZL6aDJ7Ny9y7QrRuQmAgEB8uhAzs7pVtl2QrvfZOWVvK8kcrc+6akYzEDKxEVYjp4skizZ8tAxM1NLuNlIFJ5hcMogwfLwKNoQGLsYRRTTMAlIuvHYRoyG3v3Au+/L7//+GOgYUNl22NNOIxCROaMPSNkFjIzgeefl/+1v/wyMGSI0i2yPqbMY0JEVBkMRkhxGo0MRDIzgUceARYvVrpF1ovDKERkjjhMQ4pbsEAO0Tg5ATEx8isREVUfFQpGVqxYgYCAADg6OiI4OBhHjhwps/7NmzcxduxYeHl5wcHBAU2bNsXOnTsr1GCyLomJwIwZ8vtly4CWLZVtDxERVT2Dh2liYmIwefJkrF69GsHBwYiOjkZYWBiSk5NRv379YvULCgrw5JNPon79+tiyZQt8fHxw8eJFuLu7G6P9ZMH+/Rd45hm5HHTYMOCFF5RuERERKcHgPCPBwcHo0KEDli9fDgDQaDTw8/PD+PHjMa2Em4esXr0aCxYswJkzZ2BXwXWazDNifYSQk1S3bgUaNQKOHwd4aYmIrIu+n98GDdMUFBTg2LFjCA0Nvb8DGxuEhoYiMTGxxG2+/fZbdOrUCWPHjoWHhwceeeQRzJ8/H2q1utTj5OfnIzs7W+dBlk0I4Pp1OSzz+efAmDEyELGzk/NEGIgQEVVfBg3TXL9+HWq1Gh4eHjrlHh4eOHPmTInb/P333/jxxx8xfPhw7Ny5E+fOncNrr72Gu3fvYvbs2SVuExUVhblz5xrStConBJCXB9y+Ddy6Jb8W/b7wa6tWQI8eSre26mRlAWfPysdff93//uxZOSzzoPffB9q3r/p2EhGR+TD50l6NRoP69evjo48+gq2tLYKCgpCWloYFCxaUGoxMnz4dkydP1j7Pzs6Gn5+f0dv2yy9yOWlZwcSDX4t+r9Hod5xnn5WTMx96yOinoIicHODcuZIDjqtXy97W1xdo0gRo2lTmuHj22appMxERmS+DgpG6devC1tYWmZmZOuWZmZnw9PQscRsvLy/Y2dnBtkhmpRYtWiAjIwMFBQWwt7cvto2DgwMcHBwMaVqFTJgAHD1a+f3UrAnUqgW4uNz/6uIC1KgB7NgBbNgAxMcDn3wC9OlT+eNVBSFkoHHmTPGgIy2t7G09PGTAURh0FH7/8MOAs3PVtJ+IiCyHQcGIvb09goKCEBcXh4EDBwKQPR9xcXEYN25cidt06dIFGzZsgEajgY2NnKLy119/wcvLq8RApCq1aSOTQJUUSDxYVtprzs6ATRkzbw4fBiIjgeRkoG9f4KWXgIULzXuOxO+/AxMnAgkJpdepXft+oFE04GjSxLzPjYiIzI/Bq2liYmIQGRmJNWvWoGPHjoiOjsamTZtw5swZeHh4YMSIEfDx8UFUVBQAIDU1Fa1atUJkZCTGjx+Ps2fP4oUXXsCECRMwozDBRDksfTVNXp7MpREdLXsc/P2BdeuAJ55QumW6btwAZs0CVq+WQ1D29jIjakm9HHXqKN1aIiIydya7a29ERASuXbuGWbNmISMjA23btsWuXbu0k1ovXbqk7QEBAD8/P+zevRuvv/462rRpAx8fH0ycOBFTp06twGlZJicnYNEieV+QUaPkrdp79JDDRFFRyg9d3LsHrFkjA5F//pFlQ4bIzKj+/sq2jYiIrJ/BPSNKsPSekaJu3QLefFN++AOyl+Gzz4BOnZRpT3y8HJI5eVI+b90aWLqU9y8hIqLKM0meEaq8WrXkMMiuXfJ27mfPAo8/DkyfDuTnV107Ll6UvR89eshA5KGHgBUrgKQkBiJERFS1GIwoJCwM+OMPebdajeZ+vo3jx0173NxcYPZsoHlzYMsWOfl27FgZFL32mlwBREREVJUYjCjI3V1mI42NBerVk8FJx47Au+8Cd+8a91hCyEynzZsD8+YBd+7ICbQnTgDLl1tPDhQiIrI8DEbMwNNPA6dOAeHhcjLprFlA587An38aZ/8nTsihl2HDgNRUOSl1yxYgLk7OESEiIlISgxEzUa+eDBC++kr2mPz6K/DoozInSRm38SnT9evAK68AQUHAzz/LVT1z5wKnTwODBgEqlVFPgYiIqEIYjJgRlUqmRz91CujdW05onTJF9mqcP6//fu7dk+nnmzSRq3Y0GiAiQmZTnTVLBiVERETmgsGIGfL2lmnkP/5YZno9cEBmi121Ss79KEtcHNC2rcxhcvMmEBgI/PQT8PXXQIMGVdF6IiIiwzAYMVMqlUwdf/Kk7BnJzZWrXcLC5LyPB6WkyDknoaGyZ6VOHRm8HDsGdO1a5c0nIiLSG4MRMxcQIHs7liyRwyt798oU7Z99JntJcnKAd94BWrQAtm2T99oZP14u1X3lFfmcyFqo1fKeSRs3yq8VnU9FROaFGVgtyF9/yZvu/fKLfP7UU3LFzeXL8nnPnvL+N488olgTiUwmNlZmCy78fQcAX18ZqIeHK9cufanVwP79QHo64OUFhITwnwWyfszAaoWaNpV/zKKiADs7YM8e+Yc5IED+oS7sNSGyNrGxwODBuoEIAKSlyfLY2Mofw5S9LrGx8n36xBNykvoTT9x/3xIRe0Ys1smTcpluUBAwaRJXyJD1UqvlB/eDgUghlUr2kKSkVLynwZS9LoWB1IN/aQuX1m/ZYhk9O0QVoe/nN4MRIjJrCQmyJ6E88fEVu6+SKYOFqgikiMwZh2mIyCqkpxu3XlFqtewRKelfssKySZMqPmSzf3/pgUjhMVJTZT2i6ozBCBGZNS8v49YrytTBgikDKSJrwmCEiMxaSIgcyijt9gUqFeDnJ+sZytTBgikDKSJrwmCEiMyara2cSAoUD0gKn0dHV2zOhamDBVMGUkTWhMEIEZm98HA5kdTHR7fc17dyE0xNHSyYMpAisiYMRojIIoSHAxcuyFUzGzbIr4W3QaioqggWTBVIEVkTLu0lomqvpDwjfn4yEDFWsMAMrFQdMc8IEZEBGCwQGZ++n981qrBNRERmy9a2YknTiKjyOGeEiIiIFMVghIiIiBTFYISIiIgUxWCEiIiIFMVghIiIiBTFYISIiIgUxWCEiIiIFMVghIiIiBTFYISIiIgUxWCEiIiIFMVghIiIiBTFYISIiIgUxWCEiIiIFMVghIiIiBTFYISIiIgUxWCEiIiIFFVD6QYQEVH1plYD+/cD6emAlxcQEgLY2irdKqpKDEaIiEgxsbHAxInA5cv3y3x9gSVLgPBw5dpFVYvDNEREpIjYWGDwYN1ABADS0mR5bKwy7aKqV6FgZMWKFQgICICjoyOCg4Nx5MiRUuuuX78eKpVK5+Ho6FjhBhMRkeVTq2WPiBDFXyssmzRJ1iPrZ3AwEhMTg8mTJ2P27NlISkpCYGAgwsLCcPXq1VK3cXV1RXp6uvZx8eLFSjWaiIgs2/79xXtEihICSE2V9cj6GRyMLFq0CKNHj8aoUaPQsmVLrF69Gs7Ozli7dm2p26hUKnh6emofHh4elWo0ERFZtvR049Yjy2ZQMFJQUIBjx44hNDT0/g5sbBAaGorExMRSt7t9+zb8/f3h5+eHAQMG4NSpU2UeJz8/H9nZ2ToPIiKyHl5exq1Hls2gYOT69etQq9XFejY8PDyQkZFR4jbNmjXD2rVr8c033+DLL7+ERqNB586dcbmM/rmoqCi4ublpH35+foY0k4iIzFxIiFw1o1KV/LpKBfj5yXpk/Uy+mqZTp04YMWIE2rZti27duiE2Nhb16tXDmjVrSt1m+vTpyMrK0j5SU1NN3UwiIqpCtrZy+S5QPCApfB4dzXwj1YVBeUbq1q0LW1tbZGZm6pRnZmbC09NTr33Y2dmhXbt2OHfuXKl1HBwc4ODgYEjTiIiqNVMnDjPF/sPDgS1bSs4zEh3NPCPViUE9I/b29ggKCkJcXJy2TKPRIC4uDp06ddJrH2q1GidPnoQXBwKJiIwiNhYICACeeAJ49ln5NSDAeHk6TLn/8HDgwgUgPh7YsEF+TUlhIFLdGJyBdfLkyYiMjET79u3RsWNHREdHIycnB6NGjQIAjBgxAj4+PoiKigIAzJs3D4899hgefvhh3Lx5EwsWLMDFixfx0ksvGfdMiIiqocLEYQ/m6yhMHLZlS+U+2E29f0D2sHTvXrl9kGUzOBiJiIjAtWvXMGvWLGRkZKBt27bYtWuXdlLrpUuXYGNzv8Pl33//xejRo5GRkYHatWsjKCgIhw4dQsuWLY13FkRE1VB5icNUKpk4bMCAig2pmHr/RIVUQpT0a2ZesrOz4ebmhqysLLi6uirdHCIis5CQIIdMyhMfX7GeB1Pvn6yfvp/fvDcNEZGFMnXiMCYmo6rCYISIyEKZOnEYE5NRVWEwQkRkoUydOIyJyaiqMBghIrJQpk4cxsRkVFUYjBARWbDCxGE+Prrlvr7GWXZr6v0TAVxNQ0RkFSwxAytZP30/vw3OM0JERObH1InDmJiMTInDNERERKQoBiNERESkKAYjREREpCgGI0RERKQoBiNERESkKAYjREREpCgGI0RERKQoBiNERESkKAYjREREpCgGI0RERKQoBiNERESkKAYjREREpCgGI0RERKQo3rWXiIismloN7N8PpKcDXl5ASIi8CzGZDwYjRERktWJjgYkTgcuX75f5+gJLlgDh4cq1i3RxmIaIiKxSbCwweLBuIAIAaWmyPDZWmXZRcQxGiIjI6qjVskdEiOKvFZZNmiTrkfIYjBARkdXZv794j0hRQgCpqbIeKY/BCBERWZ30dOPWI9NiMEJERFbHy8u49ci0GIwQEZHVCQmRq2ZUqpJfV6kAPz9Zj5THYISIiKyOra1cvgsUD0gKn0dHM9+IuWAwQkREVik8HNiyBfDx0S339ZXlzDNiPpj0jIiIrFZ4ODBgADOwmjsGI0REZNVsbYHu3ZVuBZWFwzRERESkKAYjREREpCgGI0RERKQoBiNERESkKAYjREREpCgGI0RERKQoLu0lIiKqBLWaeUwqi8EIERFRBcXGAhMnApcv3y/z9ZWp6JnhVX8cpiEiIqqA2Fhg8GDdQAQA0tJkeWysMu2yRAxGiIiIDKRWyx4RIYq/Vlg2aZKsR+WrUDCyYsUKBAQEwNHREcHBwThy5Ihe23399ddQqVQYOHBgRQ5LRERkFvbvL94jUpQQQGqqrEflMzgYiYmJweTJkzF79mwkJSUhMDAQYWFhuHr1apnbXbhwAVOmTEFISEiFG0tERGQO0tONW6+6MzgYWbRoEUaPHo1Ro0ahZcuWWL16NZydnbF27dpSt1Gr1Rg+fDjmzp2LRo0aVarBRERESvPyMm696s6gYKSgoADHjh1DaGjo/R3Y2CA0NBSJiYmlbjdv3jzUr18fL774ol7Hyc/PR3Z2ts6DiIjIXISEyFUzKlXJr6tUgJ+frEflMygYuX79OtRqNTw8PHTKPTw8kJGRUeI2Bw4cwKeffoqPP/5Y7+NERUXBzc1N+/Dz8zOkmURERCZlayuX7wLFA5LC59HRzDeiL5Ouprl16xaef/55fPzxx6hbt67e202fPh1ZWVnaR2pqqglbSUREZLjwcGDLFsDHR7fc11eWM8+I/gxKela3bl3Y2toiMzNTpzwzMxOenp7F6p8/fx4XLlxAv379tGUajUYeuEYNJCcno3HjxsW2c3BwgIODgyFNIyIiqnLh4cCAAczAWlkGBSP29vYICgpCXFycdnmuRqNBXFwcxo0bV6x+8+bNcfLkSZ2ymTNn4tatW1iyZAmHX4iIyOLZ2gLduyvdCstmcDr4yZMnIzIyEu3bt0fHjh0RHR2NnJwcjBo1CgAwYsQI+Pj4ICoqCo6OjnjkkUd0tnd3dweAYuVERERUPRkcjERERODatWuYNWsWMjIy0LZtW+zatUs7qfXSpUuwsWFiVyIiItKPSoiSktmal+zsbLi5uSErKwuurq5KN4eIiIj0oO/nN7swiIiISFEMRoiIiEhRDEaIiIhIUQxGiIiISFEMRoiIiEhRDEaIiIhIUQbnGSEiIqKqoVZXj1TzDEaIiIjMUGwsMHEicPny/TJfX3m3YGu7CR+HaYiIiMxMbCwweLBuIAIAaWmyPDZWmXaZCoMRIiIiM6JWyx6RkvKjF5ZNmiTrWQsGI0RERGZk//7iPSJFCQGkpsp61oJzRoiIiMxIerpx65XFXCbIMhghIiIyI15exq1XGnOaIMthGiIiIjMSEiKDApWq5NdVKsDPT9arKHObIMtghIiIyIzY2sreCaB4QFL4PDq64sMp5jhBlsEIERGRmQkPB7ZsAXx8dMt9fWV5ZYZRzHGCLOeMEBERmaHwcGDAAONPMK3KCbL6YjBCRERkpmxtge7djbvPqpogawgO0xAREVUjVTFB1lAMRoiIiKoRU0+QrQgGI0RERNWMKSfIVgTnjBAREVVDppogWxEMRoiIiKopU0yQrQgO0xAREZGiGIwQERGRohiMEBERkaIYjBAREZGiGIwQERGRohiMEBERkaIYjBAREZGiGIwQERGRohiMEBERkaIsIgOrEAIAkJ2drXBLiIiISF+Fn9uFn+OlsYhg5NatWwAAPz8/hVtCREREhrp16xbc3NxKfV0lygtXzIBGo8GVK1dQq1YtqB6837EVyc7Ohp+fH1JTU+Hq6qp0c0yqOp0rUL3Ol+dqvarT+fJcjUMIgVu3bsHb2xs2NqXPDLGInhEbGxv4+voq3Ywq4+rqavW//IWq07kC1et8ea7WqzqdL8+18srqESnECaxERESkKAYjREREpCgGI2bEwcEBs2fPhoODg9JNMbnqdK5A9Tpfnqv1qk7ny3OtWhYxgZWIiIisF3tGiIiISFEMRoiIiEhRDEaIiIhIUQxGiIiISFEMRoiIiEhRDEaqSFRUFDp06IBatWqhfv36GDhwIJKTk8vcZv369VCpVDoPR0fHKmpxxc2ZM6dYu5s3b17mNps3b0bz5s3h6OiI1q1bY+fOnVXU2soLCAgodr4qlQpjx44tsb4lXdeff/4Z/fr1g7e3N1QqFbZv367zuhACs2bNgpeXF5ycnBAaGoqzZ8+Wu98VK1YgICAAjo6OCA4OxpEjR0x0Bvor61zv3r2LqVOnonXr1qhZsya8vb0xYsQIXLlypcx9VuS9UFXKu7YjR44s1vZevXqVu19Lu7YASnz/qlQqLFiwoNR9muu11eez5s6dOxg7dizq1KkDFxcXDBo0CJmZmWXut6LvdX0xGKkiP/30E8aOHYtffvkFe/fuxd27d/HUU08hJyenzO1cXV2Rnp6ufVy8eLGKWlw5rVq10mn3gQMHSq176NAhPPPMM3jxxRdx/PhxDBw4EAMHDsQff/xRhS2uuKNHj+qc6969ewEAQ4YMKXUbS7muOTk5CAwMxIoVK0p8/YMPPsDSpUuxevVqHD58GDVr1kRYWBju3LlT6j5jYmIwefJkzJ49G0lJSQgMDERYWBiuXr1qqtPQS1nnmpubi6SkJLzzzjtISkpCbGwskpOT0b9//3L3a8h7oSqVd20BoFevXjpt37hxY5n7tMRrC0DnHNPT07F27VqoVCoMGjSozP2a47XV57Pm9ddfx3fffYfNmzfjp59+wpUrVxAeHl7mfivyXjeIIEVcvXpVABA//fRTqXXWrVsn3Nzcqq5RRjJ79mwRGBiod/2hQ4eKvn376pQFBweLl19+2cgtqxoTJ04UjRs3FhqNpsTXLfW6AhDbtm3TPtdoNMLT01MsWLBAW3bz5k3h4OAgNm7cWOp+OnbsKMaOHat9rlarhbe3t4iKijJJuyviwXMtyZEjRwQAcfHixVLrGPpeUEpJ5xsZGSkGDBhg0H6s5doOGDBA9OjRo8w6lnJtH/ysuXnzprCzsxObN2/W1jl9+rQAIBITE0vcR0Xf64Zgz4hCsrKyAAAPPfRQmfVu374Nf39/+Pn5YcCAATh16lRVNK/Szp49C29vbzRq1AjDhw/HpUuXSq2bmJiI0NBQnbKwsDAkJiaauplGV1BQgC+//BIvvPBCmXeYttTrWlRKSgoyMjJ0rp2bmxuCg4NLvXYFBQU4duyYzjY2NjYIDQ21uOudlZUFlUoFd3f3MusZ8l4wNwkJCahfvz6aNWuGV199FTdu3Ci1rrVc28zMTOzYsQMvvvhiuXUt4do++Flz7Ngx3L17V+c6NW/eHA0aNCj1OlXkvW4oBiMK0Gg0mDRpErp06YJHHnmk1HrNmjXD2rVr8c033+DLL7+ERqNB586dcfny5SpsreGCg4Oxfv167Nq1C6tWrUJKSgpCQkJw69atEutnZGTAw8NDp8zDwwMZGRlV0Vyj2r59O27evImRI0eWWsdSr+uDCq+PIdfu+vXrUKvVFn+979y5g6lTp+KZZ54p8y6nhr4XzEmvXr3w+eefIy4uDv/73//w008/oXfv3lCr1SXWt5Zr+9lnn6FWrVrlDltYwrUt6bMmIyMD9vb2xYLosq5TRd7rhqphlL2QQcaOHYs//vij3PHFTp06oVOnTtrnnTt3RosWLbBmzRq8++67pm5mhfXu3Vv7fZs2bRAcHAx/f39s2rRJr/82LNmnn36K3r17w9vbu9Q6lnpdSbp79y6GDh0KIQRWrVpVZl1Lfi8MGzZM+33r1q3Rpk0bNG7cGAkJCejZs6eCLTOttWvXYvjw4eVOKreEa6vvZ405YM9IFRs3bhy+//57xMfHw9fX16Bt7ezs0K5dO5w7d85ErTMNd3d3NG3atNR2e3p6FpvJnZmZCU9Pz6pontFcvHgR+/btw0svvWTQdpZ6XQuvjyHXrm7durC1tbXY610YiFy8eBF79+4ts1ekJOW9F8xZo0aNULdu3VLbbunXFgD279+P5ORkg9/DgPld29I+azw9PVFQUICbN2/q1C/rOlXkvW4oBiNVRAiBcePGYdu2bfjxxx/RsGFDg/ehVqtx8uRJeHl5maCFpnP79m2cP3++1HZ36tQJcXFxOmV79+7V6T2wBOvWrUP9+vXRt29fg7az1OvasGFDeHp66ly77OxsHD58uNRrZ29vj6CgIJ1tNBoN4uLizP56FwYiZ8+exb59+1CnTh2D91Hee8GcXb58GTdu3Ci17ZZ8bQt9+umnCAoKQmBgoMHbmsu1Le+zJigoCHZ2djrXKTk5GZcuXSr1OlXkvV6RhlMVePXVV4Wbm5tISEgQ6enp2kdubq62zvPPPy+mTZumfT537lyxe/ducf78eXHs2DExbNgw4ejoKE6dOqXEKejtjTfeEAkJCSIlJUUcPHhQhIaGirp164qrV68KIYqf58GDB0WNGjXEhx9+KE6fPi1mz54t7OzsxMmTJ5U6BYOp1WrRoEEDMXXq1GKvWfJ1vXXrljh+/Lg4fvy4ACAWLVokjh8/rl1B8v777wt3d3fxzTffiN9//10MGDBANGzYUOTl5Wn30aNHD7Fs2TLt86+//lo4ODiI9evXiz///FOMGTNGuLu7i4yMjCo/v6LKOteCggLRv39/4evrK06cOKHzHs7Pz9fu48FzLe+9oKSyzvfWrVtiypQpIjExUaSkpIh9+/aJRx99VDRp0kTcuXNHuw9ruLaFsrKyhLOzs1i1alWJ+7CUa6vPZ80rr7wiGjRoIH788Ufx66+/ik6dOolOnTrp7KdZs2YiNjZW+1yf93plMBipIgBKfKxbt05bp1u3biIyMlL7fNKkSaJBgwbC3t5eeHh4iD59+oikpKSqb7yBIiIihJeXl7C3txc+Pj4iIiJCnDt3Tvv6g+cphBCbNm0STZs2Ffb29qJVq1Zix44dVdzqytm9e7cAIJKTk4u9ZsnXNT4+vsTf28Lz0Wg04p133hEeHh7CwcFB9OzZs9jPwN/fX8yePVunbNmyZdqfQceOHcUvv/xSRWdUurLONSUlpdT3cHx8vHYfD55ree8FJZV1vrm5ueKpp54S9erVE3Z2dsLf31+MHj26WFBhDde20Jo1a4STk5O4efNmifuwlGurz2dNXl6eeO2110Tt2rWFs7OzePrpp0V6enqx/RTdRp/3emWo/v+gRERERIrgnBEiIiJSFIMRIiIiUhSDESIiIlIUgxEiIiJSFIMRIiIiUhSDESIiIlIUgxEiIiJSFIMRIiIiUhSDESIiIlIUgxEiIiJSFIMRIiIiUtT/ATaBqG0qXf2VAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Using a Pretrained Network - VGG 16**"
      ],
      "metadata": {
        "id": "XYYrapvcfNTv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.applications import VGG16\n",
        "from keras.layers import Input, Lambda\n",
        "import tensorflow as tf\n",
        "\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "ELc5X9IfsHE9"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "convolution_base = VGG16(weights = 'imagenet', include_top = False, input_shape = (150, 150, 3))\n",
        "# define input layer that will match the input shape of the VGG16 model\n",
        "input_layer = Input(shape = (150,150,1))\n",
        "# replicate the grayscale channel across all three color channels\n",
        "grayscale_input = Lambda(lambda x: tf.repeat(x, 3, axis=-1))(input_layer)\n",
        "conv_output = convolution_base(grayscale_input)\n",
        "\n"
      ],
      "metadata": {
        "id": "5g_wKDApfgpt"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "convolution_base.summary();"
      ],
      "metadata": {
        "id": "ykc3ndN5hns1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import numpy as np\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "batch_size = 50"
      ],
      "metadata": {
        "id": "7azAGojuh2jv"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " # convert grayscale images to RGB\n",
        "def grayscale_to_rgb(images):\n",
        "  return np.repeat(images, 3, -1)"
      ],
      "metadata": {
        "id": "qtdRFiE0jb8h"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def extract_features(directory, sample_count):\n",
        "  conv_output_shape = convolution_base.output_shape[1:]\n",
        "  #features =np.zeros(shape =  (sample_count, 4, 4, 512))\n",
        "  labels = np.zeros(shape = (sample_count))\n",
        "  features =np.zeros(shape =  (sample_count, np.prod(conv_output_shape)))\n",
        "  generator = train_datagen.flow_from_directory(train_dir, target_size = (150, 150), batch_size = batch_size, class_mode = 'categorical', color_mode = 'grayscale')\n",
        "  i = 0\n",
        "  for input_batch, labels_batch in generator:\n",
        "    features_batch = convolution_base.predict(grayscale_to_rgb(input_batch))\n",
        "     # reshape the features_batch to have 3 channels\n",
        "    features_batch = np.repeat(features_batch, 3, axis=-1)\n",
        "    features[i * batch_size : (i +1)*batch_size] = features_batch.reshape(batch_size, -1)\n",
        "    labels[i*batch_size: (i + 1)*batch_size] = labels_batch\n",
        "    i += 1\n",
        "    if i * batch_size >= sample_count:\n",
        "      break\n",
        "    return features, labels\n"
      ],
      "metadata": {
        "id": "KSzSYX9ZiD6L"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#train_features, train_labels = extract_features(train_dir, 1100)\n",
        "#validation_features, validation_labels = extract_features(validation_dir, 458)\n",
        "\n"
      ],
      "metadata": {
        "id": "FDXoLk3QnwHy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize\n",
        "import matplotlib.pyplot as plt\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "val_loss = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "epochs = range(1, len(acc)+1)\n",
        "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend()\n",
        "plt.figure()\n",
        "plt.plot(epochs, loss, 'bo', 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": "nbVE07-xvmZQ"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1B20hgHIV5JGm6c51wmYtBhB3x8AZq1pI",
      "authorship_tag": "ABX9TyOdYGDsaDFkc/6yow2ZR4pX",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}