From 5427c85e8ca1b09c5e6b107c8c086e6bfedf0298 Mon Sep 17 00:00:00 2001
From: Aditi0102 <aditiagarwal1001@gmail.com>
Date: Sat, 27 Mar 2021 23:17:24 +0530
Subject: [PATCH] #12 code added

---
 Tree_Image_Classification.ipynb | 1000 +++++++++++++++++++++++++++++++
 1 file changed, 1000 insertions(+)
 create mode 100644 Tree_Image_Classification.ipynb

diff --git a/Tree_Image_Classification.ipynb b/Tree_Image_Classification.ipynb
new file mode 100644
index 0000000..3fd640b
--- /dev/null
+++ b/Tree_Image_Classification.ipynb
@@ -0,0 +1,1000 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Tree Image Classification",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eHu-Szr15RoN",
+        "outputId": "7e4163ff-29db-4e51-8458-ce10cc021756"
+      },
+      "source": [
+        "import os \n",
+        "from tensorflow.keras import layers\n",
+        "from tensorflow.keras import Model\n",
+        "\n",
+        "!wget --no-check-certificate \\\n",
+        " https://storage.googleapis.com/mledu-datasets/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5 \\\n",
+        "    -O /tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "--2021-03-18 03:20:28--  https://storage.googleapis.com/mledu-datasets/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
+            "Resolving storage.googleapis.com (storage.googleapis.com)... 74.125.20.128, 74.125.197.128, 74.125.142.128, ...\n",
+            "Connecting to storage.googleapis.com (storage.googleapis.com)|74.125.20.128|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 87910968 (84M) [application/x-hdf]\n",
+            "Saving to: ‘/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5’\n",
+            "\n",
+            "/tmp/inception_v3_w 100%[===================>]  83.84M   157MB/s    in 0.5s    \n",
+            "\n",
+            "2021-03-18 03:20:29 (157 MB/s) - ‘/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5’ saved [87910968/87910968]\n",
+            "\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yIv6Wf6s5xVx",
+        "outputId": "8e43985d-aa6b-465f-871d-f5269e8a8836"
+      },
+      "source": [
+        "from tensorflow.keras.applications.inception_v3 import InceptionV3\n",
+        "local_weights_file = '/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
+        "pre_trained_model = InceptionV3(input_shape=(150,150,3),\n",
+        "                                include_top = False,\n",
+        "                                weights = None)\n",
+        "pre_trained_model.load_weights(local_weights_file)\n",
+        "\n",
+        "for layer in pre_trained_model.layers:\n",
+        "  layer.trainable = False\n",
+        "\n",
+        "#pre_trained_model.summary()\n",
+        "\n",
+        "last_layer = pre_trained_model.get_layer('mixed7')\n",
+        "print('last layer output shape: ', last_layer.output_shape)\n",
+        "last_output = last_layer.output"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "last layer output shape:  (None, 7, 7, 768)\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "vt0TxrBWBrKZ"
+      },
+      "source": [
+        "from tensorflow.keras.optimizers import RMSprop\n",
+        "x = layers.Flatten()(last_output)\n",
+        "x = layers.Dense(1024, activation='relu')(x)\n",
+        "x = layers.Dropout(0.2)(x)\n",
+        "x = layers.Dense(4, activation='softmax')(x)\n",
+        "model = Model(pre_trained_model.input, x)\n",
+        "model.compile(loss='categorical_crossentropy',\n",
+        "              optimizer = RMSprop(lr=0.0001),\n",
+        "              metrics=['accuracy'])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bVwcSW-BQXFn",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6d8c6bcd-cd55-4203-b39c-88fdf60f120a"
+      },
+      "source": [
+        "!git clone https://github.com/Aditi0102/tree-image-dataset.git"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Cloning into 'tree-image-dataset'...\n",
+            "remote: Enumerating objects: 360, done.\u001b[K\n",
+            "remote: Counting objects: 100% (360/360), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (358/358), done.\u001b[K\n",
+            "remote: Total 360 (delta 0), reused 357 (delta 0), pack-reused 0\u001b[K\n",
+            "Receiving objects: 100% (360/360), 4.36 MiB | 3.68 MiB/s, done.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SyIPsBm4R--G",
+        "outputId": "730c7aed-a121-4782-e867-8fb193dd10a8"
+      },
+      "source": [
+        "!ls\n"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "sample_data  tree-image-dataset\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "cREyK1FWR_4v"
+      },
+      "source": [
+        "base_dir = '/content/tree-image-dataset'\n",
+        "train_dir = os.path.join(base_dir, 'training')\n",
+        "validation_dir = os.path.join(base_dir, 'validation')\n",
+        "\n",
+        "train_apples_dir = os.path.join(train_dir, 'apples')\n",
+        "train_bananas_dir = os.path.join(train_dir, 'bananas')\n",
+        "train_banyan_dir = os.path.join(train_dir, 'banyan')\n",
+        "train_pine_dir = os.path.join(train_dir, 'pine')\n",
+        "\n",
+        "validation_apples_dir = os.path.join(validation_dir, 'apples')\n",
+        "validation_bananas_dir = os.path.join(validation_dir, 'bananas')\n",
+        "validation_banyan_dir = os.path.join(validation_dir, 'banyan')\n",
+        "validation_pine_dir = os.path.join(validation_dir, 'pine')"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "2JIf3oymTCT5",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "96ef2678-aa3d-44f3-f03e-2a9ca43c7481"
+      },
+      "source": [
+        "train_apples_fnames = os.listdir(train_apples_dir)\n",
+        "train_bananas_fnames = os.listdir(train_bananas_dir)\n",
+        "train_banyan_fnames = os.listdir(train_banyan_dir)\n",
+        "train_pine_fnames = os.listdir(train_pine_dir)\n",
+        "\n",
+        "print(train_apples_fnames[:10])\n",
+        "print(train_bananas_fnames[:10])\n",
+        "print(train_banyan_fnames[:10])\n",
+        "print(train_pine_fnames[:10])"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "['apple57.jpg', 'apple37.jpg', 'apple23.jpg', 'apple10.jpg', 'apple18.jpg', 'apple2.jpg', 'apple17.jpg', 'apple59.jpg', 'apple34.jpg', 'apple22.jpg']\n",
+            "['banana5.jpg', 'banana62.jpg', 'banana31.jpg', 'banana69.jpg', 'banana56.jpg', 'banana53.jpg', 'banana25.jpg', 'banana57.jpg', 'banana4.jpg', 'banana44.jpg']\n",
+            "['banyan60.jpg', 'banyan38.jpg', 'banyan61.jpg', 'banyan34.jpg', 'banyan59.jpg', 'banyan58.jpg', 'banyan10.jpg', 'banyan31.jpg', 'banyan45.jpg', 'banyan62.jpg']\n",
+            "['pine16.jpg', 'pine7.jpg', 'pine46.jpg', 'pine8.jpg', 'pine22.jpg', 'pine40.jpg', 'pine24.jpg', 'pine5.jpg', 'pine49.jpg', 'pine32.jpg']\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jndKxTqLgBmq",
+        "outputId": "1916aa31-5eaa-44e4-efeb-da56ee3c5f0e"
+      },
+      "source": [
+        "print('total training apple images: ', len(os.listdir(train_apples_dir)))\n",
+        "print('total training banana images: ', len(os.listdir(train_bananas_dir)))\n",
+        "print('total training banyan images: ', len(os.listdir(train_banyan_dir)))\n",
+        "print('total training pine images: ', len(os.listdir(train_pine_dir)))\n",
+        "\n",
+        "print('total validation apple images :', len(os.listdir(validation_apples_dir)))\n",
+        "print('total validation banana images :', len(os.listdir(validation_bananas_dir)))\n",
+        "print('total validation banyan images :', len(os.listdir(validation_banyan_dir)))\n",
+        "print('total validation pine images :', len(os.listdir(validation_pine_dir)))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "total training apple images:  58\n",
+            "total training banana images:  96\n",
+            "total training banyan images:  66\n",
+            "total training pine images:  75\n",
+            "total validation apple images : 14\n",
+            "total validation banana images : 24\n",
+            "total validation banyan images : 16\n",
+            "total validation pine images : 19\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fmbsNyMmzErj",
+        "outputId": "7343ef80-5720-44df-ee5f-f5b3fd718d8c"
+      },
+      "source": [
+        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+        "train_datagen = ImageDataGenerator(\n",
+        "    rescale = 1./255.,\n",
+        "    rotation_range = 40,\n",
+        "    width_shift_range = 0.2,\n",
+        "    height_shift_range = 0.2,\n",
+        "    shear_range = 0.2,\n",
+        "    zoom_range = 0.2,\n",
+        "    horizontal_flip = True\n",
+        "   )\n",
+        "\n",
+        "validation_datagen = ImageDataGenerator(rescale=1/255)\n",
+        "\n",
+        "train_generator = train_datagen.flow_from_directory(\n",
+        "    train_dir,\n",
+        "    target_size=(150,150),\n",
+        "    batch_size= 5,\n",
+        "    class_mode = 'categorical'\n",
+        ")\n",
+        "validation_generator = validation_datagen.flow_from_directory(\n",
+        "    validation_dir,\n",
+        "    target_size=(150,150),\n",
+        "    batch_size=5,\n",
+        "    class_mode='categorical'\n",
+        ")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Found 295 images belonging to 4 classes.\n",
+            "Found 73 images belonging to 4 classes.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DtukZv3V1Lq8",
+        "outputId": "68b77cc3-ef91-42eb-eb69-92ed9b821a25"
+      },
+      "source": [
+        "history = model.fit(\n",
+        "    train_generator,\n",
+        "    steps_per_epoch=59,\n",
+        "    epochs=20,\n",
+        "    validation_data = validation_generator,\n",
+        "    validation_steps = 14,\n",
+        "    verbose = 1\n",
+        ")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/20\n",
+            "59/59 [==============================] - 36s 58ms/step - loss: 1.3112 - accuracy: 0.5459 - val_loss: 0.3153 - val_accuracy: 0.8857\n",
+            "Epoch 2/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.5177 - accuracy: 0.8042 - val_loss: 0.1308 - val_accuracy: 0.9429\n",
+            "Epoch 3/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.3201 - accuracy: 0.9040 - val_loss: 0.2125 - val_accuracy: 0.9143\n",
+            "Epoch 4/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.4484 - accuracy: 0.8808 - val_loss: 0.1839 - val_accuracy: 0.9286\n",
+            "Epoch 5/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.2398 - accuracy: 0.8962 - val_loss: 0.5529 - val_accuracy: 0.8714\n",
+            "Epoch 6/20\n",
+            "59/59 [==============================] - 2s 40ms/step - loss: 0.3018 - accuracy: 0.9151 - val_loss: 0.1495 - val_accuracy: 0.9571\n",
+            "Epoch 7/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1824 - accuracy: 0.9340 - val_loss: 0.0785 - val_accuracy: 0.9714\n",
+            "Epoch 8/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1922 - accuracy: 0.9410 - val_loss: 0.1675 - val_accuracy: 0.9286\n",
+            "Epoch 9/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1726 - accuracy: 0.9191 - val_loss: 0.1328 - val_accuracy: 0.9429\n",
+            "Epoch 10/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1775 - accuracy: 0.9285 - val_loss: 0.0345 - val_accuracy: 0.9857\n",
+            "Epoch 11/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.2827 - accuracy: 0.8994 - val_loss: 0.0765 - val_accuracy: 0.9714\n",
+            "Epoch 12/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.2754 - accuracy: 0.9287 - val_loss: 0.0500 - val_accuracy: 0.9714\n",
+            "Epoch 13/20\n",
+            "59/59 [==============================] - 3s 45ms/step - loss: 0.1227 - accuracy: 0.9497 - val_loss: 0.1306 - val_accuracy: 0.9714\n",
+            "Epoch 14/20\n",
+            "59/59 [==============================] - 3s 42ms/step - loss: 0.1515 - accuracy: 0.9606 - val_loss: 0.0876 - val_accuracy: 0.9857\n",
+            "Epoch 15/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.2003 - accuracy: 0.9501 - val_loss: 0.1882 - val_accuracy: 0.9286\n",
+            "Epoch 16/20\n",
+            "59/59 [==============================] - 2s 40ms/step - loss: 0.1174 - accuracy: 0.9523 - val_loss: 0.2706 - val_accuracy: 0.9714\n",
+            "Epoch 17/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1194 - accuracy: 0.9561 - val_loss: 0.4416 - val_accuracy: 0.8857\n",
+            "Epoch 18/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1180 - accuracy: 0.9451 - val_loss: 0.3658 - val_accuracy: 0.9000\n",
+            "Epoch 19/20\n",
+            "59/59 [==============================] - 3s 44ms/step - loss: 0.3187 - accuracy: 0.9295 - val_loss: 0.1666 - val_accuracy: 0.9571\n",
+            "Epoch 20/20\n",
+            "59/59 [==============================] - 2s 41ms/step - loss: 0.1876 - accuracy: 0.9525 - val_loss: 0.3592 - val_accuracy: 0.8857\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 545
+        },
+        "id": "qfq_7uh42pfz",
+        "outputId": "7dc1f10f-9003-4847-ea17-7f6733e42ad8"
+      },
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "acc = history.history['accuracy']\n",
+        "val_acc = history.history['val_accuracy']\n",
+        "loss = history.history['loss']\n",
+        "val_loss = history.history['val_loss']\n",
+        "\n",
+        "epochs = range(len(acc))\n",
+        "\n",
+        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
+        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
+        "plt.title('Training and validation accuracy')\n",
+        "\n",
+        "plt.figure()\n",
+        "\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",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hwiVOS8JD_9O",
+        "outputId": "8b8a7414-20f6-4306-a84a-b781d405b294"
+      },
+      "source": [
+        "import time\n",
+        "t = time.time()\n",
+        "export_path_keras = \"./{}.h5\".format(int(t))\n",
+        "print(export_path_keras)\n",
+        "\n",
+        "model.save(export_path_keras)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "./1616037769.h5\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "xompEj6sLIV9"
+      },
+      "source": [
+        "from tensorflow.keras.applications.vgg16 import VGG16\n",
+        "\n",
+        "base_model = VGG16(input_shape = (150, 150, 3), # Shape of our images\n",
+        "include_top = False, # Leave out the last fully connected layer\n",
+        "weights = 'imagenet')"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "msbrzP8TLVPV"
+      },
+      "source": [
+        "for layer in base_model.layers:\n",
+        "    layer.trainable = False"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "B-w55x8zW_p1"
+      },
+      "source": [
+        "import tensorflow as tf\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "iJNqMjMkLuf4"
+      },
+      "source": [
+        "\n",
+        "# Flatten the output layer to 1 dimension\n",
+        "x = layers.Flatten()(base_model.output)\n",
+        "\n",
+        "x = layers.Dense(1024, activation='relu')(x)\n",
+        "\n",
+        "\n",
+        "x = layers.Dropout(0.2)(x)\n",
+        "\n",
+        "x = layers.Dense(4, activation='softmax')(x)\n",
+        "\n",
+        "model = tf.keras.models.Model(base_model.input, x)\n",
+        "\n",
+        "model.compile(optimizer = tf.keras.optimizers.RMSprop(lr=0.0001), loss = 'categorical_crossentropy',metrics = ['accuracy'])"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7GeVZAKPMF2z",
+        "outputId": "bfa73f74-a07b-410c-aaf6-1931426b8183"
+      },
+      "source": [
+        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+        "train_datagen = ImageDataGenerator(\n",
+        "    rescale = 1./255.,\n",
+        "    rotation_range = 40,\n",
+        "    width_shift_range = 0.2,\n",
+        "    height_shift_range = 0.2,\n",
+        "    shear_range = 0.2,\n",
+        "    zoom_range = 0.2,\n",
+        "    horizontal_flip = True\n",
+        "   )\n",
+        "\n",
+        "validation_datagen = ImageDataGenerator(rescale=1/255)\n",
+        "\n",
+        "train_generator = train_datagen.flow_from_directory(\n",
+        "    train_dir,\n",
+        "    target_size=(150,150),\n",
+        "    batch_size= 5,\n",
+        "    class_mode = 'categorical'\n",
+        ")\n",
+        "validation_generator = validation_datagen.flow_from_directory(\n",
+        "    validation_dir,\n",
+        "    target_size=(150,150),\n",
+        "    batch_size=5,\n",
+        "    class_mode='categorical'\n",
+        ")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Found 295 images belonging to 4 classes.\n",
+            "Found 73 images belonging to 4 classes.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9r-zB8qjMQGu",
+        "outputId": "31323f9f-116e-444d-f19f-bd25e299fca5"
+      },
+      "source": [
+        "history = model.fit(\n",
+        "    train_generator,\n",
+        "    steps_per_epoch=59,\n",
+        "    epochs=20,\n",
+        "    validation_data = validation_generator,\n",
+        "    validation_steps = 14,\n",
+        "    verbose = 1)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/20\n",
+            "59/59 [==============================] - 3s 41ms/step - loss: 1.6569 - accuracy: 0.4222 - val_loss: 0.9494 - val_accuracy: 0.5143\n",
+            "Epoch 2/20\n",
+            "59/59 [==============================] - 2s 40ms/step - loss: 0.7428 - accuracy: 0.6749 - val_loss: 0.4864 - val_accuracy: 0.8000\n",
+            "Epoch 3/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.5396 - accuracy: 0.7911 - val_loss: 0.4689 - val_accuracy: 0.8429\n",
+            "Epoch 4/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.4179 - accuracy: 0.8662 - val_loss: 0.3800 - val_accuracy: 0.8714\n",
+            "Epoch 5/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.4736 - accuracy: 0.8318 - val_loss: 0.4063 - val_accuracy: 0.8143\n",
+            "Epoch 6/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.4612 - accuracy: 0.8371 - val_loss: 0.3703 - val_accuracy: 0.9000\n",
+            "Epoch 7/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.3678 - accuracy: 0.8807 - val_loss: 0.3587 - val_accuracy: 0.8429\n",
+            "Epoch 8/20\n",
+            "59/59 [==============================] - 2s 39ms/step - loss: 0.3409 - accuracy: 0.8948 - val_loss: 0.2878 - val_accuracy: 0.9000\n",
+            "Epoch 9/20\n",
+            "59/59 [==============================] - 2s 38ms/step - loss: 0.3353 - accuracy: 0.8829 - val_loss: 0.4014 - val_accuracy: 0.8286\n",
+            "Epoch 10/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.3004 - accuracy: 0.8806 - val_loss: 0.4250 - val_accuracy: 0.8143\n",
+            "Epoch 11/20\n",
+            "59/59 [==============================] - 2s 38ms/step - loss: 0.3312 - accuracy: 0.8766 - val_loss: 0.2311 - val_accuracy: 0.9429\n",
+            "Epoch 12/20\n",
+            "59/59 [==============================] - 2s 38ms/step - loss: 0.3422 - accuracy: 0.8408 - val_loss: 0.2898 - val_accuracy: 0.9000\n",
+            "Epoch 13/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.1898 - accuracy: 0.9248 - val_loss: 0.5424 - val_accuracy: 0.8429\n",
+            "Epoch 14/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.3303 - accuracy: 0.8770 - val_loss: 0.2191 - val_accuracy: 0.9000\n",
+            "Epoch 15/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.3215 - accuracy: 0.9021 - val_loss: 0.2327 - val_accuracy: 0.9429\n",
+            "Epoch 16/20\n",
+            "59/59 [==============================] - 2s 38ms/step - loss: 0.2612 - accuracy: 0.8863 - val_loss: 0.1646 - val_accuracy: 0.9429\n",
+            "Epoch 17/20\n",
+            "59/59 [==============================] - 2s 38ms/step - loss: 0.2723 - accuracy: 0.8803 - val_loss: 0.2353 - val_accuracy: 0.9000\n",
+            "Epoch 18/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.2262 - accuracy: 0.8854 - val_loss: 0.4634 - val_accuracy: 0.8143\n",
+            "Epoch 19/20\n",
+            "59/59 [==============================] - 2s 37ms/step - loss: 0.2401 - accuracy: 0.9183 - val_loss: 0.2033 - val_accuracy: 0.9286\n",
+            "Epoch 20/20\n",
+            "59/59 [==============================] - 2s 38ms/step - loss: 0.1675 - accuracy: 0.9436 - val_loss: 0.1318 - val_accuracy: 0.9714\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 545
+        },
+        "id": "C5CiRXuSM2zx",
+        "outputId": "e138e0e6-e2a1-4102-d748-255bd2240429"
+      },
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "acc = history.history['accuracy']\n",
+        "val_acc = history.history['val_accuracy']\n",
+        "loss = history.history['loss']\n",
+        "val_loss = history.history['val_loss']\n",
+        "\n",
+        "epochs = range(len(acc))\n",
+        "\n",
+        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
+        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
+        "plt.title('Training and validation accuracy')\n",
+        "\n",
+        "plt.figure()\n",
+        "\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",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2dd5hUVdKH32JIEiVKTpKDMEMyCyYQXFhEVMSAAQTTmlZR14RhdT9XXVfRNScWVFQUFVExsWACBJSgBEFGUMk5TKjvj+qBZpie6ZnpMN1T7/P00933nntO9e3u3z23Tp06oqo4juM4iU+ZeBvgOI7jRAYXdMdxnCTBBd1xHCdJcEF3HMdJElzQHcdxkgQXdMdxnCTBBd3JExGZKiIXRrpsPBGRlSJychTqVRFpGXj9pIjcFk7ZIrQzTEQ+LKqd+dTbS0TSI12vE3vKxtsAJ3KIyPagt5WAPUBW4P1lqjo+3LpU9bRolE12VHVUJOoRkWbAz0A5Vc0M1D0eCPs7dEofLuhJhKpWyXktIiuBS1X149zlRKRsjkg4jpM8uMulFJBzSy0iN4nIb8DzIlJDRN4VkXUisinwulHQMZ+JyKWB18NF5H8i8mCg7M8icloRyzYXkS9EZJuIfCwij4vIKyHsDsfGu0VkZqC+D0WkdtD+80VklYhsEJFb8zk/PUXkNxFJCdo2SEQWBF73EJEvRWSziKwVkcdEpHyIul4QkXuC3v81cMwaEbk4V9n+IvKdiGwVkdUicmfQ7i8Cz5tFZLuIHJVzboOOP1pEvhWRLYHno8M9N/khIu0Cx28WkYUiMiBoXz8RWRSo81cRuSGwvXbg+9ksIhtFZIaIuL7EGD/hpYd6QE2gKTAS++6fD7xvAuwCHsvn+J7Aj0Bt4B/AsyIiRSj7X+AboBZwJ3B+Pm2GY+O5wEVAXaA8kCMw7YEnAvU3CLTXiDxQ1a+BHcCJuer9b+B1FnBt4PMcBZwEXJ6P3QRs6Buw5xSgFZDbf78DuAA4FOgPjBaRPwf2HR94PlRVq6jql7nqrgm8Bzwa+GwPAe+JSK1cn+Ggc1OAzeWAKcCHgeOuAsaLSJtAkWcx911VoCPwSWD79UA6UAc4DLgF8LwiMcYFvfSQDdyhqntUdZeqblDVN1R1p6puA+4FTsjn+FWq+rSqZgEvAvWxP27YZUWkCdAduF1V96rq/4B3QjUYpo3Pq+pPqroLeA3oEth+JvCuqn6hqnuA2wLnIBQTgKEAIlIV6BfYhqrOUdWvVDVTVVcC/8nDjrw4K2DfD6q6A7uABX++z1T1e1XNVtUFgfbCqRfsArBUVV8O2DUBWAL8KahMqHOTH0cCVYD7A9/RJ8C7BM4NkAG0F5FqqrpJVecGba8PNFXVDFWdoZ4oKua4oJce1qnq7pw3IlJJRP4TcElsxW7xDw12O+Tit5wXqroz8LJKIcs2ADYGbQNYHcrgMG38Lej1ziCbGgTXHRDUDaHawnrjZ4hIBeAMYK6qrgrY0TrgTvgtYMd9WG+9IA6wAViV6/P1FJFPAy6lLcCoMOvNqXtVrm2rgIZB70OdmwJtVtXgi19wvYOxi90qEflcRI4KbP8/YBnwoYisEJEx4X0MJ5K4oJcecveWrgfaAD1VtRr7b/FDuVEiwVqgpohUCtrWOJ/yxbFxbXDdgTZrhSqsqosw4TqNA90tYK6bJUCrgB23FMUGzG0UzH+xO5TGqlodeDKo3oJ6t2swV1QwTYBfw7CroHob5/J/76tXVb9V1YGYO2Yy1vNHVbep6vWq2gIYAFwnIicV0xankLigl16qYj7pzQF/7B3RbjDQ450N3Cki5QO9uz/lc0hxbJwEnC4ixwYGMMdS8O/9v8BfsAvH67ns2ApsF5G2wOgwbXgNGC4i7QMXlNz2V8XuWHaLSA/sQpLDOsxF1CJE3e8DrUXkXBEpKyJnA+0x90hx+Brrzd8oIuVEpBf2HU0MfGfDRKS6qmZg5yQbQEROF5GWgbGSLdi4Q34uLicKuKCXXh4BDgHWA18BH8So3WHYwOIG4B7gVSxePi+KbKOqLgSuwER6LbAJG7TLjxwf9iequj5o+w2Y2G4Dng7YHI4NUwOf4RPMHfFJriKXA2NFZBtwO4HebuDYndiYwcxA5MiRuereAJyO3cVsAG4ETs9ld6FR1b2YgJ+GnfdxwAWquiRQ5HxgZcD1NAr7PsEGfT8GtgNfAuNU9dPi2OIUHvFxCyeeiMirwBJVjfodguMkO95Dd2KKiHQXkcNFpEwgrG8g5ot1HKeY+ExRJ9bUA97EBijTgdGq+l18TXKc5MBdLo7jOEmCu1wcx3GShLi5XGrXrq3NmjWLV/OO4zgJyZw5c9arap289sVN0Js1a8bs2bPj1bzjOE5CIiK5Zwjvw10ujuM4SYILuuM4TpLggu44jpMkeBy64yQ5GRkZpKens3v37oILOyWGihUr0qhRI8qVKxf2MS7ojpPkpKenU7VqVZo1a0boNUmckoSqsmHDBtLT02nevHnYx7nLxXGSnN27d1OrVi0X8wRCRKhVq1ah76pc0B2nFOBinngU5TtLPEH/4Qe46SbYujXeljiO45QoEk/Qf/4Z/vEPWLQo3pY4jhMGGzZsoEuXLnTp0oV69erRsGHDfe/37t2b77GzZ8/m6quvLrCNo48+OiK2fvbZZ5x++ukRqSseJN6gaIcO9vzDD3DkkfmXdRwn7tSqVYt58+YBcOedd1KlShVuuOGGffszMzMpWzZvKerWrRvdunUrsI1Zs2ZFxtgEJ/F66M2aQaVKsHBhvC1xHKeIDB8+nFGjRtGzZ09uvPFGvvnmG4466ihSU1M5+uij+fHHH4EDe8x33nknF198Mb169aJFixY8+uij++qrUqXKvvK9evXizDPPpG3btgwbNoycjLLvv/8+bdu2pWvXrlx99dWF6olPmDCBTp060bFjR2666SYAsrKyGD58OB07dqRTp048/PDDADz66KO0b9+eI444gnPOOaf4J6sQJF4PvUwZaN/eeuiO4xSOa66BQG85YnTpAo88UujD0tPTmTVrFikpKWzdupUZM2ZQtmxZPv74Y2655RbeeOONg45ZsmQJn376Kdu2baNNmzaMHj36oDjt7777joULF9KgQQOOOeYYZs6cSbdu3bjsssv44osvaN68OUOHDg3bzjVr1nDTTTcxZ84catSowamnnsrkyZNp3Lgxv/76Kz8EtGjz5s0A3H///fz8889UqFBh37ZYUWAPXUSeE5E/RCRPBQ0sGrtARL4XkVki0jnyZuaiY0fvoTtOgjNkyBBSUlIA2LJlC0OGDKFjx45ce+21LAzx/+7fvz8VKlSgdu3a1K1bl99///2gMj169KBRo0aUKVOGLl26sHLlSpYsWUKLFi32xXQXRtC//fZbevXqRZ06dShbtizDhg3jiy++oEWLFqxYsYKrrrqKDz74gGrVqgFwxBFHMGzYMF555ZWQrqRoEU5rLwCPAS+F2P8zcIKqbhKR04CngJ6RMS8EHTrACy/Axo1Qs2ZUm3KcpKIIPeloUbly5X2vb7vtNnr37s1bb73FypUr6dWrV57HVKhQYd/rlJQUMjMzi1QmEtSoUYP58+czbdo0nnzySV577TWee+453nvvPb744gumTJnCvffey/fffx8zYS+wh66qXwAb89k/S1U3Bd5+BTSKkG2hyRkY9V664yQFW7ZsoWHDhgC88MILEa+/TZs2rFixgpUrVwLw6quvhn1sjx49+Pzzz1m/fj1ZWVlMmDCBE044gfXr15Odnc3gwYO55557mDt3LtnZ2axevZrevXvzwAMPsGXLFrZv3x7xzxOKSF82LgGmRrjOg+nY0Z4XLoTjjot6c47jRJcbb7yRCy+8kHvuuYf+/ftHvP5DDjmEcePG0bdvXypXrkz37t1Dlp0+fTqNGu3vl77++uvcf//99O7dG1Wlf//+DBw4kPnz53PRRReRnZ0NwN///neysrI477zz2LJlC6rK1VdfzaGHHhrxzxOKsNYUFZFmwLuq2jGfMr2BccCxqrohRJmRwEiAJk2adF21KmSe9vxRhUMPhfPPh8ceK1odjlNKWLx4Me3atYu3GXFn+/btVKlSBVXliiuuoFWrVlx77bXxNitf8vruRGSOquYZyxmRsEUROQJ4BhgYSswBVPUpVe2mqt3q1MlzBaVwG7RIF3e5OI4TJk8//TRdunShQ4cObNmyhcsuuyzeJkWcYrtcRKQJ8CZwvqr+VHyTwqRjR3j77Zg15zhOYnPttdeW+B55cQknbHEC8CXQRkTSReQSERklIqMCRW4HagHjRGSeiMRmodAOHWDdOvjjj5g05ziOU9IpsIeuqvkGbKrqpcClEbMoXIIHRuvWjXnzjuM4JY3Em/qfQ3BOF8dxHCeBBb1ePahRwwdGHcdxAiSuoIt4CgDHSQB69+7NtGnTDtj2yCOPMHr06JDH9OrVi9mzbTiuX79+eeZEufPOO3nwwQfzbXvy5MksCkq1ffvtt/Pxxx8Xxvw8KalpdhNX0MHcLj/8YHHpjuOUSIYOHcrEiRMP2DZx4sSw86m8//77RZ6ck1vQx44dy8knn1ykuhKBxBb0jh1h82ZYuzbeljiOE4IzzzyT9957b99iFitXrmTNmjUcd9xxjB49mm7dutGhQwfuuOOOPI9v1qwZ69evB+Dee++ldevWHHvssftS7ILFmHfv3p3OnTszePBgdu7cyaxZs3jnnXf461//SpcuXVi+fDnDhw9n0qRJgM0ITU1NpVOnTlx88cXs2bNnX3t33HEHaWlpdOrUiSVLloT9WeOdZjfx0ucGEzww2qBBfG1xnAQgHtlza9asSY8ePZg6dSoDBw5k4sSJnHXWWYgI9957LzVr1iQrK4uTTjqJBQsWcMQRR+RZz5w5c5g4cSLz5s0jMzOTtLQ0unbtCsAZZ5zBiBEjAPjb3/7Gs88+y1VXXcWAAQM4/fTTOfPMMw+oa/fu3QwfPpzp06fTunVrLrjgAp544gmuueYaAGrXrs3cuXMZN24cDz74IM8880yB56EkpNlN7B66J+lynIQg2O0S7G557bXXSEtLIzU1lYULFx7gHsnNjBkzGDRoEJUqVaJatWoMGDBg374ffviB4447jk6dOjF+/PiQ6Xdz+PHHH2nevDmtW7cG4MILL+SLL77Yt/+MM84AoGvXrvsSehVESUizm9g99Dp1LAbdBd1xwiJe2XMHDhzItddey9y5c9m5cyddu3bl559/5sEHH+Tbb7+lRo0aDB8+nN27dxep/uHDhzN58mQ6d+7MCy+8wGeffVYse3NS8EYi/W4s0+wmdg8d9g+MOo5TYqlSpQq9e/fm4osv3tc737p1K5UrV6Z69er8/vvvTJ2af6LW448/nsmTJ7Nr1y62bdvGlClT9u3btm0b9evXJyMjg/Hjx+/bXrVqVbZt23ZQXW3atGHlypUsW7YMgJdffpkTTjihWJ+xJKTZTeweOtjA6PPPW6SLSLytcRwnBEOHDmXQoEH7XC+dO3cmNTWVtm3b0rhxY4455ph8j09LS+Pss8+mc+fO1K1b94AUuHfffTc9e/akTp069OzZc5+In3POOYwYMYJHH31032AoQMWKFXn++ecZMmQImZmZdO/enVGjRh3UZn6UxDS7YaXPjQbdunXTnDjTYvGf/8CoUbByJTRtWvz6HCfJ8PS5iUtc0ufGFR8YdRzHAVzQHcdxkobEF/QaNSwG3QdGHSck8XKtOkWnKN9Z4gs6WC/de+iOkycVK1Zkw4YNLuoJhKqyYcMGKlasWKjjEj/KBSzS5cknITsbyiTHNcpxIkWjRo1IT09n3bp18TbFKQQVK1Y8IIomHJJD0Dt0gF274Oef4fDD422N45QoypUrR/PmzeNthhMDkqM7G7x6keM4TiklOQS9fXt79oFRx3FKMckh6FWrQpMm3kN3HKdUkxyCDr56keM4pZ7kEfQOHWDxYihmZjTHcZxEJXkEvWNH2LsXli+PtyWO4zhxIXkEPXj1IsdxnFJI8gh6u3aWPtf96I7jlFKSR9ArVYIWLVzQHccptSSPoIOvXuQ4TqmmQEEXkedE5A8RyVMpxXhURJaJyAIRSYu8mWHSoQP89JMNjjqO45QywumhvwD0zWf/aUCrwGMk8ETxzSoiHTta2OJPP8XNBMdxnHhRoKCr6hfAxnyKDAReUuMr4FARqR8pAwuFL3bhOE4pJhI+9IbA6qD36YFtByEiI0VktojMjkoqzzZtICXFBd1xnFJJTAdFVfUpVe2mqt3q1KkT+QYqVoSWLX1g1HGcUkkkBP1XoHHQ+0aBbfHBVy9yHKeUEglBfwe4IBDtciSwRVXXRqDeotGxIyxbBrt3x80Ex3GceFDgikUiMgHoBdQWkXTgDqAcgKo+CbwP9AOWATuBi6JlbFh06GBL0S1ZAl26xNUUx3GcWFKgoKvq0AL2K3BFxCwqLsGrF7mgO45TikiumaIArVpBuXI+MOo4Tqkj+QS9XDlo3doHRh3HKXUknKAvXgx33AE7duRTqGNH76E7jlPqSDhBX7oUxo6FBQvyKdShA/z8cwGq7ziOk1wknKCnptrz3Ln5FMoZGF28OOr2OI7jlBQSTtAbNYLatQsQdF+9yHGcUkjCCboIpKUVIOiHHw4VKvjAqOM4pYqEE3QwQV+4EPbsCVEgJcWWpPMeuuM4pYiEFPTUVMjIKKAD7jldHMcpZSSkoKcF1kQq0I++ejVs3RoTmxzHceJNQgp6ixZQrVqYkS7eS3ccp5SQkIJepoy5Xb77Lp9CvnqR4ziljIQUdDBBnz/flhDNk2bNoFIlHxh1HKfUkLCCnpYGu3bBjz+GKFCmDLRv7z10x3FKDQkt6BCG28UF3XGcUkLCCnqbNraEaIEDo2vXwsaNMbPLcRwnXiSsoJctC507h5kCwHvpjuOUAhJW0MHcLt99ZyvO5UlO6KIPjDqOUwpIeEHfutUy5eZJo0YWsO49dMdxSgEJLegFptIV8UgXx3FKDQkt6B07mi+9wIFRd7k4jlMKSGhBr1DB9LrAgdH16+GPP2Jml+M4TjxIaEGH/SkAVEMU8JwujuOUEhJe0NPSYN06+PXXEAV89SLHcUoJSSHokI/bpV49qFHDe+iO4yQ9CS/onTtbMEvIFAAiPjDqOE6pIOEFvXJlSwNQ4MDowoX5ONodx3ESn7AEXUT6isiPIrJMRMbksb+JiHwqIt+JyAIR6Rd5U0NT4KLRHTrA5s2W18VxHCdJKVDQRSQFeBw4DWgPDBWR9rmK/Q14TVVTgXOAcZE2ND/S0iA93QZH88RTADiOUwoIp4feA1imqitUdS8wERiYq4wC1QKvqwNrImdiweTMGA3pR/ckXY7jlALCEfSGwOqg9+mBbcHcCZwnIunA+8BVeVUkIiNFZLaIzF4XsjtdeApMAVCnDtSt6z10x3GSmkgNig4FXlDVRkA/4GUROahuVX1KVbuparc6depEqGmLSmzePMyBUcdxnCQlHEH/FWgc9L5RYFswlwCvAajql0BFoHYkDAyXsAZGPdLFcZwkJhxB/xZoJSLNRaQ8Nuj5Tq4yvwAnAYhIO0zQI+dTCYPUVFi+HLZsCVGgY0fYvh1++SWWZjmO48SMAgVdVTOBK4FpwGIsmmWhiIwVkQGBYtcDI0RkPjABGK4a265wzozRefNCFPCBUcdxkpyy4RRS1fexwc7gbbcHvV4EHBNZ0wpHcAqAE07Io0BwTpd+MQ2TdxzHiQkJP1M0h8MOg/r18wldrFEDGjTwHrrjOElL0gg6FGJg1HEcJwlJOkFfvBh27gxRoGNHWLQon1WlHcdxEpekE/TsbFiwIESBDh1g1658VpV2HMdJXJJK0MNOAeAzRh3HSUKSStCbNIGaNfPxo7cP5BRzP7rjOElIUgm6SAEDo9Wqmeq7oDuOk4QklaCDCfr338PevSEK+OpFjuMkKUkn6KmpkJFhwSx50qEDLFkCmZkxtctxHCfaJJ2gF7hodMeO1n1/5pmY2eQ4jhMLkk7QW7aEKlXyEfQzzoDevWH0aLjoonyC1h3HcRKLpBP0MmWgS5d8QherVIGPPoLbb4cXX4QePWw2kuM4ToKTdIIO5naZNw+yskIUSEmBu+6CDz6AP/6A7t1h/PiY2ug4jhNpklbQd+6En34qoOCpp1pXPi0NzjsPLrvMZpI6juMkIEkr6FBAoq4cGjaETz6BMWPgqafgqKNg6dKo2uc4jhMNklLQ27aFChXy8aPnpmxZ+Pvf4b33YPVq6NoVXn89qjY6juNEmqQU9HLl4IgjwuyhB9Ovn10FOnSAs86Cq66CPXuiYqPjOE6kSUpBh/0pAAq9EF6TJvD553DddfDYY3DssZ6d0XGchCBpBT011RaMLpIWly8P//wnvPWW+dNTU2Hy5Ijb6DiOE0mSVtBzBkbD9qPnxZ//bBW0agWDBsH111teAcdxnBJI0gp6p04Wbl5oP3pumjeH//0PrrwSHnoIjj8efvklIjY6juNEkqQV9IoVbWyz2IIOFjLz73/Da69Z6t3UVM/Y6DhOiSNpBR1Md4s0MBqKIUNgzhzzsQ8aBJs3R6hix3Gc4pPUgp6WZjP7166NYKWtWlmM+sqVcP75vuC04zglhqQXdIiQ2yWYY4+Fhx+Gd9+Fe+6JcOWO4zhFI6kFvXNnW5Yu4oIOcMUV1kO/806bYeo4jhNnwhJ0EekrIj+KyDIRGROizFkiskhEForIfyNrZtGoWtU8JMUKXQyFCDz5pF01zjsPli2LQiOO4zjhU6Cgi0gK8DhwGtAeGCoi7XOVaQXcDByjqh2Aa6Jga5HId9Ho4lKpErz5piVhP+MM2LEjSg05juMUTDg99B7AMlVdoap7gYnAwFxlRgCPq+omAFX9I7JmFp20NAsbX78+Sg00bw4TJlgY46WXRjCkxnEcp3CEI+gNgdVB79MD24JpDbQWkZki8pWI9I2UgcUlNdWeo+J2yeHUU+Hee2HiRHjkkSg25DiOE5pIDYqWBVoBvYChwNMicmjuQiIyUkRmi8jsdevWRajp/ImJoIPlUx80CP76V/jssyg35jiOczDhCPqvQOOg940C24JJB95R1QxV/Rn4CRP4A1DVp1S1m6p2q1OnTlFtLhS1akHTplH0o+cgAi+8YKtUn3UWpKdHuUHHcZwDCUfQvwVaiUhzESkPnAO8k6vMZKx3jojUxlwwKyJoZ7GI6sBoMNWqWYbGXbtg8GDPpe44TkwpUNBVNRO4EpgGLAZeU9WFIjJWRAYEik0DNojIIuBT4K+quiFaRheW1FTLgrt1awwaa9cOXnoJvvnGFshwHMeJEWXDKaSq7wPv59p2e9BrBa4LPEocOTNG58+H446LQYODBsHNN9uydt27w4gRMWjUcZzSTlLPFM0haikA8uPuu+GUUyzt7jffxLBhx3FKK6VC0OvXh8MOi7Ggp6RYfHr9+uZP/6PEhOY7jpOklApBB+ulRz10MTe1atkg6fr1cPbZkJkZYwMcxylNlCpBX7TIAlBiSmoqPPWUxabfdFOMG3ccpzRRqgQ9Kwu+/z4OjZ9//v4l7CZOjIMBTrKwcaMFUn38cbwtcUoipUbQc2aMxtSPHsw//wnHHAOXXBKnq4qTDLz6KixZAi+/HG9LnJJIqRH0Zs3g0EPj4EfPoXx5W+moWjULa5w2zW4ZHKcQjB9vzx9+6HngnIMpNYIuEsMZo6GoXx/eeMPWIu3bFxo3ttwv3mN3wmDlSpg50xY//+03WLAg3hY5JY1SI+hgbpcFCyAjI45GHH00/PqrCXuPHpad8YgjzLiHH7Z/quPkwX8Dy8Y8/bQ9T5sWP1uckkmpEvS0NNi7FxYvjrMhFSrYghiTJ8OaNfDvf0O5cnDdddCoEfTvb87SmIfkOCUVVXO3HHssHHUUdOrkgu4cTKkTdIiz2yU3dersn026aBHceKPdRpxzDtSrZ2kDZsyA7Ox4W+rEkfnz7ecxbJi979PHfhbbt8fXLqdkUaoEvVUrqFy5hAl6MO3awX33mbN0+nQbPJ0wAY4/3tLy3nGHr11aShk/HsqWhSFD7H2fPuY69NT7TjClStBTUmxN5xIr6DmkpMCJJ1p+9d9/txi1li0tP0yrVnbPfc898PXXPvu0FJCVZf7z006zycdgrpdDDnG3i3MgpUrQwdwu8+YlkAejcmU47zyLU/vlF3jgAcuzftttcOSRULu2+ePHjYOffvJYtiTk889tqOW88/Zvq1gRevVyQXcOpFQK+o4dFlRyySXw+OPw5Ze2rcTTqJH52OfOtWRfEyfCmWfCnDlwxRXQpo0F3F9yie3zhGBJwfjxULUq/OlPB27v29fy/K8oMUvJOPFGNE49um7duuns2bNj3u62bdbJ/fZb08X16217mTLQtq0Jfs6jSxeoXj3mJhYeVVi+HD76yOaEf/KJxbqD+ZhOOQVOPtmSwVeqFF9bnUKxe7dlCh00yDxwwfz4o/1mx42D0aPjYp4TB0Rkjqp2y3NfaRP0YFRt6c+5cw98rFmzv0zLlgeKfGqqeTlKNFlZ1mv/+GMT+VmzLF6zfHlLP9Cnj62m5OJe4nnjDbsJ+/BDuy4HowrNm1vHY/Lk+NjnxB4X9ELy22+WIuC77/aL/M8/79/fsqXdBvfoET8bC8WOHfC//+3vwc+fb8L+7ruWD8EpsZxxhrkE09NtrDw3l11mgVAbNthUBif5yU/QS50PPRzq1bOIgltugUmTzEe5YYNFEv7f/1lgySmnWJBJQlC5svXKH3zQRoRff93i3k84Adaujbd1Tgg2bYL33rMpCXmJOdjXum2bib5TMBkZ9t996614WxIdXNDDpGZNiyS84Qb44gubD3TKKQn6RzrzTFOK5cst/s1H1UokkyaZpyxnMlFenHSSib1Hu4THlCl2k/rQQ/G2JDq4oBeBxo1tQke9enDqqZYwKeE45RS75di82dwvniCsxDF+vAUude0aukz16jYt4YMPYmdXIpOTB+d//4PVq+NrSzRwQS8ijRqZqDdosH8adsLRs6fdbpQpY7NRZ82Kt0VOgNWrLf582DDLFJofffrsj2R1QrNqld3JnHuuvX/11fjaEw1c0ItBgwYm6o0amQTO3HMAABzeSURBVM/988/jbVER6NDBbjHq1LHQRu/qlQgmTLDnHPHJjz597Pmjj6JnTzLw3HP2fN990L17ci4e5oJeTOrXN1Fv0gT69YNPP423RUWgWTO7xWjTxmavJOMvPcEYP94mAh9+eMFlu3a1UFr3o4cmK8sE/dRToWlTG2ieM8cmZiUTLugRoF49E/LmzS3z7fTp8baoCBx2mF2Zjj7auoVPPBFvi6JGSU/78MMPlnAzv8HQYMqUsSGRDz8s+Z8tXnzwgYV+jhhh788+21xZydZ3cUGPEIcdZhM0W7aE00+3P1fCUb26/fJPPx0uv9ySgSVBbpidO+37uPFG682WL29BPiWV8eMtcuWss8I/pk8fy+M2f3707Epknn4a6tbdnz6hYUObOD1hQlL8xPfhgh5B6tY1UW/dGgYMSNBb4EMOsemJ558Pt98O116bcN2+jAwb3737bktgVaOGCd4jj0CVKnZHddddJfOPnJ1tgn7qqfZ7CpdTT7XnhPzNRZm1a20O3fDhdjHPYehQW+wmmQK8whJ0EekrIj+KyDIRGZNPucEioiKS5yym0kDt2ibq7drBwIEwdWq8LSoC5cpZ4pBrroF//cv+CXFdty9/VM1F8fDDdnNRs6ZFYt5xB2zdCn/5i914bNpkA9e33265fEpiLvGccLpw3S051K9vKxm6oB/M88+bD/3SSw/cPniw3QklldtFVfN9ACnAcqAFUB6YD7TPo1xV4AvgK6BbQfV27dpVk5kNG1TT0lTLl1edMqX49WVnq86bp3rvvaqDB6s+/bTqtm3Fr7fARu++WxVU//Qn1Z07o9xg+KxYYefgnHNU69Y1E0G1VSvVUaNUX39ddf36vI/dtUv1sMNU+/SJrc3hMHKkauXKqtu3F/7YG29ULVcuBr+LBCIrS7V5c9VevfLe37ev7c/Ojq1dxQGYraH0OtQO3S/URwHTgt7fDNycR7lHgP7AZy7oxsaNqt262Z/s7bcLf/z27XbcyJGqjRrtF6169ey5alUTr+++i7ztBzBunKqI6nHHqW7eHOXG8mfpUtV27fafi/r1Vc87T/X551V/+SX8eu67z46fNy9qphaaPXtUa9RQHTasaMdPn26f6Z13ImtXIvPxx3ZOxo/Pe/8LL9j+r76KrV3FobiCfibwTND784HHcpVJA94IvA4p6MBIYDYwu0mTJjE7AfFk0ybVHj1M1N96q+Dyy5erPvqo9R4rVLBvqEoV1UGDVJ95RnXNGutN/O9/qhdcoFqxopXp3t32R613NmGCatmyql26qP72W5QayZ9t21Q7dlStWdPO0aJFRe9ZbdpkF8Rzz42sjcVh8mT7Lt9/v2jH796tWqmS6uWXR9auRObss+33smtX3vs3b7b/2V/+Elu7ikNUBR3zw38GNNMCBD34URp66Dls3qx65JGmh5MmHbhv717VTz9VveGGA3uerVqpXnON6kcf2R81FBs2qP7rX6rt28eg1z51qilGy5aqS5ZEoYHQZGfbn7NMGdUPPyxmZXv2qKqd85QU1Z9/LrZ5EWHIENU6dVQzMopeR//+qocfHjmbEpl168zlWZBYDxpkd3qZmbGxq7hE1eUCVAfWAysDj93AmoJEvTQJuqrqli2qRx9tAvLcc3arN2SIavXq9i2UK6d68smqDz+s+tNPha8/p9d+/vn7e/Y9elivvSj+2JDMnKlaq5Y5ekPdx0aBBx+0z3T//cWoJCtL9e9/t5N94YWavnCzliuneuWVETOzyGzebHdbxbXl3/+287RsWWTsSmT++U87F99/n3+5116zcp98Ehu7iktxBb0ssAJoHjQo2iGf8t5DD8HWrarHHnug//eSS1TffNP2RYoNG1QfeWR/j79qVdXRoyPoL169WvWYY6zykSOjPlg6fbr1zAcPLsbg1a+/qp54otmcc2Vt0EAvOuUXPeQQ683Fk+eeM9O+/LJ49fz0k9Xz+OORsStRyc5WbdvW7owLYscOc2uOHBl9uyJBsQTdjqcf8FMg2uXWwLaxwIA8yrqg58O2baovvaQ6Z070R9azs1VnzDi41/7UU6qzZ5vwF9mGvXtVx4yxSjt3Vv3xx4jansOqVaq1a5tLqcgXvSlT7K6iUiXVZ5+1Dz17tmqHDrqItgqqd9wUwskaI046yVwlxf1NZGdb1MaAAZGxK1GZMcN+ms8+G175YcPM1x7wxpVoii3o0XiUVkGPF7l77TmPatVMjwcNUr3uOrtlf/dd1YULredSIO+9Z/+EKlVUJ06MqM27dlmUULVqRbxe7NqlevXV+y86ixcfuH/3btVbbtGBTNaaZTbq9skfRcTuwvLrrxZEdPvtkalv1Cj7OhJBnKLFBRfYnWm47sYpU+xn8t570bUrErigO/vIzjaf4ptvmo/xyittIK1dO9VDDjlQ7HNCJI86yqJBbr3VejwzZuTqSf7yi7kxwNQkVEhBIe286CKrsighn7pokYk42KhYPjbNfGaRguq/uEr10kttwCOG5Ph6I3WT89ZbVt+nn0amvkRj0yb7LV92WfjH5ISMnnde9OyKFC7oTlhkZ6uuXas6a5bqK6/YnKKLL1bt3Vu1WTPzY+cI/aBBuXRv717Vv/7VdnbpYgHjxeCJJ6yq224rwod4+mn7R9eubbcbYXDs0VnapNpG3SvlVRs3jkAoTfikpdmdSKTYssUiqsaMiVydicRjj9lvZ/bswh136aV2Z1OC5s/liQu6ExH27rU4+X/8w8YU27SxjvABTJliXZ2qVS18oAjMmmWBKP36WWBK2GzaZKFDYE7pNWvCPjTnlvuVO5faaBpYFy+So9V5sHixNfXww5Gt9/jjVVNTI1tnIpCdbTdmRfnsOZOQXn898nZFEhd0J+J89plNua9SRfWNN3LtXLXKwgtA9YorCuWCWbtWtUEDGyDcuLEQBs2cqdq0qXVN77+/kFcCK96+veoRR6hm79hpQeoiVufHHxeqrsLwt7/Znc/atZGt99577fTHaQ5Y3PjmG/vc48YV/tjMTEsJMXhw5O2KJC7oTlRYvVq1Z0/7FY0Zk2tixt69qtdfbzvT0sIKjN6718I6K1VSnT8/TCMyM1XHjrVbhubNizWHO2ca+L6ZmjNn2gwvsOmXkZiGm5lpdxK6PyLllFOKX21uZs82s196KfJ1l2RGjLDfT1EzVFx1lUWExXgYpVC4oDtRY/du80yATYw6KJ777bfNBVOtWoH3slddZfVMmBBm46tXq55wgh107rnF/hfu2WM5c044IWjjjh2q115rvfXmzfMfaczIsAHiWbPM3fTQQxY6NGSIjSw3bmwXnsDg8czPMxTsQhJpsrJs1mlR88IkItu22R3j8OFFr2PWrJJ/IXRBd6LOs89az6ZJkzwGo1autAB4sLCaPHIZvPSS7b7uujAbfOstC5esXFn1xRcjFtT/0EOad7KmGTMs5UFOJM+DD1r0zODBdpvSsOGBo8Y5j0MOUW3d2iY1XXCBhQqNGKEKenmzd7Vixeyo9QaHDTNRL6T3KWF5+mk75TNnFr2O7Gzzsp12WsTMijj5CbrY/tjTrVs3nT17dlzadqLD7Nlwxhm2+vwTT8BFFwXt3LsXbr4ZHnoIunSBo46ytdPKlOG79Y05+rVrOLLBKj46+1nKlsX2paTsK7PvkZICS5ZYvva0NFtypnXriH2GbdtsfdgTT7R1Pg5g50645RbLEQ9QuTI0bmyrhOc8cr+vUcPWOstFxqNP0OAvZ3JSzXlMXNLFFumOMC+/DBdcYGtnpqVFvPoSR8+esH27LeGXxykPmzFj4J//tIUxateOnH2RQkTmqGrea06EUvpoP7yHnpz88YcFmOR0ZA+a3DJ5svV069RRrVVL11dvoc1kpTaS1fr7IU0toUn58uaaEDm4xwvWE77uuqjNnLn1Vms6ZP6x334zP3gx7grefdc+yjvlzjA/fRSSr/z2m7Vx330Rr7rEMX++Rixa6LvvrK4nnyx+XdEAd7k4sSQjwxZbAAt2SU/Pu1xmpg0Ili9v0Ql5kp1tPoO9e81Vs3NnRCYu5cfvv9t15dJLo9fG0KGBqeafzbIXdevmcxKKTpcuFsJYbDIyTDWffdbSgL70UolaSePKK+13FGpRk8KQkwcm1KIY8cYF3YkLr79uLu66dVU///zg/TmpYJ55Jva2FcTo0SYQhQhlD5utW821PmpUYMOSJTZzq1KliM89HzPGIjkL5afPyrJpq6+8YuJ9zDFmW84dUrly9ly5so0LfPRRXHPP7typeuihdpGMFHfeaXdpoToj8cQF3YkbCxfamGBKit0O53gpJk3SfXN3SiLLlpln56abIl93zgDwjBlBG9eutfDOlJSIXuE+/dTamjw5RIHsbJs3MGmSfdiTTtqf0zlnUPeYY2wA+JVXTOgzM834ESP2l23Y0G7LfvghYraHS875jGT62yVLIufCiTQu6E5c2bxZdeBA+7UNHar67bcWXnbkkfkv3hFvzjrLoi0jvepenz4WSXFQ9MnWrbYTVO+4IyKRO3v22LkePTqwISNDddo0q79fvwMXZC1XTrVrV7t1eOYZc7EUtNrGrl0Wonn66ftDMtPSTAljNKvp+ONtWCbS2UtTUy04q6Thgu7Enawsm72YM8552GEl83Y2mDlzzNYHHohMfTlpZlJSVG++OUShvXstkBosWf7evcVu909/Um3eOEOzb7vdetI5A8sdOlhbjz9u/vviXl1//92Wz+ra1dpISbGLxsSJUUuQktOTLtbCJyH4xz+s7uXLI193cXBBd0oMH3xg658e4G4owZx8si1EUlytW758f/RPr14WDRSS7GzLSgYWEF3UwceMDNW339bH2j+uoPoTray+N9+M/oDmwoXmwM9Z3bxaNbtAff75wbcmO3aY22fuXPPHT5xoF5mxY83Vc955Znf37qotWthdxYMPqqplaChbNjo3A6tWmen33hv5uouDC7rjFJEPP9RiDdxmZloe+kqVLF/Zk08WYqLPf/5jPemuXQunWKtW2QWhQQNV0GV1jlRQ/fddG4r0GYpFZqYtOXXhheb7AZsxe8QRdreQs8p5qEe1ajZDt1s3c0ede66l/wTd89BjWqeO6hlnRM/8Y45R7dQpevUXhfwE3ScWOU4+qELXrjanaNEim9sULosXwyWXwJdfQr9+8OSTNu+oULz7Lpx9Nhx2GHzwQehJVJmZ8N578NRTMHWqbTvtNBg5Evr3p2XbsrRrB1OmFLL9SLJjB0yeDJMmQXY21KplM3dq1cr7UbMmlC9/cD2ZmXDWWbz+Vgpn8TpTp0LfvtEx+bHH4KqrbLJShw7RaaOw+MQixykGEydaZ/HNN8Mrv3ev3aaXL28h5i+/XMwBu6+/3jcRS2fNOnDfypUH9Ma1QQN7v3LlAcUuv9yiDEvyIHSh2L1bT6k1W5uwUjPHR3alrGB++81ukv72t6g1UWhwl4vjFJ2MDHPd9uxZsDDPnWvREWA5uSLm21261EI5Kla0fMWTJ5tfWcQe/fpZIrQQUSlvv202TZ8eIXvizIoV9nnuavqsOdGLtKxVeJx8cnSiaIpKfoJeiBtIxymdlC0L118PX38NM2bkXWb3brj1VujeHdassTwwr71mnpKI0LIlzJoFRxwBgwfDn/8MCxbAbbfBypXmbhkwwIzNg969oVw5mDYtQvbEmWefNffXxR+cZYlqhgyBjz+OSltDh8KyZZYTp8QTSumj/fAeupNI7NxpXo9+/Q7eN2vW/kWOLrzQFuSOGtu32zTGfHrjoejVy1bzSXQyMsyz1L9/YMOGDTbIWqlSVMKnNm60EP3rr4941UUC76E7TvE45BC4+mp4/334/nvbtmMHXHstHHOMDZpOnWpJIGvWjKIhlSvDHXfk2xsPRZ8+MH8+/PZblGyLEe+/b3dBl14a2FCzJnz4oY049+9vaT8jSI0aNr786qs2lluScUF3nDC5/HLT03/8Az75xLwfjzwCo0dbFES0Ii0iRZ8+9vzhh/G1o7g8/TTUq2favY/DDjOXS82a9kF/+CGibZ5zDqSnw8yZEa024rigO06Y1KwJI0bA+PFw0knmw/38c3j8cahaNd7WFUznzlC3rkU/hsvOnTBvnvVO774bzjsPTjgBnn/eQjpjSVYW/O1vFsl56aU2JnAAjRrB9OlQsSKcfDIsXRqxtgcMgEqVLP1+Scbj0B2nEKSn2+IXAwfC2LHmikkkLrjAXEO//74/pj4rC1avhh9/PPDx00+2PZgmTUzYliyBCy+0i1nlytG3e8MGGDbMBnUvucTiwytWDFF4yRI4/ngrMGMGNG0aERvOOceuF2vXFtrbFVHyi0OPo1mOk3g0amRCl6j06WMrGV1+Oaxfb8K9dCns2bO/TLVq0KaN9cTbtLFH69bQqpWJeVaW9dbHjjV39euvQ7t20bP5u+9sJaw1a2ze1IgRBRzQtq35lXr3tlupGTOgfv1i2zF0qN2pTJ++331V0vAeuuOUItatg2bNbEXAFi32i3WOcLdpY26ZcJZw++gj6zXv3GlCe+65kbf3xRdh1CibUPrGG9CjRyEO/uorc700bWq+sWKuJ7dnj7nqBw0yl1OhUYVffrErVNOmkJpaJDuKPVMU6Av8CCwDxuSx/zpgEbAAmA40LahOD1t0nPiwdWtEkjiqqmXMPPZY3ZfbPlKLSe3ZY7NbwVK3/P57ESv69FObjJWaassGFpOLLrL0MgV+zowM1e+/t2nC111nH6JGDd2Xo+bqq4tsA8WZKQqkAMuBFkB5YD7QPleZ3kClwOvRwKsF1euC7jjJQUaGrY0BtuTd0qXFqy89XfWoo6y+G24odLj9wbz3ngWSH310sbNMTptmdv33v0Ebd+xQ/fJL1SeeUB050rJCBicdq1jRto0caWW++sqOKSLFFfSjgGlB728Gbs6nfCows6B6XdAdJ7mYMsU6odWq2QJIReHzzy1XfuXKtm5GxJg0yZKynHhi4W8jsrJsdtHSpZox82tt02iblk/J0Gd6/ke1XTurN0e8Dz3UeuPXXWe98++/j8AV6UDyE/RwBkUbAsFj3elAz3zKXwJMzWuHiIwERgI0adIkjKYdx0kUTj/d3MNnnQVnngl/+YvF7OeVMDE3qvCvf8ENN8Dhh9vAY0SzGw4ebLO+LrjAjBs71kJnNm605+DXuZ83bdo3o6gsMJOanMNELv16JLObNuZfN39L+W5HQJcu5hsPZwAiSkQ0ykVEzgO6ASfktV9VnwKeAhsUjWTbjuPEn6ZNLajkxhtNoL/80nLa5Bc5uGOHRa5MmGDhoC++CNWrR8G488+3xkaPttw3ualadX/a3lq1zOjg94HnWjVr8kGLVtz6MDzwwGnM/+Q0Jl0ODRpEweZCEo6g/woEZ3FuFNh2ACJyMnArcIKq7sm933Gc0kH58jaD9rjj4OKLLZjjpZesB5+bZcssamThQrj3XhgzpnA55wvNqFE2xXfdugPFukaN8G4lAqQA999vufIvusieJ02yNBBxJZQvRvf7xMsCK4Dm7B8U7aAH+82XA60Kqk/dh+44pYalS22gFGzgNNidPGWKavXqljN+2rT42Vhcvv/e0uuWLWsr50U7zS7FSc6lqpnAlcA0YDHwmqouFJGxIjIgUOz/gCrA6yIyT0TeiehVx3GchKRlS3O7XHYZPPCAzbJdvdryi/3pTxYLP2cOnHpqvC0tOh07wrff2mSjK66wu5Ldu+Nji08schwnJowfb8K+Z4+tIjd8OIwbl3jpE0KRnQ133WXjrd262USoaMR+5DexyJNzOY4TE4YNs1QBJ55o66s+91zyiDmY7/+uu+Dtty2lQteu8OmnMbYhts05jlOaadvWEmxddllco/uiyoAB5oKpUwdOOQUefjh2mSld0B3HcSJMmza2ZOHAgXDddftz3kQbF3THcZwoULWqhTLedx9MnAhHHQUrVkS3TRd0x3GcKCECN99sy+atXm2DpdFcqNsF3XEcJ8r07WsDwo0b2/qk//pXdNpxQXccx4kBLVrArFmWN7516+i04SsWOY7jxIjKleGVV6JXv/fQHcdxkgQXdMdxnCTBBd1xHCdJcEF3HMdJElzQHcdxkgQXdMdxnCTBBd1xHCdJcEF3HMdJEuK2wIWIrANWFfHw2sD6CJoTaUq6fVDybXT7iofbVzxKsn1NVbVOXjviJujFQURmh1qxoyRQ0u2Dkm+j21c83L7iUdLtC4W7XBzHcZIEF3THcZwkIVEF/al4G1AAJd0+KPk2un3Fw+0rHiXdvjxJSB+64ziOczCJ2kN3HMdxcuGC7jiOkySUaEEXkb4i8qOILBORMXnsryAirwb2fy0izWJoW2MR+VREFonIQhH5Sx5leonIFhGZF3jcHiv7Au2vFJHvA23PzmO/iMijgfO3QETSYmhbm6DzMk9EtorINbnKxPz8ichzIvKHiPwQtK2miHwkIksDzzVCHHthoMxSEbkwhvb9n4gsCXyHb4nIoSGOzff3EEX77hSRX4O+x34hjs33/x5F+14Nsm2liMwLcWzUz1+xUdUS+QBSgOVAC6A8MB9on6vM5cCTgdfnAK/G0L76QFrgdVXgpzzs6wW8G8dzuBKonc/+fsBUQIAjga/j+F3/hk2YiOv5A44H0oAfgrb9AxgTeD0GeCCP42oCKwLPNQKva8TIvlOBsoHXD+RlXzi/hyjadydwQxi/gXz/79GyL9f+fwK3x+v8FfdRknvoPYBlqrpCVfcCE4GBucoMBF4MvJ4EnCQiEgvjVHWtqs4NvN4GLAYaxqLtCDIQeEmNr4BDRaR+HOw4CViuqkWdORwxVPULYGOuzcG/sxeBP+dxaB/gI1XdqKqbgI+AvrGwT1U/VNXMwNuvgEaRbjdcQpy/cAjn/15s8rMvoB1nARMi3W6sKMmC3hBYHfQ+nYMFc1+ZwA96C1ArJtYFEXD1pAJf57H7KBGZLyJTRaRDTA0DBT4UkTkiMjKP/eGc41hwDqH/RPE8fzkcpqprA69/Aw7Lo0xJOZcXY3ddeVHQ7yGaXBlwCT0XwmVVEs7fccDvqro0xP54nr+wKMmCnhCISBXgDeAaVd2aa/dczI3QGfg3MDnG5h2rqmnAacAVInJ8jNsvEBEpDwwAXs9jd7zP30Go3XuXyFhfEbkVyATGhygSr9/DE8DhQBdgLebWKIkMJf/eeYn/P5VkQf8VaBz0vlFgW55lRKQsUB3YEBPrrM1ymJiPV9U3c+9X1a2quj3w+n2gnIjUjpV9qvpr4PkP4C3stjaYcM5xtDkNmKuqv+feEe/zF8TvOa6owPMfeZSJ67kUkeHA6cCwwEXnIML4PUQFVf1dVbNUNRt4OkS78T5/ZYEzgFdDlYnX+SsMJVnQvwVaiUjzQC/uHOCdXGXeAXKiCc4EPgn1Y440AX/bs8BiVX0oRJl6OT59EemBne+YXHBEpLKIVM15jQ2c/ZCr2DvABYFolyOBLUGuhVgRslcUz/OXi+Df2YXA23mUmQacKiI1Ai6FUwPboo6I9AVuBAao6s4QZcL5PUTLvuBxmUEh2g3n/x5NTgaWqGp6Xjvjef4KRbxHZfN7YFEYP2Gj37cGto3FfrgAFbFb9WXAN0CLGNp2LHbrvQCYF3j0A0YBowJlrgQWYiP2XwFHx9C+FoF25wdsyDl/wfYJ8Hjg/H4PdIvx91sZE+jqQdviev6wi8taIAPz416CjctMB5YCHwM1A2W7Ac8EHXtx4Le4DLgohvYtw/zPOb/DnMivBsD7+f0eYmTfy4Hf1wJMpOvnti/w/qD/eyzsC2x/Ied3F1Q25uevuA+f+u84jpMklGSXi+M4jlMIXNAdx3GSBBd0x3GcJMEF3XEcJ0lwQXccx0kSXNAdx3GSBBd0x3GcJOH/Ad3MIhk49pStAAAAAElFTkSuQmCC\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fe5FXa9BNAbX",
+        "outputId": "1c57f519-4a97-4726-87d8-fccf3f630ad4"
+      },
+      "source": [
+        "import time\n",
+        "t = time.time()\n",
+        "export_path_keras = \"./{}.h5\".format(int(t))\n",
+        "print(export_path_keras)\n",
+        "\n",
+        "model.save(export_path_keras)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "./1616037897.h5\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "HjfvVKPGSMvo",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "5593ca86-1542-43cb-8c5e-92f7dd1ab803"
+      },
+      "source": [
+        "from tensorflow.keras.applications import ResNet50\n",
+        "\n",
+        "base_model = ResNet50(input_shape=(150, 150,3), include_top=False, weights=\"imagenet\")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
+            "94773248/94765736 [==============================] - 0s 0us/step\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ywn8sqToScyf"
+      },
+      "source": [
+        "for layer in base_model.layers:\n",
+        "    layer.trainable = False"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "B6aKUAdzPDNj"
+      },
+      "source": [
+        "x = layers.Flatten()(base_model.output)\n",
+        "\n",
+        "x = layers.Dense(1024, activation='relu')(x)\n",
+        "\n",
+        "\n",
+        "x = layers.Dropout(0.2)(x)\n",
+        "\n",
+        "x = layers.Dense(4, activation='softmax')(x)\n",
+        "\n",
+        "model = tf.keras.models.Model(base_model.input, x)\n",
+        "\n",
+        "model.compile(optimizer = tf.keras.optimizers.RMSprop(lr=0.0001), loss = 'categorical_crossentropy',metrics = ['accuracy'])\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d97Qom0jQA8A",
+        "outputId": "27d3b41f-6513-4c6c-a8ea-fbe800513203"
+      },
+      "source": [
+        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+        "train_datagen = ImageDataGenerator(\n",
+        "    rescale = 1./255.,\n",
+        "    rotation_range = 40,\n",
+        "    width_shift_range = 0.2,\n",
+        "    height_shift_range = 0.2,\n",
+        "    shear_range = 0.2,\n",
+        "    zoom_range = 0.2,\n",
+        "    horizontal_flip = True\n",
+        "   )\n",
+        "\n",
+        "validation_datagen = ImageDataGenerator(rescale=1/255)\n",
+        "\n",
+        "train_generator = train_datagen.flow_from_directory(\n",
+        "    train_dir,\n",
+        "    target_size=(150,150),\n",
+        "    batch_size= 5,\n",
+        "    class_mode = 'categorical'\n",
+        ")\n",
+        "validation_generator = validation_datagen.flow_from_directory(\n",
+        "    validation_dir,\n",
+        "    target_size=(150,150),\n",
+        "    batch_size=5,\n",
+        "    class_mode='categorical'\n",
+        ")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Found 295 images belonging to 4 classes.\n",
+            "Found 73 images belonging to 4 classes.\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Rf8p06BdQMTc",
+        "outputId": "69db21b8-2aa7-445c-a124-9506f5df753f"
+      },
+      "source": [
+        "history = model.fit(\n",
+        "    train_generator,\n",
+        "    steps_per_epoch=59,\n",
+        "    epochs=20,\n",
+        "    validation_data = validation_generator,\n",
+        "    validation_steps = 14,\n",
+        "    verbose = 1)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/20\n",
+            "59/59 [==============================] - 6s 61ms/step - loss: 2.7389 - accuracy: 0.2728 - val_loss: 1.5488 - val_accuracy: 0.2857\n",
+            "Epoch 2/20\n",
+            "59/59 [==============================] - 3s 46ms/step - loss: 1.7991 - accuracy: 0.3135 - val_loss: 1.6220 - val_accuracy: 0.4143\n",
+            "Epoch 3/20\n",
+            "59/59 [==============================] - 3s 47ms/step - loss: 1.4633 - accuracy: 0.4273 - val_loss: 1.2444 - val_accuracy: 0.4571\n",
+            "Epoch 4/20\n",
+            "59/59 [==============================] - 3s 45ms/step - loss: 1.4317 - accuracy: 0.3922 - val_loss: 1.2075 - val_accuracy: 0.4714\n",
+            "Epoch 5/20\n",
+            "59/59 [==============================] - 3s 44ms/step - loss: 1.4336 - accuracy: 0.2948 - val_loss: 1.3479 - val_accuracy: 0.2571\n",
+            "Epoch 6/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.3280 - accuracy: 0.3665 - val_loss: 1.3476 - val_accuracy: 0.4571\n",
+            "Epoch 7/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.3145 - accuracy: 0.4480 - val_loss: 1.4578 - val_accuracy: 0.2714\n",
+            "Epoch 8/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.2922 - accuracy: 0.4067 - val_loss: 1.1847 - val_accuracy: 0.4571\n",
+            "Epoch 9/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.2662 - accuracy: 0.4107 - val_loss: 1.1945 - val_accuracy: 0.5286\n",
+            "Epoch 10/20\n",
+            "59/59 [==============================] - 3s 44ms/step - loss: 1.2125 - accuracy: 0.4307 - val_loss: 1.2234 - val_accuracy: 0.4000\n",
+            "Epoch 11/20\n",
+            "59/59 [==============================] - 3s 44ms/step - loss: 1.2645 - accuracy: 0.4437 - val_loss: 1.1947 - val_accuracy: 0.4286\n",
+            "Epoch 12/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.1804 - accuracy: 0.4679 - val_loss: 1.2524 - val_accuracy: 0.4714\n",
+            "Epoch 13/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.3673 - accuracy: 0.3836 - val_loss: 1.1749 - val_accuracy: 0.4286\n",
+            "Epoch 14/20\n",
+            "59/59 [==============================] - 3s 44ms/step - loss: 1.1979 - accuracy: 0.4402 - val_loss: 1.1942 - val_accuracy: 0.5143\n",
+            "Epoch 15/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.2324 - accuracy: 0.4023 - val_loss: 1.2254 - val_accuracy: 0.4714\n",
+            "Epoch 16/20\n",
+            "59/59 [==============================] - 3s 46ms/step - loss: 1.1015 - accuracy: 0.4767 - val_loss: 1.1692 - val_accuracy: 0.4286\n",
+            "Epoch 17/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.1928 - accuracy: 0.5158 - val_loss: 1.0979 - val_accuracy: 0.5429\n",
+            "Epoch 18/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.1915 - accuracy: 0.4713 - val_loss: 1.2804 - val_accuracy: 0.5000\n",
+            "Epoch 19/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.1796 - accuracy: 0.5138 - val_loss: 1.7352 - val_accuracy: 0.3429\n",
+            "Epoch 20/20\n",
+            "59/59 [==============================] - 3s 43ms/step - loss: 1.1918 - accuracy: 0.4256 - val_loss: 1.0764 - val_accuracy: 0.4714\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 545
+        },
+        "id": "HLZCeBhdQoye",
+        "outputId": "972e7d02-3644-433a-9950-a196fece1f8c"
+      },
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "acc = history.history['accuracy']\n",
+        "val_acc = history.history['val_accuracy']\n",
+        "loss = history.history['loss']\n",
+        "val_loss = history.history['val_loss']\n",
+        "\n",
+        "epochs = range(len(acc))\n",
+        "\n",
+        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
+        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
+        "plt.title('Training and validation accuracy')\n",
+        "\n",
+        "plt.figure()\n",
+        "\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",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "XHy5yStoQv_V",
+        "outputId": "b8260e02-4346-4bca-e414-8654f282becc"
+      },
+      "source": [
+        "import time\n",
+        "t = time.time()\n",
+        "export_path_keras = \"./{}.h5\".format(int(t))\n",
+        "print(export_path_keras)\n",
+        "\n",
+        "model.save(export_path_keras)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "./1616038017.h5\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file