diff --git a/sw_lab9-10_2.ipynb b/sw_lab9-10_2.ipynb new file mode 100644 index 0000000..b01a2e7 --- /dev/null +++ b/sw_lab9-10_2.ipynb @@ -0,0 +1,1598 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Aleksandra Jonas, Aleksandra Gronowska, Iwona Christop\n", + "# Zestaw 9-10/zadanie2 - AlexNet, VGG16, ResNet on village" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Przygotowanie danych" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Image, display" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import subprocess\n", + "import pkg_resources\n", + "import numpy as np\n", + "\n", + "required = { 'scikit-image'}\n", + "installed = {pkg.key for pkg in pkg_resources.working_set}\n", + "missing = required - installed\n", + "\n", + "if missing: \n", + " python = sys.executable\n", + " subprocess.check_call([python, '-m', 'pip', 'install', *missing], stdout=subprocess.DEVNULL)\n", + "\n", + "def load_data(input_dir, img_size):\n", + " import numpy as np\n", + " import pandas as pd\n", + " import os\n", + " from skimage.io import imread\n", + " import cv2 as cv\n", + " from pathlib import Path\n", + " import random\n", + " from shutil import copyfile, rmtree\n", + " import json\n", + "\n", + " import seaborn as sns\n", + " import matplotlib.pyplot as plt\n", + "\n", + " import matplotlib\n", + " \n", + " image_dir = Path(input_dir)\n", + " categories_name = []\n", + " for file in os.listdir(image_dir):\n", + " d = os.path.join(image_dir, file)\n", + " if os.path.isdir(d):\n", + " categories_name.append(file)\n", + "\n", + " folders = [directory for directory in image_dir.iterdir() if directory.is_dir()]\n", + " \n", + " ds_img = []\n", + " categories_count=[]\n", + " labels=[]\n", + " for i, direc in enumerate(folders):\n", + " count = 0\n", + " for obj in direc.iterdir():\n", + " if os.path.isfile(obj) and os.path.basename(os.path.normpath(obj)) != 'desktop.ini':\n", + " labels.append(os.path.basename(os.path.normpath(direc)))\n", + " count += 1\n", + " img = imread(obj)#zwraca ndarry postaci xSize x ySize x colorDepth\n", + " img = img[:, :, :3]\n", + " img = cv.resize(img, img_size, interpolation=cv.INTER_AREA)# zwraca ndarray\n", + " img = img / 255 #normalizacja\n", + " ds_img.append(img)\n", + " categories_count.append(count)\n", + " X={}\n", + " X[\"values\"] = np.array(ds_img)\n", + " X[\"categories_name\"] = categories_name\n", + " X[\"categories_count\"] = categories_count\n", + " X[\"labels\"]=labels\n", + " return X" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_run_logdir(root_logdir):\n", + " import os\n", + " import time\n", + "\n", + " run_id = time.strftime(\"run_%Y_%m_%d-%H_%M_%S\")\n", + " return os.path.join(root_logdir, run_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def diagram_setup(model_name):\n", + " from tensorflow import keras\n", + " import os\n", + " \n", + " root_logdir = os.path.join(os.curdir, f\"logs\\\\fit\\\\{model_name}\\\\\")\n", + " \n", + " run_logdir = get_run_logdir(root_logdir)\n", + " tensorboard_cb = keras.callbacks.TensorBoard(run_logdir)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def prepare_data(path, img_size, test_size, val_size):\n", + " from sklearn.model_selection import train_test_split\n", + " from sklearn.preprocessing import LabelEncoder\n", + " import tensorflow as tf\n", + "\n", + " data = load_data(path, img_size)\n", + " values = data['values']\n", + " labels = data['labels']\n", + "\n", + " X_train, X_test, y_train, y_test = train_test_split(values, labels, test_size=test_size, random_state=42)\n", + " X_train, X_validate, y_train, y_validate = train_test_split(X_train, y_train, test_size=val_size, random_state=42)\n", + "\n", + " class_le = LabelEncoder()\n", + " y_train_enc = class_le.fit_transform(y_train)\n", + " y_validate_enc = class_le.fit_transform(y_validate)\n", + " y_test_enc = class_le.fit_transform(y_test)\n", + "\n", + " train_ds = tf.data.Dataset.from_tensor_slices((X_train, y_train_enc))\n", + " validation_ds = tf.data.Dataset.from_tensor_slices((X_validate, y_validate_enc))\n", + " test_ds = tf.data.Dataset.from_tensor_slices((X_test, y_test_enc))\n", + "\n", + " train_ds_size = tf.data.experimental.cardinality(train_ds).numpy()\n", + " test_ds_size = tf.data.experimental.cardinality(test_ds).numpy()\n", + " validation_ds_size = tf.data.experimental.cardinality(validation_ds).numpy()\n", + "\n", + " #Rozmiary zbiorów\n", + " print(\"Training:\", train_ds_size)\n", + " print(\"Test:\", test_ds_size)\n", + " print(\"Validation:\", validation_ds_size)\n", + "\n", + " # Mieszanie zriorów\n", + " train_ds = (train_ds.shuffle(buffer_size=train_ds_size).batch(batch_size=32, drop_remainder=True))\n", + " test_ds = (test_ds.shuffle(buffer_size=train_ds_size).batch(batch_size=32, drop_remainder=True))\n", + " validation_ds = (validation_ds.shuffle(buffer_size=train_ds_size).batch(batch_size=32, drop_remainder=True))\n", + "\n", + " return train_ds, test_ds, validation_ds\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AlexNet" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:`lr` is deprecated, please use `learning_rate` instead, or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.SGD.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d (Conv2D) (None, 55, 55, 96) 34944 \n", + " \n", + " max_pooling2d (MaxPooling2D (None, 27, 27, 96) 0 \n", + " ) \n", + " \n", + " conv2d_1 (Conv2D) (None, 27, 27, 256) 614656 \n", + " \n", + " max_pooling2d_1 (MaxPooling (None, 13, 13, 256) 0 \n", + " 2D) \n", + " \n", + " conv2d_2 (Conv2D) (None, 13, 13, 384) 885120 \n", + " \n", + " conv2d_3 (Conv2D) (None, 13, 13, 384) 1327488 \n", + " \n", + " conv2d_4 (Conv2D) (None, 13, 13, 256) 884992 \n", + " \n", + " max_pooling2d_2 (MaxPooling (None, 6, 6, 256) 0 \n", + " 2D) \n", + " \n", + " flatten (Flatten) (None, 9216) 0 \n", + " \n", + " dense (Dense) (None, 4096) 37752832 \n", + " \n", + " dense_1 (Dense) (None, 4096) 16781312 \n", + " \n", + " dense_2 (Dense) (None, 12) 49164 \n", + " \n", + "=================================================================\n", + "Total params: 58,330,508\n", + "Trainable params: 58,330,508\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "from tensorflow import keras\n", + "import tensorflow as tf\n", + "import os\n", + "import time\n", + "\n", + "model = keras.models.Sequential([\n", + " keras.layers.Conv2D(filters=96, kernel_size=(11,11), strides=(4,4), activation='relu', input_shape=(227,227,3)),\n", + " keras.layers.MaxPool2D(pool_size=(3,3), strides=(2,2)),\n", + " keras.layers.Conv2D(filters=256, kernel_size=(5,5), strides=(1,1), activation='relu', padding=\"same\"),\n", + " keras.layers.MaxPool2D(pool_size=(3,3), strides=(2,2)),\n", + " keras.layers.Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), activation='relu', padding=\"same\"),\n", + " keras.layers.Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), activation='relu', padding=\"same\"),\n", + " keras.layers.Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), activation='relu', padding=\"same\"),\n", + " keras.layers.MaxPool2D(pool_size=(3,3), strides=(2,2)),\n", + " keras.layers.Flatten(),\n", + " keras.layers.Dense(4096, activation='relu'),\n", + " keras.layers.Dense(4096, activation='relu'),\n", + " keras.layers.Dense(12, activation='softmax')\n", + "])\n", + "\n", + "model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.optimizers.SGD(lr=.001), metrics=['accuracy'])\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: 7430\n", + "Test: 2323\n", + "Validation: 1858\n" + ] + } + ], + "source": [ + "train_ds_a, test_ds_a, val_ds_a = prepare_data(\"./plantvillage/color\", (227, 227), 0.2, 0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n", + "/var/folders/_h/ljwht4gd7lb99rm1hm78h7_00000gn/T/ipykernel_23432/2397086753.py:6: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", + " alex = model.fit_generator(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-01-06 20:01:38.622228: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "232/232 [==============================] - ETA: 0s - loss: 2.1314 - accuracy: 0.2501\n", + "Epoch 1: val_accuracy improved from -inf to 0.44235, saving model to alex_2.h5\n", + "232/232 [==============================] - 223s 956ms/step - loss: 2.1314 - accuracy: 0.2501 - val_loss: 1.6157 - val_accuracy: 0.4423\n", + "Epoch 2/25\n", + "232/232 [==============================] - ETA: 0s - loss: 1.3779 - accuracy: 0.5031\n", + "Epoch 2: val_accuracy improved from 0.44235 to 0.60614, saving model to alex_2.h5\n", + "232/232 [==============================] - 264s 1s/step - loss: 1.3779 - accuracy: 0.5031 - val_loss: 1.1473 - val_accuracy: 0.6061\n", + "Epoch 3/25\n", + "232/232 [==============================] - ETA: 0s - loss: 1.0262 - accuracy: 0.6358\n", + "Epoch 3: val_accuracy improved from 0.60614 to 0.67726, saving model to alex_2.h5\n", + "232/232 [==============================] - 266s 1s/step - loss: 1.0262 - accuracy: 0.6358 - val_loss: 0.9024 - val_accuracy: 0.6773\n", + "Epoch 4/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.7844 - accuracy: 0.7259\n", + "Epoch 4: val_accuracy improved from 0.67726 to 0.72252, saving model to alex_2.h5\n", + "232/232 [==============================] - 267s 1s/step - loss: 0.7844 - accuracy: 0.7259 - val_loss: 0.7740 - val_accuracy: 0.7225\n", + "Epoch 5/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.5837 - accuracy: 0.7967\n", + "Epoch 5: val_accuracy improved from 0.72252 to 0.79472, saving model to alex_2.h5\n", + "232/232 [==============================] - 269s 1s/step - loss: 0.5837 - accuracy: 0.7967 - val_loss: 0.5986 - val_accuracy: 0.7947\n", + "Epoch 6/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.4601 - accuracy: 0.8393\n", + "Epoch 6: val_accuracy did not improve from 0.79472\n", + "232/232 [==============================] - 273s 1s/step - loss: 0.4601 - accuracy: 0.8393 - val_loss: 0.6495 - val_accuracy: 0.7769\n", + "Epoch 7/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.3825 - accuracy: 0.8679\n", + "Epoch 7: val_accuracy improved from 0.79472 to 0.85938, saving model to alex_2.h5\n", + "232/232 [==============================] - 274s 1s/step - loss: 0.3825 - accuracy: 0.8679 - val_loss: 0.4127 - val_accuracy: 0.8594\n", + "Epoch 8/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.2899 - accuracy: 0.8978\n", + "Epoch 8: val_accuracy did not improve from 0.85938\n", + "232/232 [==============================] - 273s 1s/step - loss: 0.2899 - accuracy: 0.8978 - val_loss: 0.4238 - val_accuracy: 0.8540\n", + "Epoch 9/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.2615 - accuracy: 0.9133\n", + "Epoch 9: val_accuracy improved from 0.85938 to 0.87338, saving model to alex_2.h5\n", + "232/232 [==============================] - 270s 1s/step - loss: 0.2615 - accuracy: 0.9133 - val_loss: 0.3714 - val_accuracy: 0.8734\n", + "Epoch 10/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.2115 - accuracy: 0.9247\n", + "Epoch 10: val_accuracy improved from 0.87338 to 0.87500, saving model to alex_2.h5\n", + "232/232 [==============================] - 269s 1s/step - loss: 0.2115 - accuracy: 0.9247 - val_loss: 0.3794 - val_accuracy: 0.8750\n", + "Epoch 11/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.1971 - accuracy: 0.9349\n", + "Epoch 11: val_accuracy did not improve from 0.87500\n", + "232/232 [==============================] - 270s 1s/step - loss: 0.1971 - accuracy: 0.9349 - val_loss: 0.4570 - val_accuracy: 0.8567\n", + "Epoch 12/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.1495 - accuracy: 0.9500\n", + "Epoch 12: val_accuracy improved from 0.87500 to 0.87662, saving model to alex_2.h5\n", + "232/232 [==============================] - 270s 1s/step - loss: 0.1495 - accuracy: 0.9500 - val_loss: 0.4067 - val_accuracy: 0.8766\n", + "Epoch 13/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.1206 - accuracy: 0.9634\n", + "Epoch 13: val_accuracy improved from 0.87662 to 0.88147, saving model to alex_2.h5\n", + "232/232 [==============================] - 269s 1s/step - loss: 0.1206 - accuracy: 0.9634 - val_loss: 0.4036 - val_accuracy: 0.8815\n", + "Epoch 14/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.1667 - accuracy: 0.9593\n", + "Epoch 14: val_accuracy did not improve from 0.88147\n", + "232/232 [==============================] - 272s 1s/step - loss: 0.1667 - accuracy: 0.9593 - val_loss: 0.5347 - val_accuracy: 0.8292\n", + "Epoch 15/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.1315 - accuracy: 0.9588\n", + "Epoch 15: val_accuracy did not improve from 0.88147\n", + "232/232 [==============================] - 277s 1s/step - loss: 0.1315 - accuracy: 0.9588 - val_loss: 0.7335 - val_accuracy: 0.8163\n", + "Epoch 16/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.0950 - accuracy: 0.9731\n", + "Epoch 16: val_accuracy improved from 0.88147 to 0.88308, saving model to alex_2.h5\n", + "232/232 [==============================] - 272s 1s/step - loss: 0.0950 - accuracy: 0.9731 - val_loss: 0.4444 - val_accuracy: 0.8831\n", + "Epoch 17/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.0566 - accuracy: 0.9846\n", + "Epoch 17: val_accuracy did not improve from 0.88308\n", + "232/232 [==============================] - 273s 1s/step - loss: 0.0566 - accuracy: 0.9846 - val_loss: 0.6635 - val_accuracy: 0.8287\n", + "Epoch 18/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.0443 - accuracy: 0.9880\n", + "Epoch 18: val_accuracy improved from 0.88308 to 0.88631, saving model to alex_2.h5\n", + "232/232 [==============================] - 273s 1s/step - loss: 0.0443 - accuracy: 0.9880 - val_loss: 0.4852 - val_accuracy: 0.8863\n", + "Epoch 19/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.0101 - accuracy: 0.9981\n", + "Epoch 19: val_accuracy improved from 0.88631 to 0.90248, saving model to alex_2.h5\n", + "232/232 [==============================] - 274s 1s/step - loss: 0.0101 - accuracy: 0.9981 - val_loss: 0.4459 - val_accuracy: 0.9025\n", + "Epoch 20/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.0031 - accuracy: 0.9995\n", + "Epoch 20: val_accuracy improved from 0.90248 to 0.90787, saving model to alex_2.h5\n", + "232/232 [==============================] - 274s 1s/step - loss: 0.0031 - accuracy: 0.9995 - val_loss: 0.4574 - val_accuracy: 0.9079\n", + "Epoch 21/25\n", + "232/232 [==============================] - ETA: 0s - loss: 0.0010 - accuracy: 1.0000\n", + "Epoch 21: val_accuracy did not improve from 0.90787\n", + "232/232 [==============================] - 278s 1s/step - loss: 0.0010 - accuracy: 1.0000 - val_loss: 0.4781 - val_accuracy: 0.9073\n", + "Epoch 22/25\n", + "232/232 [==============================] - ETA: 0s - loss: 7.0759e-04 - accuracy: 1.0000\n", + "Epoch 22: val_accuracy did not improve from 0.90787\n", + "232/232 [==============================] - 270s 1s/step - loss: 7.0759e-04 - accuracy: 1.0000 - val_loss: 0.4991 - val_accuracy: 0.9062\n", + "Epoch 23/25\n", + "232/232 [==============================] - ETA: 0s - loss: 5.5237e-04 - accuracy: 1.0000\n", + "Epoch 23: val_accuracy did not improve from 0.90787\n", + "232/232 [==============================] - 270s 1s/step - loss: 5.5237e-04 - accuracy: 1.0000 - val_loss: 0.5114 - val_accuracy: 0.9073\n", + "Epoch 24/25\n", + "232/232 [==============================] - ETA: 0s - loss: 4.5192e-04 - accuracy: 1.0000\n", + "Epoch 24: val_accuracy did not improve from 0.90787\n", + "232/232 [==============================] - 268s 1s/step - loss: 4.5192e-04 - accuracy: 1.0000 - val_loss: 0.5210 - val_accuracy: 0.9052\n", + "Epoch 25/25\n", + "232/232 [==============================] - ETA: 0s - loss: 3.7889e-04 - accuracy: 1.0000\n", + "Epoch 25: val_accuracy did not improve from 0.90787\n", + "232/232 [==============================] - 268s 1s/step - loss: 3.7889e-04 - accuracy: 1.0000 - val_loss: 0.5333 - val_accuracy: 0.9057\n" + ] + } + ], + "source": [ + "from keras.callbacks import ModelCheckpoint, EarlyStopping\n", + "\n", + "checkpoint = ModelCheckpoint(\"alex_2.h5\", monitor='val_accuracy', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)\n", + "early = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=20, verbose=1, mode='auto')\n", + "\n", + "alex = model.fit_generator(\n", + " steps_per_epoch=len(train_ds_a), \n", + " generator=train_ds_a, \n", + " validation_data= val_ds_a, \n", + " validation_steps=len(val_ds_a), \n", + " epochs=25, \n", + " callbacks=[checkpoint,early])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(alex.history[\"accuracy\"])\n", + "plt.plot(alex.history['val_accuracy'])\n", + "plt.plot(alex.history['loss'])\n", + "plt.plot(alex.history['val_loss'])\n", + "plt.title(\"Model accuracy\")\n", + "plt.ylabel(\"Value\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.legend([\"Accuracy\",\"Validation Accuracy\",\"Loss\",\"Validation Loss\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "72/72 [==============================] - 23s 318ms/step - loss: 0.4541 - accuracy: 0.9084\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.45413827896118164, 0.9084201455116272]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.evaluate(test_ds_a)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# VGG16" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d (Conv2D) (None, 224, 224, 64) 1792 \n", + " \n", + " conv2d_1 (Conv2D) (None, 224, 224, 64) 36928 \n", + " \n", + " max_pooling2d (MaxPooling2D (None, 112, 112, 64) 0 \n", + " ) \n", + " \n", + " conv2d_2 (Conv2D) (None, 112, 112, 128) 73856 \n", + " \n", + " conv2d_3 (Conv2D) (None, 112, 112, 128) 147584 \n", + " \n", + " max_pooling2d_1 (MaxPooling (None, 56, 56, 128) 0 \n", + " 2D) \n", + " \n", + " conv2d_4 (Conv2D) (None, 56, 56, 256) 295168 \n", + " \n", + " conv2d_5 (Conv2D) (None, 56, 56, 256) 590080 \n", + " \n", + " conv2d_6 (Conv2D) (None, 56, 56, 256) 590080 \n", + " \n", + " max_pooling2d_2 (MaxPooling (None, 28, 28, 256) 0 \n", + " 2D) \n", + " \n", + " conv2d_7 (Conv2D) (None, 28, 28, 512) 1180160 \n", + " \n", + " conv2d_8 (Conv2D) (None, 28, 28, 512) 2359808 \n", + " \n", + " conv2d_9 (Conv2D) (None, 28, 28, 512) 2359808 \n", + " \n", + " max_pooling2d_3 (MaxPooling (None, 14, 14, 512) 0 \n", + " 2D) \n", + " \n", + " conv2d_10 (Conv2D) (None, 14, 14, 512) 2359808 \n", + " \n", + " conv2d_11 (Conv2D) (None, 14, 14, 512) 2359808 \n", + " \n", + " conv2d_12 (Conv2D) (None, 14, 14, 512) 2359808 \n", + " \n", + " flatten (Flatten) (None, 100352) 0 \n", + " \n", + " dense (Dense) (None, 4096) 411045888 \n", + " \n", + " dense_1 (Dense) (None, 4096) 16781312 \n", + " \n", + " dense_2 (Dense) (None, 12) 49164 \n", + " \n", + "=================================================================\n", + "Total params: 442,591,052\n", + "Trainable params: 442,591,052\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/lib/python3.10/site-packages/keras/optimizers/optimizer_v2/adam.py:117: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n", + " super().__init__(name, **kwargs)\n" + ] + } + ], + "source": [ + "import keras,os\n", + "from keras.models import Sequential\n", + "from keras.layers import Dense, Conv2D, MaxPool2D , Flatten\n", + "from keras.preprocessing.image import ImageDataGenerator\n", + "from keras.optimizers import Adam\n", + "import numpy as np\n", + "\n", + "model = keras.models.Sequential([\n", + " keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu', input_shape=(224,224,3), padding=\"same\"),\n", + " keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu', input_shape=(224,224,3), padding=\"same\"),\n", + " keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", + " keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", + " keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", + " keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", + " keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", + " keras.layers.Flatten(),\n", + " keras.layers.Dense(units = 4096, activation='relu'),\n", + " keras.layers.Dense(units = 4096, activation='relu'),\n", + " keras.layers.Dense(units = 12, activation='softmax')\n", + "])\n", + "\n", + "opt = Adam(lr=0.001)\n", + "model.compile(optimizer=opt, loss=keras.losses.sparse_categorical_crossentropy, metrics=['accuracy'])\n", + "\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: 7430\n", + "Test: 2323\n", + "Validation: 1858\n" + ] + } + ], + "source": [ + "train_ds_v, test_ds_v, val_ds_v = prepare_data('./plantvillage/color', (224, 224), 0.2, 0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_h/ljwht4gd7lb99rm1hm78h7_00000gn/T/ipykernel_24066/3966396738.py:5: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", + " vgg = model.fit_generator(steps_per_epoch=len(train_ds_v), generator=train_ds_v, validation_data= val_ds_v, validation_steps=len(val_ds_v), epochs=25, callbacks=[checkpoint,early])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-01-06 22:32:18.362109: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "232/232 [==============================] - ETA: 0s - loss: 2.4227 - accuracy: 0.1339 \n", + "Epoch 1: val_accuracy improved from -inf to 0.15086, saving model to vgg16_2.h5\n", + "232/232 [==============================] - 3659s 16s/step - loss: 2.4227 - accuracy: 0.1339 - val_loss: 2.4052 - val_accuracy: 0.1509\n", + "Epoch 2/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4051 - accuracy: 0.1356 \n", + "Epoch 2: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3761s 16s/step - loss: 2.4051 - accuracy: 0.1356 - val_loss: 2.4036 - val_accuracy: 0.1509\n", + "Epoch 3/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4026 - accuracy: 0.1381 \n", + "Epoch 3: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3712s 16s/step - loss: 2.4026 - accuracy: 0.1381 - val_loss: 2.4002 - val_accuracy: 0.1503\n", + "Epoch 4/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4015 - accuracy: 0.1379 \n", + "Epoch 4: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3690s 16s/step - loss: 2.4015 - accuracy: 0.1379 - val_loss: 2.4012 - val_accuracy: 0.1509\n", + "Epoch 5/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4015 - accuracy: 0.1382 \n", + "Epoch 5: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3695s 16s/step - loss: 2.4015 - accuracy: 0.1382 - val_loss: 2.3971 - val_accuracy: 0.1509\n", + "Epoch 6/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4004 - accuracy: 0.1393 \n", + "Epoch 6: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3703s 16s/step - loss: 2.4004 - accuracy: 0.1393 - val_loss: 2.3999 - val_accuracy: 0.1509\n", + "Epoch 7/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4006 - accuracy: 0.1379 \n", + "Epoch 7: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3678s 16s/step - loss: 2.4006 - accuracy: 0.1379 - val_loss: 2.3984 - val_accuracy: 0.1509\n", + "Epoch 8/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4007 - accuracy: 0.1394 \n", + "Epoch 8: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3677s 16s/step - loss: 2.4007 - accuracy: 0.1394 - val_loss: 2.3993 - val_accuracy: 0.1509\n", + "Epoch 9/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4006 - accuracy: 0.1354 \n", + "Epoch 9: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3660s 16s/step - loss: 2.4006 - accuracy: 0.1354 - val_loss: 2.3993 - val_accuracy: 0.1509\n", + "Epoch 10/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4004 - accuracy: 0.1395 \n", + "Epoch 10: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3696s 16s/step - loss: 2.4004 - accuracy: 0.1395 - val_loss: 2.3970 - val_accuracy: 0.1509\n", + "Epoch 11/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4005 - accuracy: 0.1394 \n", + "Epoch 11: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3672s 16s/step - loss: 2.4005 - accuracy: 0.1394 - val_loss: 2.4014 - val_accuracy: 0.1498\n", + "Epoch 12/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4003 - accuracy: 0.1374 \n", + "Epoch 12: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3548s 15s/step - loss: 2.4003 - accuracy: 0.1374 - val_loss: 2.3988 - val_accuracy: 0.1503\n", + "Epoch 13/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4005 - accuracy: 0.1393 \n", + "Epoch 13: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3600s 16s/step - loss: 2.4005 - accuracy: 0.1393 - val_loss: 2.3987 - val_accuracy: 0.1503\n", + "Epoch 14/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4005 - accuracy: 0.1394 \n", + "Epoch 14: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3600s 16s/step - loss: 2.4005 - accuracy: 0.1394 - val_loss: 2.3989 - val_accuracy: 0.1509\n", + "Epoch 15/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4004 - accuracy: 0.1393 \n", + "Epoch 15: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3261s 14s/step - loss: 2.4004 - accuracy: 0.1393 - val_loss: 2.3988 - val_accuracy: 0.1503\n", + "Epoch 16/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.3998 - accuracy: 0.1367 \n", + "Epoch 16: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3359s 14s/step - loss: 2.3998 - accuracy: 0.1367 - val_loss: 2.3984 - val_accuracy: 0.1509\n", + "Epoch 17/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4001 - accuracy: 0.1395 \n", + "Epoch 17: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3397s 15s/step - loss: 2.4001 - accuracy: 0.1395 - val_loss: 2.4013 - val_accuracy: 0.1509\n", + "Epoch 18/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.3998 - accuracy: 0.1394 \n", + "Epoch 18: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3391s 15s/step - loss: 2.3998 - accuracy: 0.1394 - val_loss: 2.3987 - val_accuracy: 0.1509\n", + "Epoch 19/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.3991 - accuracy: 0.1395 \n", + "Epoch 19: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3483s 15s/step - loss: 2.3991 - accuracy: 0.1395 - val_loss: 2.4005 - val_accuracy: 0.1509\n", + "Epoch 20/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.4009 - accuracy: 0.1373 \n", + "Epoch 20: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3464s 15s/step - loss: 2.4009 - accuracy: 0.1373 - val_loss: 2.3981 - val_accuracy: 0.1503\n", + "Epoch 21/25\n", + "232/232 [==============================] - ETA: 0s - loss: 2.3996 - accuracy: 0.1394 \n", + "Epoch 21: val_accuracy did not improve from 0.15086\n", + "232/232 [==============================] - 3464s 15s/step - loss: 2.3996 - accuracy: 0.1394 - val_loss: 2.3978 - val_accuracy: 0.1509\n", + "Epoch 21: early stopping\n" + ] + } + ], + "source": [ + "from keras.callbacks import ModelCheckpoint, EarlyStopping\n", + "\n", + "checkpoint = ModelCheckpoint(\"vgg16_2.h5\", monitor='val_accuracy', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)\n", + "early = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=20, verbose=1, mode='auto')\n", + "vgg = model.fit_generator(steps_per_epoch=len(train_ds_v), generator=train_ds_v, validation_data= val_ds_v, validation_steps=len(val_ds_v), epochs=25, callbacks=[checkpoint,early])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'vgg' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [11], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpyplot\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mplt\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m plt\u001b[39m.\u001b[39mplot(vgg\u001b[39m.\u001b[39mhistory[\u001b[39m\"\u001b[39m\u001b[39maccuracy\u001b[39m\u001b[39m\"\u001b[39m])\n\u001b[1;32m 3\u001b[0m plt\u001b[39m.\u001b[39mplot(vgg\u001b[39m.\u001b[39mhistory[\u001b[39m'\u001b[39m\u001b[39mval_accuracy\u001b[39m\u001b[39m'\u001b[39m])\n\u001b[1;32m 4\u001b[0m plt\u001b[39m.\u001b[39mplot(vgg\u001b[39m.\u001b[39mhistory[\u001b[39m'\u001b[39m\u001b[39mloss\u001b[39m\u001b[39m'\u001b[39m])\n", + "\u001b[0;31mNameError\u001b[0m: name 'vgg' is not defined" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(vgg.history[\"accuracy\"])\n", + "plt.plot(vgg.history['val_accuracy'])\n", + "plt.plot(vgg.history['loss'])\n", + "plt.plot(vgg.history['val_loss'])\n", + "plt.title(\"Model accuracy\")\n", + "plt.ylabel(\"Value\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.legend([\"Accuracy\",\"Validation Accuracy\",\"Loss\",\"Validation Loss\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'model' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m model\u001b[39m.\u001b[39mevaluate(test_ds_v)\n", + "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined" + ] + } + ], + "source": [ + "model.evaluate(test_ds_v)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ResNet50" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_1\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_2 (InputLayer) [(None, 224, 224, 3 0 [] \n", + " )] \n", + " \n", + " conv1_pad (ZeroPadding2D) (None, 230, 230, 3) 0 ['input_2[0][0]'] \n", + " \n", + " conv1_conv (Conv2D) (None, 112, 112, 64 9472 ['conv1_pad[0][0]'] \n", + " ) \n", + " \n", + " conv1_bn (BatchNormalization) (None, 112, 112, 64 256 ['conv1_conv[0][0]'] \n", + " ) \n", + " \n", + " conv1_relu (Activation) (None, 112, 112, 64 0 ['conv1_bn[0][0]'] \n", + " ) \n", + " \n", + " pool1_pad (ZeroPadding2D) (None, 114, 114, 64 0 ['conv1_relu[0][0]'] \n", + " ) \n", + " \n", + " pool1_pool (MaxPooling2D) (None, 56, 56, 64) 0 ['pool1_pad[0][0]'] \n", + " \n", + " conv2_block1_1_conv (Conv2D) (None, 56, 56, 64) 4160 ['pool1_pool[0][0]'] \n", + " \n", + " conv2_block1_1_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block1_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block1_1_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block1_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv2_block1_2_conv (Conv2D) (None, 56, 56, 64) 36928 ['conv2_block1_1_relu[0][0]'] \n", + " \n", + " conv2_block1_2_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block1_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block1_2_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block1_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv2_block1_0_conv (Conv2D) (None, 56, 56, 256) 16640 ['pool1_pool[0][0]'] \n", + " \n", + " conv2_block1_3_conv (Conv2D) (None, 56, 56, 256) 16640 ['conv2_block1_2_relu[0][0]'] \n", + " \n", + " conv2_block1_0_bn (BatchNormal (None, 56, 56, 256) 1024 ['conv2_block1_0_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block1_3_bn (BatchNormal (None, 56, 56, 256) 1024 ['conv2_block1_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block1_add (Add) (None, 56, 56, 256) 0 ['conv2_block1_0_bn[0][0]', \n", + " 'conv2_block1_3_bn[0][0]'] \n", + " \n", + " conv2_block1_out (Activation) (None, 56, 56, 256) 0 ['conv2_block1_add[0][0]'] \n", + " \n", + " conv2_block2_1_conv (Conv2D) (None, 56, 56, 64) 16448 ['conv2_block1_out[0][0]'] \n", + " \n", + " conv2_block2_1_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block2_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block2_1_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block2_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv2_block2_2_conv (Conv2D) (None, 56, 56, 64) 36928 ['conv2_block2_1_relu[0][0]'] \n", + " \n", + " conv2_block2_2_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block2_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block2_2_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block2_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv2_block2_3_conv (Conv2D) (None, 56, 56, 256) 16640 ['conv2_block2_2_relu[0][0]'] \n", + " \n", + " conv2_block2_3_bn (BatchNormal (None, 56, 56, 256) 1024 ['conv2_block2_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block2_add (Add) (None, 56, 56, 256) 0 ['conv2_block1_out[0][0]', \n", + " 'conv2_block2_3_bn[0][0]'] \n", + " \n", + " conv2_block2_out (Activation) (None, 56, 56, 256) 0 ['conv2_block2_add[0][0]'] \n", + " \n", + " conv2_block3_1_conv (Conv2D) (None, 56, 56, 64) 16448 ['conv2_block2_out[0][0]'] \n", + " \n", + " conv2_block3_1_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block3_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block3_1_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block3_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv2_block3_2_conv (Conv2D) (None, 56, 56, 64) 36928 ['conv2_block3_1_relu[0][0]'] \n", + " \n", + " conv2_block3_2_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block3_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block3_2_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block3_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv2_block3_3_conv (Conv2D) (None, 56, 56, 256) 16640 ['conv2_block3_2_relu[0][0]'] \n", + " \n", + " conv2_block3_3_bn (BatchNormal (None, 56, 56, 256) 1024 ['conv2_block3_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv2_block3_add (Add) (None, 56, 56, 256) 0 ['conv2_block2_out[0][0]', \n", + " 'conv2_block3_3_bn[0][0]'] \n", + " \n", + " conv2_block3_out (Activation) (None, 56, 56, 256) 0 ['conv2_block3_add[0][0]'] \n", + " \n", + " conv3_block1_1_conv (Conv2D) (None, 28, 28, 128) 32896 ['conv2_block3_out[0][0]'] \n", + " \n", + " conv3_block1_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block1_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block1_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block1_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block1_2_conv (Conv2D) (None, 28, 28, 128) 147584 ['conv3_block1_1_relu[0][0]'] \n", + " \n", + " conv3_block1_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block1_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block1_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block1_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block1_0_conv (Conv2D) (None, 28, 28, 512) 131584 ['conv2_block3_out[0][0]'] \n", + " \n", + " conv3_block1_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block1_2_relu[0][0]'] \n", + " \n", + " conv3_block1_0_bn (BatchNormal (None, 28, 28, 512) 2048 ['conv3_block1_0_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block1_3_bn (BatchNormal (None, 28, 28, 512) 2048 ['conv3_block1_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block1_add (Add) (None, 28, 28, 512) 0 ['conv3_block1_0_bn[0][0]', \n", + " 'conv3_block1_3_bn[0][0]'] \n", + " \n", + " conv3_block1_out (Activation) (None, 28, 28, 512) 0 ['conv3_block1_add[0][0]'] \n", + " \n", + " conv3_block2_1_conv (Conv2D) (None, 28, 28, 128) 65664 ['conv3_block1_out[0][0]'] \n", + " \n", + " conv3_block2_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block2_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block2_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block2_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block2_2_conv (Conv2D) (None, 28, 28, 128) 147584 ['conv3_block2_1_relu[0][0]'] \n", + " \n", + " conv3_block2_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block2_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block2_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block2_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block2_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block2_2_relu[0][0]'] \n", + " \n", + " conv3_block2_3_bn (BatchNormal (None, 28, 28, 512) 2048 ['conv3_block2_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block2_add (Add) (None, 28, 28, 512) 0 ['conv3_block1_out[0][0]', \n", + " 'conv3_block2_3_bn[0][0]'] \n", + " \n", + " conv3_block2_out (Activation) (None, 28, 28, 512) 0 ['conv3_block2_add[0][0]'] \n", + " \n", + " conv3_block3_1_conv (Conv2D) (None, 28, 28, 128) 65664 ['conv3_block2_out[0][0]'] \n", + " \n", + " conv3_block3_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block3_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block3_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block3_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block3_2_conv (Conv2D) (None, 28, 28, 128) 147584 ['conv3_block3_1_relu[0][0]'] \n", + " \n", + " conv3_block3_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block3_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block3_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block3_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block3_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block3_2_relu[0][0]'] \n", + " \n", + " conv3_block3_3_bn (BatchNormal (None, 28, 28, 512) 2048 ['conv3_block3_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block3_add (Add) (None, 28, 28, 512) 0 ['conv3_block2_out[0][0]', \n", + " 'conv3_block3_3_bn[0][0]'] \n", + " \n", + " conv3_block3_out (Activation) (None, 28, 28, 512) 0 ['conv3_block3_add[0][0]'] \n", + " \n", + " conv3_block4_1_conv (Conv2D) (None, 28, 28, 128) 65664 ['conv3_block3_out[0][0]'] \n", + " \n", + " conv3_block4_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block4_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block4_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block4_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block4_2_conv (Conv2D) (None, 28, 28, 128) 147584 ['conv3_block4_1_relu[0][0]'] \n", + " \n", + " conv3_block4_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block4_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block4_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block4_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv3_block4_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block4_2_relu[0][0]'] \n", + " \n", + " conv3_block4_3_bn (BatchNormal (None, 28, 28, 512) 2048 ['conv3_block4_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv3_block4_add (Add) (None, 28, 28, 512) 0 ['conv3_block3_out[0][0]', \n", + " 'conv3_block4_3_bn[0][0]'] \n", + " \n", + " conv3_block4_out (Activation) (None, 28, 28, 512) 0 ['conv3_block4_add[0][0]'] \n", + " \n", + " conv4_block1_1_conv (Conv2D) (None, 14, 14, 256) 131328 ['conv3_block4_out[0][0]'] \n", + " \n", + " conv4_block1_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block1_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block1_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block1_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block1_2_conv (Conv2D) (None, 14, 14, 256) 590080 ['conv4_block1_1_relu[0][0]'] \n", + " \n", + " conv4_block1_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block1_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block1_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block1_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block1_0_conv (Conv2D) (None, 14, 14, 1024 525312 ['conv3_block4_out[0][0]'] \n", + " ) \n", + " \n", + " conv4_block1_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block1_2_relu[0][0]'] \n", + " ) \n", + " \n", + " conv4_block1_0_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block1_0_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block1_3_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block1_3_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block1_add (Add) (None, 14, 14, 1024 0 ['conv4_block1_0_bn[0][0]', \n", + " ) 'conv4_block1_3_bn[0][0]'] \n", + " \n", + " conv4_block1_out (Activation) (None, 14, 14, 1024 0 ['conv4_block1_add[0][0]'] \n", + " ) \n", + " \n", + " conv4_block2_1_conv (Conv2D) (None, 14, 14, 256) 262400 ['conv4_block1_out[0][0]'] \n", + " \n", + " conv4_block2_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block2_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block2_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block2_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block2_2_conv (Conv2D) (None, 14, 14, 256) 590080 ['conv4_block2_1_relu[0][0]'] \n", + " \n", + " conv4_block2_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block2_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block2_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block2_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block2_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block2_2_relu[0][0]'] \n", + " ) \n", + " \n", + " conv4_block2_3_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block2_3_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block2_add (Add) (None, 14, 14, 1024 0 ['conv4_block1_out[0][0]', \n", + " ) 'conv4_block2_3_bn[0][0]'] \n", + " \n", + " conv4_block2_out (Activation) (None, 14, 14, 1024 0 ['conv4_block2_add[0][0]'] \n", + " ) \n", + " \n", + " conv4_block3_1_conv (Conv2D) (None, 14, 14, 256) 262400 ['conv4_block2_out[0][0]'] \n", + " \n", + " conv4_block3_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block3_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block3_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block3_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block3_2_conv (Conv2D) (None, 14, 14, 256) 590080 ['conv4_block3_1_relu[0][0]'] \n", + " \n", + " conv4_block3_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block3_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block3_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block3_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block3_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block3_2_relu[0][0]'] \n", + " ) \n", + " \n", + " conv4_block3_3_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block3_3_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block3_add (Add) (None, 14, 14, 1024 0 ['conv4_block2_out[0][0]', \n", + " ) 'conv4_block3_3_bn[0][0]'] \n", + " \n", + " conv4_block3_out (Activation) (None, 14, 14, 1024 0 ['conv4_block3_add[0][0]'] \n", + " ) \n", + " \n", + " conv4_block4_1_conv (Conv2D) (None, 14, 14, 256) 262400 ['conv4_block3_out[0][0]'] \n", + " \n", + " conv4_block4_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block4_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block4_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block4_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block4_2_conv (Conv2D) (None, 14, 14, 256) 590080 ['conv4_block4_1_relu[0][0]'] \n", + " \n", + " conv4_block4_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block4_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block4_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block4_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block4_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block4_2_relu[0][0]'] \n", + " ) \n", + " \n", + " conv4_block4_3_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block4_3_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block4_add (Add) (None, 14, 14, 1024 0 ['conv4_block3_out[0][0]', \n", + " ) 'conv4_block4_3_bn[0][0]'] \n", + " \n", + " conv4_block4_out (Activation) (None, 14, 14, 1024 0 ['conv4_block4_add[0][0]'] \n", + " ) \n", + " \n", + " conv4_block5_1_conv (Conv2D) (None, 14, 14, 256) 262400 ['conv4_block4_out[0][0]'] \n", + " \n", + " conv4_block5_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block5_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block5_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block5_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block5_2_conv (Conv2D) (None, 14, 14, 256) 590080 ['conv4_block5_1_relu[0][0]'] \n", + " \n", + " conv4_block5_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block5_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block5_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block5_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block5_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block5_2_relu[0][0]'] \n", + " ) \n", + " \n", + " conv4_block5_3_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block5_3_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block5_add (Add) (None, 14, 14, 1024 0 ['conv4_block4_out[0][0]', \n", + " ) 'conv4_block5_3_bn[0][0]'] \n", + " \n", + " conv4_block5_out (Activation) (None, 14, 14, 1024 0 ['conv4_block5_add[0][0]'] \n", + " ) \n", + " \n", + " conv4_block6_1_conv (Conv2D) (None, 14, 14, 256) 262400 ['conv4_block5_out[0][0]'] \n", + " \n", + " conv4_block6_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block6_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block6_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block6_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block6_2_conv (Conv2D) (None, 14, 14, 256) 590080 ['conv4_block6_1_relu[0][0]'] \n", + " \n", + " conv4_block6_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block6_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv4_block6_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block6_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv4_block6_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block6_2_relu[0][0]'] \n", + " ) \n", + " \n", + " conv4_block6_3_bn (BatchNormal (None, 14, 14, 1024 4096 ['conv4_block6_3_conv[0][0]'] \n", + " ization) ) \n", + " \n", + " conv4_block6_add (Add) (None, 14, 14, 1024 0 ['conv4_block5_out[0][0]', \n", + " ) 'conv4_block6_3_bn[0][0]'] \n", + " \n", + " conv4_block6_out (Activation) (None, 14, 14, 1024 0 ['conv4_block6_add[0][0]'] \n", + " ) \n", + " \n", + " conv5_block1_1_conv (Conv2D) (None, 7, 7, 512) 524800 ['conv4_block6_out[0][0]'] \n", + " \n", + " conv5_block1_1_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block1_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block1_1_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block1_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv5_block1_2_conv (Conv2D) (None, 7, 7, 512) 2359808 ['conv5_block1_1_relu[0][0]'] \n", + " \n", + " conv5_block1_2_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block1_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block1_2_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block1_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv5_block1_0_conv (Conv2D) (None, 7, 7, 2048) 2099200 ['conv4_block6_out[0][0]'] \n", + " \n", + " conv5_block1_3_conv (Conv2D) (None, 7, 7, 2048) 1050624 ['conv5_block1_2_relu[0][0]'] \n", + " \n", + " conv5_block1_0_bn (BatchNormal (None, 7, 7, 2048) 8192 ['conv5_block1_0_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block1_3_bn (BatchNormal (None, 7, 7, 2048) 8192 ['conv5_block1_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block1_add (Add) (None, 7, 7, 2048) 0 ['conv5_block1_0_bn[0][0]', \n", + " 'conv5_block1_3_bn[0][0]'] \n", + " \n", + " conv5_block1_out (Activation) (None, 7, 7, 2048) 0 ['conv5_block1_add[0][0]'] \n", + " \n", + " conv5_block2_1_conv (Conv2D) (None, 7, 7, 512) 1049088 ['conv5_block1_out[0][0]'] \n", + " \n", + " conv5_block2_1_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block2_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block2_1_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block2_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv5_block2_2_conv (Conv2D) (None, 7, 7, 512) 2359808 ['conv5_block2_1_relu[0][0]'] \n", + " \n", + " conv5_block2_2_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block2_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block2_2_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block2_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv5_block2_3_conv (Conv2D) (None, 7, 7, 2048) 1050624 ['conv5_block2_2_relu[0][0]'] \n", + " \n", + " conv5_block2_3_bn (BatchNormal (None, 7, 7, 2048) 8192 ['conv5_block2_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block2_add (Add) (None, 7, 7, 2048) 0 ['conv5_block1_out[0][0]', \n", + " 'conv5_block2_3_bn[0][0]'] \n", + " \n", + " conv5_block2_out (Activation) (None, 7, 7, 2048) 0 ['conv5_block2_add[0][0]'] \n", + " \n", + " conv5_block3_1_conv (Conv2D) (None, 7, 7, 512) 1049088 ['conv5_block2_out[0][0]'] \n", + " \n", + " conv5_block3_1_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block3_1_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block3_1_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block3_1_bn[0][0]'] \n", + " n) \n", + " \n", + " conv5_block3_2_conv (Conv2D) (None, 7, 7, 512) 2359808 ['conv5_block3_1_relu[0][0]'] \n", + " \n", + " conv5_block3_2_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block3_2_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block3_2_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block3_2_bn[0][0]'] \n", + " n) \n", + " \n", + " conv5_block3_3_conv (Conv2D) (None, 7, 7, 2048) 1050624 ['conv5_block3_2_relu[0][0]'] \n", + " \n", + " conv5_block3_3_bn (BatchNormal (None, 7, 7, 2048) 8192 ['conv5_block3_3_conv[0][0]'] \n", + " ization) \n", + " \n", + " conv5_block3_add (Add) (None, 7, 7, 2048) 0 ['conv5_block2_out[0][0]', \n", + " 'conv5_block3_3_bn[0][0]'] \n", + " \n", + " conv5_block3_out (Activation) (None, 7, 7, 2048) 0 ['conv5_block3_add[0][0]'] \n", + " \n", + " flatten_1 (Flatten) (None, 100352) 0 ['conv5_block3_out[0][0]'] \n", + " \n", + " dense_1 (Dense) (None, 12) 1204236 ['flatten_1[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 24,791,948\n", + "Trainable params: 1,204,236\n", + "Non-trainable params: 23,587,712\n", + "__________________________________________________________________________________________________\n" + ] + } + ], + "source": [ + "from keras.layers import Input, Lambda, Dense, Flatten\n", + "from keras.models import Model\n", + "from keras.applications import ResNet50\n", + "from keras.preprocessing import image\n", + "from keras.preprocessing.image import ImageDataGenerator\n", + "from keras.models import Sequential\n", + "import numpy as np\n", + "from glob import glob\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# re-size all the images to this\n", + "IMAGE_SIZE = [224, 224]\n", + "\n", + "# add preprocessing layer to the front of resnet\n", + "resnet = ResNet50(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False)\n", + "\n", + "# don't train existing weights\n", + "for layer in resnet.layers:\n", + " layer.trainable = False\n", + " \n", + " # useful for getting number of classes\n", + "classes = 12\n", + " \n", + "\n", + "# our layers - you can add more if you want\n", + "x = Flatten()(resnet.output)\n", + "# x = Dense(1000, activation='relu')(x)\n", + "prediction = Dense(12, activation='softmax')(x)\n", + "\n", + "# create a model object\n", + "model_resnet = Model(inputs=resnet.input, outputs=prediction)\n", + "\n", + "# view the structure of the model\n", + "model_resnet.summary()\n", + "\n", + "# tell the model what cost and optimization method to use\n", + "model_resnet.compile(\n", + " loss='sparse_categorical_crossentropy',\n", + " optimizer='adam',\n", + " metrics=['accuracy']\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: 7430\n", + "Test: 2323\n", + "Validation: 1858\n" + ] + } + ], + "source": [ + "train_ds_r, test_ds_r, val_ds_r = prepare_data('./plantvillage/color', img_size=IMAGE_SIZE, test_size=0.2, val_size=0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/_h/ljwht4gd7lb99rm1hm78h7_00000gn/T/ipykernel_39241/1735889553.py:1: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", + " r = model_resnet.fit_generator(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "232/232 [==============================] - 297s 1s/step - loss: 0.6232 - accuracy: 0.8380 - val_loss: 1.2547 - val_accuracy: 0.7328\n", + "Epoch 2/25\n", + "232/232 [==============================] - 277s 1s/step - loss: 0.4919 - accuracy: 0.8611 - val_loss: 0.8189 - val_accuracy: 0.8308\n", + "Epoch 3/25\n", + "232/232 [==============================] - 299s 1s/step - loss: 0.6947 - accuracy: 0.8382 - val_loss: 0.5326 - val_accuracy: 0.8518\n", + "Epoch 4/25\n", + "232/232 [==============================] - 306s 1s/step - loss: 0.6153 - accuracy: 0.8599 - val_loss: 1.1360 - val_accuracy: 0.7710\n", + "Epoch 5/25\n", + "232/232 [==============================] - 311s 1s/step - loss: 0.5149 - accuracy: 0.8689 - val_loss: 1.3260 - val_accuracy: 0.7780\n", + "Epoch 6/25\n", + "232/232 [==============================] - 313s 1s/step - loss: 0.6220 - accuracy: 0.8462 - val_loss: 0.8199 - val_accuracy: 0.8233\n", + "Epoch 7/25\n", + "232/232 [==============================] - 318s 1s/step - loss: 0.6513 - accuracy: 0.8412 - val_loss: 1.1632 - val_accuracy: 0.7457\n", + "Epoch 8/25\n", + "232/232 [==============================] - 320s 1s/step - loss: 0.5098 - accuracy: 0.8623 - val_loss: 0.8247 - val_accuracy: 0.8006\n", + "Epoch 9/25\n", + "232/232 [==============================] - 323s 1s/step - loss: 0.5930 - accuracy: 0.8493 - val_loss: 0.4964 - val_accuracy: 0.8761\n", + "Epoch 10/25\n", + "232/232 [==============================] - 324s 1s/step - loss: 0.5482 - accuracy: 0.8661 - val_loss: 0.8474 - val_accuracy: 0.8109\n", + "Epoch 11/25\n", + "232/232 [==============================] - 322s 1s/step - loss: 0.5106 - accuracy: 0.8668 - val_loss: 1.2926 - val_accuracy: 0.7629\n", + "Epoch 12/25\n", + "232/232 [==============================] - 322s 1s/step - loss: 0.5876 - accuracy: 0.8579 - val_loss: 1.0667 - val_accuracy: 0.7812\n", + "Epoch 13/25\n", + "232/232 [==============================] - 323s 1s/step - loss: 0.6110 - accuracy: 0.8560 - val_loss: 0.5787 - val_accuracy: 0.8545\n", + "Epoch 14/25\n", + "232/232 [==============================] - 323s 1s/step - loss: 0.5797 - accuracy: 0.8524 - val_loss: 0.6400 - val_accuracy: 0.8658\n", + "Epoch 15/25\n", + "232/232 [==============================] - 326s 1s/step - loss: 0.4589 - accuracy: 0.8759 - val_loss: 0.6950 - val_accuracy: 0.8400\n", + "Epoch 16/25\n", + "232/232 [==============================] - 324s 1s/step - loss: 0.5822 - accuracy: 0.8700 - val_loss: 1.4940 - val_accuracy: 0.7678\n", + "Epoch 17/25\n", + "232/232 [==============================] - 322s 1s/step - loss: 0.4404 - accuracy: 0.8827 - val_loss: 1.5049 - val_accuracy: 0.7559\n", + "Epoch 18/25\n", + "232/232 [==============================] - 321s 1s/step - loss: 0.6142 - accuracy: 0.8598 - val_loss: 0.8974 - val_accuracy: 0.8060\n", + "Epoch 19/25\n", + "232/232 [==============================] - 322s 1s/step - loss: 0.5486 - accuracy: 0.8677 - val_loss: 1.5655 - val_accuracy: 0.7753\n", + "Epoch 20/25\n", + "232/232 [==============================] - 326s 1s/step - loss: 0.3964 - accuracy: 0.8947 - val_loss: 0.7896 - val_accuracy: 0.8292\n", + "Epoch 21/25\n", + "232/232 [==============================] - 324s 1s/step - loss: 0.4499 - accuracy: 0.8848 - val_loss: 1.7746 - val_accuracy: 0.7150\n", + "Epoch 22/25\n", + "232/232 [==============================] - 323s 1s/step - loss: 0.4320 - accuracy: 0.8817 - val_loss: 1.2487 - val_accuracy: 0.7974\n", + "Epoch 23/25\n", + "232/232 [==============================] - 322s 1s/step - loss: 0.4307 - accuracy: 0.8844 - val_loss: 0.6485 - val_accuracy: 0.8470\n", + "Epoch 24/25\n", + "232/232 [==============================] - 322s 1s/step - loss: 0.4287 - accuracy: 0.8900 - val_loss: 1.5260 - val_accuracy: 0.7586\n", + "Epoch 25/25\n", + "232/232 [==============================] - 323s 1s/step - loss: 0.6704 - accuracy: 0.8482 - val_loss: 0.7494 - val_accuracy: 0.8287\n" + ] + } + ], + "source": [ + "r = model_resnet.fit_generator(\n", + " train_ds_r,\n", + " validation_data=val_ds_r,\n", + " epochs=25,\n", + " steps_per_epoch=len(train_ds_r),\n", + " validation_steps=len(val_ds_r)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# loss\n", + "plt.plot(r.history['loss'], label='train loss')\n", + "plt.plot(r.history['val_loss'], label='val loss')\n", + "plt.legend()\n", + "plt.show()\n", + "plt.savefig('LossVal_loss')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGdCAYAAAAbudkLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACjcklEQVR4nOydeXhTdfaH3yTd95ZCS6FQdmTfkUVFQcEFN9xAZVFxGdBRxpkRR8Xlpzg6wzA6uIwD7gy44L6MiIIiq2VRZF8LLW1pS/c9ye+P25uk0C1tkntvet7n6ZPb5Obeb9I0+eSczznHZLfb7QiCIAiCIPghZq0XIAiCIAiC4C1E6AiCIAiC4LeI0BEEQRAEwW8RoSMIgiAIgt8iQkcQBEEQBL9FhI4gCIIgCH6LCB1BEARBEPwWETqCIAiCIPgtAVovwFfYbDYyMjKIjIzEZDJpvRxBEARBEJqA3W6nqKiIpKQkzGb34zOtRuhkZGSQnJys9TIEQRAEQWgGx48fp2PHjm7fr9UIncjISEB5oqKiojRejSAIgiAITaGwsJDk5GTH57i7NEvoLFmyhOeff57MzEwGDhzIiy++yIgRI+rct6qqioULF/Lmm2+Snp5Or169+Otf/8qkSZPcOmZ5eTl/+MMfWLFiBRUVFUycOJGXXnqJhISEJq1ZTVdFRUWJ0BEEQRAEg9Fc24nbya6VK1cyb948FixYwLZt2xg4cCATJ04kOzu7zv0feeQRXn31VV588UV2797N3XffzTXXXMP27dvdOuYDDzzAZ599xvvvv8+6devIyMjg2muvbcZDFgRBEAShtWByd3r5yJEjGT58OP/6178AxeSbnJzMvffey0MPPXTW/klJSfzlL39hzpw5juumTJlCaGgo77zzTpOOWVBQQNu2bVm+fDnXXXcdAHv37uWcc85h48aNnHvuuY2uu7CwkOjoaAoKCiSiIwiCIAgGoaWf325FdCorK0lNTWXChAnOA5jNTJgwgY0bN9Z5n4qKCkJCQmpdFxoayvr165t8zNTUVKqqqmrt07t3bzp16lTveQVBEARBENzy6OTk5GC1Ws/yxSQkJLB379467zNx4kQWLVrE+eefT7du3VizZg2rVq3CarU2+ZiZmZkEBQURExNz1j6ZmZl1nreiooKKigrH74WFhY0+PrvdTnV1tWNtgr6xWCwEBARIuwBBEAShXrxedfXPf/6T2bNn07t3b0wmE926dWPWrFksW7bMq+dduHAhTzzxRJP3r6ys5OTJk5SWlnpxVYKnCQsLo3379gQFBWm9FEEQBEGHuCV04uPjsVgsZGVl1bo+KyuLxMTEOu/Ttm1bPv74Y8rLy8nNzSUpKYmHHnqIrl27NvmYiYmJVFZWkp+fXyuq09B558+fz7x58xy/q+VpdWGz2Thy5AgWi4WkpCSCgoIkSqBz7HY7lZWVnDp1iiNHjtCjR49mNZISBEEQ/Bu3hE5QUBBDhw5lzZo1XH311YAiEtasWcPcuXMbvG9ISAgdOnSgqqqKDz/8kBtuuKHJxxw6dCiBgYGsWbOGKVOmALBv3z7S0tIYNWpUnecLDg4mODi4SY+rsrLSYYAOCwtr0n0E7QkNDSUwMJBjx45RWVl5lhdMEARBENxOXc2bN48ZM2YwbNgwRowYweLFiykpKWHWrFkATJ8+nQ4dOrBw4UIANm/eTHp6OoMGDSI9PZ3HH38cm83Gn/70pyYfMzo6mttvv5158+YRFxdHVFQU9957L6NGjWpSxVVTkYiA8ZC/mSAIgtAQbgudG2+8kVOnTvHYY4+RmZnJoEGD+Prrrx1m4rS0tFofPuXl5TzyyCMcPnyYiIgILrvsMt5+++1aKajGjgnwj3/8A7PZzJQpU2o1DBQEQRAEQagPt/voGJWG6vDLy8s5cuQIXbp0kfSHwZC/nSAIgn/j0z46gv+TkpLC4sWLtV6GIAiCIHiEVjPU018ZN24cgwYN8pg42bp1K+Hh4R45liAIgiBojUR0WgFqI8Sm0LZtW6k8EwTBsFRbbby67hDb005rvRRBJ4jQqQe73U5pZbUmP021Tc2cOZN169bxz3/+E5PJhMlk4ujRo6xduxaTycRXX33F0KFDCQ4OZv369Rw6dIirrrqKhIQEIiIiGD58ON9++22tY56ZujKZTPznP//hmmuuISwsjB49evDpp582uK63336bYcOGERkZSWJiItOmTTtr6Otvv/3GFVdcQVRUFJGRkZx33nkcOnTIcfuyZcvo27cvwcHBtG/fvtH2BYIgCACrtqWz8Ku93PjvTazdV/ewaaF1IamreiirstLnsf9pcu7dT04kLKjxP80///lP9u/fT79+/XjyyScBJSJz9OhRAB566CH+9re/0bVrV2JjYzl+/DiXXXYZTz/9NMHBwbz11ltMnjyZffv20alTp3rP88QTT/Dcc8/x/PPP8+KLL3LzzTdz7Ngx4uLi6ty/qqqKp556il69epGdnc28efOYOXMmX375JQDp6emcf/75jBs3ju+++46oqCh++uknR9Tp5ZdfZt68eTz77LNceumlFBQU8NNPP7nzFAqC0Er5IPUEAJXVNu58K5WXbh7ChD4JjdxL8GdE6BiY6OhogoKCCAsLq7ND9JNPPsnFF1/s+D0uLo6BAwc6fn/qqaf46KOP+PTTTxuMmMycOZOpU6cC8Mwzz/DCCy+wZcsWJk2aVOf+t912m2O7a9euvPDCCwwfPpzi4mIiIiJYsmQJ0dHRrFixgsDAQAB69uzpuM///d//8Yc//IHf//73juuGDx/e2NMhCEIr51huCVuO5mE2wXk92rJu/ynueTeVF6cOYVK/urvoC/6PCJ16CA20sPvJiZqd2xMMGzas1u/FxcU8/vjjfPHFF5w8eZLq6mrKyspIS0tr8DgDBgxwbIeHhxMVFXVWKsqV1NRUHn/8cXbu3Mnp06ex2WyA0mOpT58+7Nixg/POO88hclzJzs4mIyOD8ePHu/NQBUEQ+HBbOgBje7Rl6YxhPPDeTj7bmcGc5dt44abBXD6gvcYrFLRAhE49mEymJqWP9MyZ1VMPPvggq1ev5m9/+xvdu3cnNDSU6667jsrKygaPc6YgMZlMDvFyJiUlJUycOJGJEyfy7rvv0rZtW9LS0pg4caLjPKGhofWeq6HbBEEQ6sNms/NhTdpqypAOBFjM/OOGgQSYTXy0PZ17/7uNatsgrhrUQeOVCr5GzMgGJygoCKvV2qR9f/rpJ2bOnMk111xD//79SUxMdPh5PMXevXvJzc3l2Wef5bzzzqN3795nRX8GDBjAjz/+SFVV1Vn3j4yMJCUlhTVr1nh0XYIg+Debj+SRnl9GZHAAE/sqaaoAi5m/XT+Q64d2xGaHB1bucHh4hNaDCB2Dk5KSwubNmzl69Cg5OTn1RloAevTowapVq9ixYwc7d+5k2rRpDe7fHDp16kRQUBAvvvgihw8f5tNPP+Wpp56qtc/cuXMpLCzkpptu4ueff+bAgQO8/fbb7Nu3D4DHH3+cv//977zwwgscOHCAbdu28eKLL3p0nYIg+BeqgLliYHtCXNL/FrOJv04ZwNQRnbDZ4Y8f7GTl1obT9YJ/IULH4Dz44INYLBb69OnjSBPVx6JFi4iNjWX06NFMnjyZiRMnMmTIEI+up23btrzxxhu8//779OnTh2effZa//e1vtfZp06YN3333HcXFxVxwwQUMHTqU1157zZEimzFjBosXL+all16ib9++XHHFFRw4cMCj6xQEwX8oqajmq10nAbhuaMezbjebTTxzTT+mj+qM3Q5//vBX3tl0zNfLFDRCZl0h85KMjPztBEH4IPUED76/ky7x4Xz3hwswmUx17me323nq8z0s++kIAI9P7sPMMV18uVRdcTC7mNd/OsKAjtHcOLz+FiNa09JZV8Z22wqCIAitHtWEfO3gDvWKHFAKKR694hwCA0y8uu4wj3+2m2qbnTvO6+qrpeqCU0UVLP52Pyu2Hsdqs/PezyauGtShVsrPnxChIwiCIBiW43mlbDyci8kE19aRtjoTk8nEQ5N6E2Qx8+J3B/m/L/ZQabXxu3HdfbBabSmtrOY/Px7h1XWHKKlUilgsZhNVVjvb0/IZ1a2Nxiv0DuLREQRBEAzLR9uV3jmjurahQ0zT2lOYTCb+cEkvHpigNCp97ut9/PNb//UBWm12VmxJY9zza1m0ej8llVYGdoxmxZ3ncll/pbfQliN5Gq/Se0hERxAEQTAkdrudD7cpaau6TMiN8fsJPQiwmHj+f/v4x7f7qbbZmHdxzwbTX0bCbrezdt8pFn61h/1ZxQAkx4Xyx4m9uaJ/e8xmEweyivhsZwZbj4rQEQRBEARd8fOx0xzLLSU8yNLsEQ9zLuxOoMXEM1/u5cXvDlJltfPnSb0ML3Z2pRfwzJd72HAoF4Do0EDuvag7t47qTHCA04szoouSrko9dpoqq41Ai/8lekToCIIgCIZENSFf1r99izrZ33l+NwItZp74bDevrDtEtdXGXy4/x5Bi58TpUv7+zX5HSi8owMys0Sn8blx3osPOHrvTo10E0aGBFJRV8VtGIYOSY3y8Yu8jQkcQBEEwHGWVVj7/RemdM6UZaaszmTWmCwEWM49+vIv/rD9CldXG41f2NYzYKSit4qW1B3l9w1Eqq5VGsFcPSuLBib3oGBtW7/3MZhPDU+L4dk8WW47kitARBEEQBD3wze5MiiuqSY4LZURKnEeOeeu5nQk0m5j/0a+8ufEYVTY7/3dVP8xm/Yqdimorb288xr++P0h+qTJWZ3S3Njx82Tn06xDdpGOM6BJbI3TyuPP8bt5criaI0BFISUnh/vvv5/7779d6KYIgCE3iA0fvnI4eFSI3jehEgMXMHz/YyfLNaVRbbSy8dgAWnYkdu93O57+c5Ln/7eV4XhkAPRMimH/pOYzr1datSJTq09l69DQ2m13Xwq45iNARBEEQDMXJgjLWH8wBYMqQlqetzuS6oR0JMJuY994O3vv5BGv2ZHNR73Zc3CeB83q0JTRIu8Z6xRXVbDiYw5K1h9h5PB+AdpHB/OGSnkwZ0pGAZpiJ+yZFERZkoaCsiv3ZRfROdL/7sJ4RoSMIgiAYilXb0rHbYUSXODq1qd9/0hKuHtyBoAAzD3/0K7kllbyfeoL3U08QEmhmbPe2XNynHePPSSA+Itgr51epttrYeSKfHw/k8NPBHLan5VNtUyY3hQdZuOuCbtxxXpcWmbEDLWaGdIpl/cEcth7J8zuh4391ZK2If//73yQlJZ01gfyqq67itttuA+DQoUNcddVVJCQkEBERwfDhw/n222/dOs/WrVu5+OKLiY+PJzo6mgsuuIBt27bV2ic/P5+77rqLhIQEQkJC6NevH59//rnj9p9++olx48YRFhZGbGwsEydO5PTp08185IIgtFZa2jvHHS7r356tf5nA8tkjmTUmhY6xoZRX2fh2TxZ//vBXhj/9LVNe3sAr6w5x6FSxR85pt9s5mF3MmxuOcsebPzP4ydVMeXkji789wNajp6m22encJow7xnZh7R8v5L7xPVokclRGdFF8Tpv9sHGgRHTqw26HqlJtzh0YBk3Ir15//fXce++9fP/994wfPx6AvLw8vv76a7788ksAiouLueyyy3j66acJDg7mrbfeYvLkyezbt49OnZo2xK2oqIgZM2bw4osvYrfb+fvf/85ll13GgQMHiIyMxGazcemll1JUVMQ777xDt27d2L17NxaLEt7dsWMH48eP57bbbuOf//wnAQEBfP/991it1mY+QYIgNBe73U5BWRUxYUFaL6VZbD+ez+FTJYQGWhxdfb1JoMXM6G7xjO4Wz2NX9GFvZhGrd2exencWv6YXkHrsNKnHTvPsV3vp2jaci/skcEmfBAYlxzbZ15NTXMFPB3NYfyCH9QdzOFlQXuv22LBARnePZ2zNT3Kc56NYw2sM3VuO5GG32w1TbdYUROjUR1UpPJOkzbkfzoCg8EZ3i42N5dJLL2X58uUOofPBBx8QHx/PhRdeCMDAgQMZOHCg4z5PPfUUH330EZ9++ilz585t0nIuuuiiWr//+9//JiYmhnXr1nHFFVfw7bffsmXLFvbs2UPPnkpL9a5dnUPynnvuOYYNG8ZLL73kuK5v375NOrcgCJ7Dbrfzxw9+4YPUE7w+czgX9m6n9ZLcRu2dc2m/RCKCffsRZjKZOKd9FOe0j+K+8T04WVDGt7uz+GZ3FpsO53L4VAmvrjvMq+sOEx8RxPjeCVzcJ4GxPeJrDcwsq7Sy5Wge6w+c4scDOezNLKp1nqAAM8NTYhnbvS1ju8fTNynK6wbhwZ1iCLSYyC6qIC2vlM5tGv8MMgoidAzOzTffzOzZs3nppZcIDg7m3Xff5aabbsJsVrKSxcXFPP7443zxxRecPHmS6upqysrKSEtLa/I5srKyeOSRR1i7di3Z2dlYrVZKS0sdx9ixYwcdO3Z0iJwz2bFjB9dff33LH6wgCC1i6fojjmqlF747YDihU15l5bOdGYBneue0lPbRodw6KoVbR6VQWF7FD/tPsXp3Ft/tzSanuJKVPx9n5c/HCQk0c16PtpzTPoqtR/JIPXaaSmtty0Gf9lGc1yOesT3iGZ4S5/NJ4iGBFgZ2jOHnY6fZfCRPhE6rIDBMiaxode4mMnnyZOx2O1988QXDhw/nxx9/5B//+Ifj9gcffJDVq1fzt7/9je7duxMaGsp1111HZWVlk88xY8YMcnNz+ec//0nnzp0JDg5m1KhRjmOEhjY8SK+x2wVB8D4bDuWw8Ku9jt+3p+WzLe00QzrFargq9/h2TxaF5dUkRYcwqqu+Jm1HhQRyxYAkrhiQRJXVxpYjeY4UV3p+mWNbJSk6hLE94hnboy1jurWhjZdNzU1heJc4fj52mq1H8rhhWLLWy/EYInTqw2RqUvpIa0JCQrj22mt59913OXjwIL169WLIkCGO23/66SdmzpzJNddcAygRnqNHj7p1jp9++omXXnqJyy67DIDjx4+Tk5PjuH3AgAGcOHGC/fv31xnVGTBgAGvWrOGJJ55oxiMUBKGlZOSXce/y7Vhtdq4Z3AGTSalcev2no4YSOo7eOUM82zvH0wRazIzpHs+Y7vEsmNyH3ScLWb07i6M5JQzpHMvY7vF0iQ/XnQ9mRJc4Xl57iC1+NuBThI4fcPPNN3PFFVfw22+/ccstt9S6rUePHqxatYrJkydjMpl49NFHz6rSaowePXrw9ttvM2zYMAoLC/njH/9YK0pzwQUXcP755zNlyhQWLVpE9+7d2bt3LyaTiUmTJjF//nz69+/P7373O+6++26CgoL4/vvvuf7664mPj/fIcyAIQt2UV1m5+51Ucksq6dM+imeu6c/hnGJWbUvny19PMv/S3iTF6D/qml1Yzg/7TwH6SFs1FZPJRN+kaPomNa1LsZYM7RyLyQTHckvJKiwnISpE6yV5BCkv9wMuuugi4uLi2LdvH9OmTat126JFi4iNjWX06NFMnjyZiRMn1or4NIWlS5dy+vRphgwZwq233sp9991Hu3a1c/sffvghw4cPZ+rUqfTp04c//elPjqqqnj178s0337Bz505GjBjBqFGj+OSTTwgIEJ0tCN7Ebrfz6Me7+OVEATFhgbx661BCgyz0TYrm3K5xWG123tp4TOtlNomPtqdjsysfxl3i9R9tNyJRIYH0aa/00NniR2XmJrvdbtd6Eb6gsLCQ6OhoCgoKiIqq3QypvLycI0eO0KVLF0JC/EPBthbkbycI9fP2pmM8+vEuzCZ467aRjO3hjKB+81smd76dSnRoIBvnX+SRXizewm63M3HxD+zPKmbhtf2ZOqJprTEE93nis994/aej3HpuZ566up/WywEa/vxuChLREQRB8ENSj+Xx5Ge/AfCnSb1riRyA8eck0CkujIKyKj7clq7FEpvMr+kF7M8qJjjAzOUDvN87pzWjDkjd6kc+HRE6giAIfkZ2YTl3v7ONKqudy/u3567zu561j8VsYtaYFABe/+kINpt+g/tq75xL+iYSFRKo8Wr8m+E1HZL3ZhaRX9r06lw9I0JHEATBj6istnHPu9s4VVRBz4QInrtuQL3VPdcPSyYyOIDDp0pYd+CUj1faNCqqrXxS0zvH2yMfBIiPCKZrW8UDtfWof4zpEaEjCILgRzz1+W5Sj50mMiSAV28dRngD3YMjggO4YbjSL2XZ+iO+WqJbfL83m/zSKhKighnbXao0fcHILv6VvmqW0FmyZAkpKSmEhIQwcuRItmzZ0uD+ixcvplevXoSGhpKcnMwDDzxAeblzlkdKSgomk+msnzlz5jj2GTdu3Fm333333c1ZviAIgl/y3s/HeXuTUkW1+MZBTapOmjk6BbMJfjyQw/6sokb39zVq75xrBnds8uwooWX424BPt4XOypUrmTdvHgsWLGDbtm0MHDiQiRMnkp2dXef+y5cv56GHHmLBggXs2bOHpUuXsnLlSh5++GHHPlu3buXkyZOOn9WrVwOcNTZg9uzZtfZ77rnn3F1+g7SSAjS/wq//Zmv/Cp/epwyYFQyH3W5n5dY0vt+X7ZPX6S8n8nnk410A3D+hB+PPSWjS/ZLjwrikTyKgeHX0xKmiCr7fp6TUrhvaQePVtB7UAZ+/pRdQUlGt8WpajttCZ9GiRcyePZtZs2bRp08fXnnlFcLCwli2bFmd+2/YsIExY8Ywbdo0UlJSuOSSS5g6dWqtKFDbtm1JTEx0/Hz++ed069aNCy64oNaxwsLCau3XnDKzuggMVMxtpaUaTSsXmo36N1P/hn5DdQWsexa2vQmn9ja+v6A7Pv/lJH/+8Fdmvb6VGa9v5dCpYq+dK6e4grvfTqWy2saEc9px30U93Lr/bWO7AEq35LwS/RhQP9mRjtVmZ2ByDN3bRWq9nFZDx9gwOsSEUm2zsz0tX+vltBi3GidUVlaSmprK/PnzHdeZzWYmTJjAxo0b67zP6NGjeeedd9iyZQsjRozg8OHDfPnll9x66631nuOdd95h3rx5Zxno3n33Xd555x0SExOZPHkyjz76KGFhdc+FqqiooKKiwvF7YWFhvY/LYrEQExPjiEqFhYXprjW3UBu73U5paSnZ2dnExMRgsfh2AJ7XyT8O9poO1jkHoN052q5HcJs3Nhx1bP+w/xSTFv/AbWO6cO/4Hh6dul1ttTF3+TYyCsrpGh/OohsHuT0eYXhKLP07RPNregHLNx9jrptCyVuoZe/XDZFojq8ZnhJL+o4ythzJPas1gdFw678tJycHq9VKQkLtkGhCQgJ799b9rXPatGnk5OQwduxY7HY71dXV3H333bVSV658/PHH5OfnM3PmzLOO07lzZ5KSkvjll1/485//zL59+1i1alWdx1m4cKFbs5USE5XQbX0pOEGfxMTEOP52fsXpo87t3AOaLUNoHrvSC0g9dppAi4nls8/l5bWH+G5vNq/+cJiPtqcz/7LeXD2og0e+UD371V42Hc4jPMjCq7cObVb5tclk4raxKTywcidvbTzGned3IyhA21qV3zIK2HOykCCLmckDkzRdS2tkRJc2fLwjwy/mXnm9FebatWt55plneOmllxg5ciQHDx7k97//PU899RSPPvroWfsvXbqUSy+9lKSk2i/sO++807Hdv39/2rdvz/jx4zl06BDdunU76zjz589n3rx5jt8LCwtJTq5/GqvJZKJ9+/a0a9eOqqqq5jxUwccEBgb6XyRH5bSLVyJHhI7RUKM5l/Vvz/CUOIbPjOO7vVk88dlujuWW8sDKnby7KY3Hr+xLvw7Nn4H0yY50/lNTLfW36wfSI6H56Z3L+yex8Mu9ZBdV8MWvGVwzWNtS7g9TlWjOhD7tiAkL0nQtrRHVkLw9LZ+KaivBAcZ9r3VL6MTHx2OxWMjKyqp1fVZWVr3fqh999FFuvfVW7rjjDkARKSUlJdx555385S9/wWx2fms4duwY3377bb1RGldGjhwJwMGDB+sUOsHBwQQHuz/23mKx+O+Hp2AcXCM6InQMRW5xBZ/W9H2ZMTrFcf1FvRMY3S2epeuP8K/vDvLzsdNM/td6po3oxIOX9CI23L0P890Zhfz5w18AuGdcNy7t37KOwUEBZqaP6szfvtnP0vVHPBZxag5VVhuf7KhJW0nvHE3o1jacNuFB5JZUsiu9gKGd47ReUrNxKzYZFBTE0KFDWbNmjeM6m83GmjVrGDVqVJ33KS0trSVmAIeQOLMS4fXXX6ddu3Zcfvnlja5lx44dALRvL+3ABT/kTKEjlVeGYcXW41RW2xjQMZrByTG1bgsJtDDnwu6s+cMFXDGgPXY7vLs5jQv/vpa3Nx3D2sTuxPmlldz1zs+UV9k4r0c8D17SyyNrnzqiE8EBZnalF/LzMe2axa3dd4rckkriI4I5v0dbzdbRmjGZTI7qK6OXmbudhJ03bx6vvfYab775Jnv27OGee+6hpKSEWbNmATB9+vRaZuXJkyfz8ssvs2LFCo4cOcLq1at59NFHmTx5cq3Iic1m4/XXX2fGjBlnTbU+dOgQTz31FKmpqRw9epRPP/2U6dOnc/755zNgwIDmPnZB0C+uQqeiAEr02bVWqE211cY7NX1sZoxKqTcikhQTyr+mDeG/s8+ld2Ik+aVVPPrxLia/uL7RJm1Wm537VuzgeF4ZHWNDeeGmwR7rL9MmIphrBivG36U/aldq/kHqcQCuGZxEgEX62mqFOg7C6JPM3fbo3HjjjZw6dYrHHnuMzMxMBg0axNdff+0wKKelpdWK4DzyyCOYTCYeeeQR0tPTadu2LZMnT+bpp5+uddxvv/2WtLQ0brvttrPOGRQUxLfffsvixYspKSkhOTmZKVOm8Mgjj7i7fEHQP3a7U+hYgsBaCTn7IaKdpssSGueb3VmcLCinTXgQVwxsPNo8qlsbPr93LO9sOsai1fvZfbKQ61/ZyNWDkph/2TkkRIWcdZ9Fq/fxw/5ThASaefXWoW6nvBrjtrFdWLH1ON/szuR4XinJcXVXtnqLvJJKvturFIVMkbSVpqgdklOPnsZqsxu2YaPJ7tcd15y0dMy7IPiMkhx4vhtggpSxcPRHuGIxDJul9cqERrjh1Y1sOZLH3Au78+BE99JJucUVPP+/faz8+Th2O4QHWbh3fA9uG9PFUQH19a5M7n4nFYB/3jSIqwZ5p+z61qWb+fFADneM7cIjV/Txyjnq442fjvD4Z7vp1yGKz+89z6fnFmpjtdkZ+MQ3FFdU8/m9Y1tknG8JLf38lpigIOgNNZoT1QES+yvbuQc1W47QNPacLGTLkTwsZhO3nNvZ7fu3iQjm2SkD+GTOGAYlx1BSaeXZr/YyafEPrN2XzcHsIv7w3g4AbhvTxWsiRz0+wMqtxyn2cWdctXfOlCESzdEai9nE0M6xgLHnXonQEQS9oQqd2BRo013Zztmv1WqEJvJmTUn5pH6JJEafnXJqKgM6xrDqntE8f90A4iOCOJxTwszXt3L1kg2UVFoZ2SWO+Zf19tCq6+aCnm3p2jacoopq3v/5uFfP5cq+zCJ+TS8g0GLyqpATms4IP/DpiNARBL2h9tCJTYH4nsq2lJjrmvzSSj6uKYee6VJS3lzMZhPXD0vmuwfHcfvYLgSYTRRXVNM+OoQlNw8h0MsGXbPZxKyaqM4bG442uRqspXy4TRngeWGvdsR52HskNI8RLpPMjep0EaEj+JTv92az83i+1svQN64RnfiaVvz5x5T5V4IuWbn1OOVVNvq0j2JYTajfE0SFBPLoFX346vfncc+4brx9+0jiI9zvD9YcpgzpQHRoIMdyS1mzJ6vxO7SQaquNVdukd47eGNAxmqAAMznFlRzOKdF6Oc1ChI7gE2w2O898uYdZb2xl2mubKCiV7tP1kndUuYxNgYgECIpU5l7lHdZyVUI9WG123tqolJTPHF1/SXlL6JEQyZ8n9aZ7uwiPH7s+woICmDqiEwDLfDDV/McDOeQUVxAXHsS4XlJhqBeCAyyOflBGTV+J0BG8TmW1jXnv7eDfPygf1CWVVv67NU3jVekY14iOyeSM6ohPR5d8uyeL9PwyYsMCuXKQf81kmj6qMxaziU2H8/gto8Cr5/qgJm111aAkzedsCbVxpK9E6AjC2RRXVHP7m1v5eEcGAWYTl9e0qX9zw1GqrDaNV6dDqiugUAnfE5uiXDqEjvh09IhqQr5xeCdCAv1rfExSTCiX9lPG+yxbf9Rr5/lsZwbf/JYJSLWVHlGFjlE7JIvQEbzGqaIKbvr3Rn48kENYkIX/zBjG328YSHxEECcLyvlqV6bWS9Qf+ccBOwSGQ3i8cp1GQqfKaiOnuIJDp4rZlnaa7/dl88mOdN7bepzsonKfrkWv7M8qYsOhXMwmuOXcTlovxyvcPlYxJX+2M8Pjf/dqq42nv9jNvf/dTpXVziV9EuibJH3O9MaQTrFYzCbS88tIzy/Tejlu4/Xp5ULr5GhOCdOXbSEtr5Q24UEsmzmcgTV53lvO7czibw+wdP0RJg9or9ngQF1yZtoKoE2N0MltvtDJLa4gLa+UgrIq509pVe3fz/gprbTWe7y2kcG8MWs4fZO0aSCmF9RozsV9EugY69sOwr5icKdYBneKYXtaPu9uSuOBi3t65Li5xRXc+9/tbDiUC8DdF3TjwUt6yvuBDgkPDqBfUhQ7TxSw9UgeHQYbq/RfhI7gcX45kc+s17eSW1JJclwob902ki7x4Y7bbzm3My+tPcTO4/lsSztt6Km4Hse1tFzFUWJ+UBkP4eYHwcHsYia/uJ6yqvqFS0NEhgQQHRpIdGggMWGBnDhdxrHcUm54ZSMv3zKU83v60dBFux02vQxmC4y8q8FdC8qqHFVCMzxQUq5nbhvThXvTtvPOpmPcM65bi1N0v5zI5+63U8koKCcsyMLfrh/IZS2cvi54lxFd4th5ooDNR/K4WoSO0JpZt/8U97yTSmmllb5JUbw+azjtIms3T4uPCObqQUm89/MJlq4/IkLHFdeIjkpcV8CkDPcszobIhCYfzm638/inv1FWZSU2LJD20aEO0RIdGkh0WGDt310ETXRoIJEhgWfNtyksr+Kut1LZeDiX297YyrNTBvhPOfC6v8Lahcp2ylhI6Fvvru//fJyyKiu9EiIZ1bWNjxaoDZf2SyQpOoSMgnI+3ZnBDcOSm32s934+ziMf76Ky2kaX+HBevXUoPRMiPbhawRsMT4njtR+PGLJDsggdwWOs2naCP33wC9U2O2O7x/PKrUOJCK77JXbb2C689/MJvt6lzeBA3aIKnbguzusCQyC2s3Jb7gG3hM5XuzJZfzCHoAAzn8wZS6c2LX+eo0ICeeO24fzpg1/4ZEcGD76/k8yCMuZc2N3YaYdtbzlFDsC2t+HSZ+vc1bWkfIaXSsr1RIDFzPTRKTz71V6WrT/C9UM7uv2YK6ttPPHZb7y7Wam4nHBOOxbdOIiokEBvLFnwMMNTlC+kB7OLyS2uoI2P+jl5AjEjCy3Gbrfz6rpDzHtvJ9U2O1cNSmLZzOH1ihyA3olRjO0ej83u9DkIwGnlw7NWRAecPh03SsxLK6v5v893A4r/wRMiRyU4wMI/bhjE3Rd0A+Bv3+znLx/votqolXT7v4HP7le2u16oXP6yot4mjWv3ZZOWV0pUSABXD/avkvL6mDq8E6GBFvZmFrGxxlfTVLIKy7nx3xt5d3MaJhPMu7gn/751mIgcAxEbHkTPBKWP09ajpzVejXuI0BFahM1m56nP97Dwq70AzD6vC/+4YVCT+mCo1RxaDA7UJXZ73akrqO3TaSJLvj9IRkE5HWND+d24bh5Zoitms4mHLu3Nk1f1xWSC5ZvTuOvtVEorDfa3TE+F92eA3QoDp8HNHygDVctOw97P67zLG46S8mTCglpHYDw6LNCRonSngeCWI3lc/sJ6tqflExUSwLIZw7lvfA/MZv+OgvkjRp17JUJHaDYV1VbuW7Hd8ab3l8vO4S+X92nyG5jr4MD3tvpucKBuKc2FyiLABNFneCDi3RvueSSnhNd+UP4uj17Rx6v9XaaPSuHlm4cSHGBmzd5spr62mZxig4yryDsM794AVaXQ7SK48gWwBMCgm5Xbt7191l0OnSrmxwM5mExw67kpvl2vxswckwLAmr3ZHGlkHIDdbueNn44w7bVN5BRX0Dsxkk/njuXC3tL12Kio6astR92L6GmNCB2hWRSVVzHr9a18/stJAi0m/nnTIGaf39WtY5jNJm6rGRz4+oYjPhsc6E3sdjtlDZRlN4gazYlKUnw5rrhRYq4akCutNi7o2ZZL+jTd09NcJvVLZPnskcSEBbLzeD5TXt7AUb3PxSnJgXemQGkOJA6AG94CS00qZXCN0Dn8vTOdWMNbNdGc8b3beTQdaAS6tY3gwl5tsdvhjQaiOmWVVv7w3k4e/2w31TY7kwcmsep3o0lxqb4UjIca0dmdUUhRuXHG+IjQEdwmu7CcG17dxIZDuYQHWXh95giuGtS8csMpQzoSExbI8bwyVu/2/uBAb/PQh78y6Mlv+GH/KffvXF/aCpypq9PHoKrhpm3f7M5i3f5TBFnMPH5lX58ZZYd2juPDe0aTHBfKsdxSrn15A9vTdJrLryyB5TcoEZ2YTkq6Ktil8ic2BbqOU7Z3vOu4uqi8ig9SlVEF/l5SXh+3j1W+0LyfeoKCsrM/7I7nlTLl5Q2s2p6OxWzikcvP4YWbBrWaFJ8/0z46lE5xYdjskHpMp//bdSBCR3CLQ6eKufblDew5WUh8RDAr7xrF2B7xzT5eaJCFaergwPXeHxzoTQ5mF/Ne6nEqqm3ct2K7+x1E6+qhoxLRDoKjAHuDwz3LKq08+ZliQJ59fpda/Yt8Qbe2EXx4z2j6d4gmr6SSqa9t4lu9CVhrNXxwm+LNCY2FW1bVXck2+Fblcvs7YFOidB+mnqCk0kq3tuGM7d78172RGdO9DT0TIiittJ6Vcv5h/ykm/2s9u08W0iY8iLdvH8Ed53X1+6q01oSavjJSmbkIHR2x52QhN7yy0e2KBl+xPe001728gROny0hpE8aqe0bTr0PLO+NOH5VCgNnElqN5/HrCu4MDvcmr6w5hr8m+5ZdW8bt3t1FZ7UYVUkMRnSYO93x53SHS88tIig5hzoXdm35uD9IuMoQVd57LBT3bUl5l4863f+bdzccav6MvsNvhi3mw/2sICIGpK53P65n0vgJCYpTZY4e+x9bKSsrrw2Ryppzf2HCUaqsNu93OS2sPMvP1LeSXVjGwYzSf3TuW0d1apxj0Z0Ya0JAsQkdHPPvVXrYczePxT3/DbteXX+W7vVlMe20zp2vexD64Z7TH/AmJ0SFcMUDpirp0ff3RCj2Tnl/GR9uVLrkvTh1MdKjiVXn6i91NP0h9peUqjfh0juWW8Mq6QwA8ckUfTVMF4cEB/GfGMG4Y1hGbHf7y0S6e/99e7V/XPzwP294EkxmmLIVOI+vfNzAEBt6kbG97kx8P5nA4p4SI4ACubeWDJ68e3IG48CDS88tYtT2de97ZxnNf78NmhxuHJbPyrlEkxYRqvUzBCwyvETo7jxdQ3sxu675GhI5OOJhdzLoaX8e+mkGBeuGj7SeY/VYqZVVWLujZluWzzyXew82i1Lz/57+cJLPAeAMjX/vhMNU2O2O6t2HywCT+ceNAAN7ceIxPd2Y07SANRXTAJaJTd4n5k5/tprLaxtju8Y6J01oSaDHz1ykDuH+Csu4l3x/iD+/vdC/K5Um2vwPfP61sX/ocnHNF4/dR01f7vuLDH7YBcP2wjg32iGoNhARauHmkknL+0we/8PVvmQRaTDxzTX+endLf76a4C05S2oTRNjKYSquNncfztV5OkxChoxPUpnlqu/2lOvGr5JVUMn/Vr1htdq4d0oH/zBhGuBfe5Pt3jGZEShzVNjtvbTzq8eN7k5ziClZsVbq9/m6cki66qHcCcy5Uetc89OEvHMgqavgg1ZVQoJhcie1S9z4NpK7W7Mlizd5sAswmnxqQG8NkMnH/hJ78dUp/LGYTq7alc/ubW31fsXFgNXx6n7I99gEYMbtp90vsB0lDwFZFwtFPACXVKsCt53Ym0KK8zhKiFL/etJGddPPaE7yDyWQyXD8dETo6oKCsig+3KR9yT13VD5MJvtubzeFTxRqvTBFg5VU2+nWI4u/XDyTQ4r2XzG01DQSXb0lrfom2Brz+0xHKq2wMTI5hdDfnzKN5F/didLc2lFZauefdbZQ01BSx4Dhgh8BwCK/H16BWXuXWDPesobzKyhM1BuTbx3ahe7uIlj4kj3Pj8E78Z8YwwoIs/Hgghxte3URWoY8id+nb4L2ahoADboLxC9y7/xAlqnODeS3jesb73OCtV9pFhbDw2gHcPLITn907liGdYrVekuAjRjj66YjQEZrIe1uPU1qpDAecOiKZ8TUNtd7QeDRCaWU1b9ZEV+6+oJvXv6ld3CeBTnFh5Jc6hZ/eKSyv4q0Nirfmd+NqP0cWs4kXpg4mISqYg9nFPLTq1/o9Kq4VV/U9z3FdFW9JRSEUOyuZ/v3DYdLySkmICube8fUYa3XAhb3aseLOc4mPCGLPyUKufWlD45GulpJ3RCkjrypRysWvfNHt6e8lPa+m1B5MD3M69/bK98oyjcp1Qzvy9DX9zxrcK/g3akQn9dhpQ4x9EaGjMVab3SEmZo1RKjnUyMb7P5+goFS7pkzvbT1OfmkVneLCuLRfe6+fz2I2MbOmN8myn45gM0ADwXc2HaOoopoe7SK4+JyzS5TjI4JZMm0IFrOJz3ZmOKp2ziKvgdJylYBgiOmsbOcohuTjeaUs+V7x7Pzl8j66944M6BjDqnvG0DU+nPT8Mq59eQMPvr+TZeuPsOlwbp19WZqN2hCw5BQk9ocb3oaAILcPs2p3EV/aFNPykFOfem59gmBQeiVEEhUSQGmlld8yCrVeTqOI0NGY1buzOHG6jNiwQK4erDTdG9W1Db0TIymrsjq8H76mymrjtR+VD9/Z53d1eIe8zQ3Dk4kMDuDwqRKHOVuvlFVaWVrzHP3uwm71jr4YlhLH/Et7A/B/X+yuu4leY0ZklTN8Ok99vpuKahvndo1j8gDvi1FP0KlNGB/cM5ohnWIoKq/mg9QTPPn5bm769yYGPvENY//6HXe+9TOLv93PN79lcuJ0qfvVWpWlsPxGyDsE0Z1g2vsQEuX2Wu12O29tOMqK6nEAmH77CCq8HIUSBJ1jNpsM1U9HhI7GvF7TRn3qiE6OSgXXqM6bNX0qfM2Xv54kPb+MNuFBXD/Ud6W0EcEB3DhcmfOkF0N2fbz383FySyrpGBvK5AENT7C+fWwXLu2XSJXVzpx3t5FXUll7h6YKHUeJ+UHW7svmm91ZWMwmnriyn6FMoHHhQay4cxT/mT6M+yf04JI+CXSMVcqRT5wu45vdWSz+9gB3vp3K2L9+z8AnvuGmf2/kyc9280HqCXZnFNZfvWWthg9vh/SflT44t3wAUc0TgRsO5XIgu5jdgX2wxnVXUmC7VjXzUQuC/6CmrzYbwJCs7zi3n/NbRgGbj+RhMZu4dVTnWrddOTCJ577eS0ZBOV//lskVjXyQehK73c4r65R+NjNHp/i8VHTG6BSW/XSE9Qdz2JtZSO9E97+Je5sqq41//6A8R3dd0I2ARkzaJpOJ564bwN7MIo7klHD/yh28PnO4M1LWWA8dlZqIju3UPp7YpRiQZ45OoVdiZEP30iVBAWYm9ElggsssroLSKvZkFrI7o5DdJ5XLA9lFFJZXs+lwHpsOO99UgyxmeiRE0Kd9FH2SohjQMYbBHaMxf/kg7PsSLMEwbSW07dXsNao+uSlDkrHE3wrfLoDtb8PQGc0+piD4A2o/nZ+P5mGz2XU9jV6Ejoa88dNRAC7tl0j76NrNtZQ+FZ3555oDLFt/xKdCZ93+U+w5WUhYkOUsAeYLkuPCmNQvkS9/zWTZ+iM8d91An6+hMT7ZkUF6fhnxEcFNjnhFhgTy8i1DuHrJT/yw/xQvfneA+yf0VCqo3ExdFaXv5Uh+CW0jgx19avyB6LBAzu3ahnO7OqvXKqttHMguqiV+dp8spKi8mt8yChWPQKqy7/yIz7mrejl2TJim/Ac6ndvstRzPK2XNHsX0PWN0ZwidCt89BSe2QvYeaHdOix6rIBiZfknRhAZaOF1axcFTxfRM0O+XLUldaURucQWf1DSSmzWm7r4pt5zbmSCLmW1p+T4djvhqTTRn6ohOxIS5b970BLfXpO4+3pFBTnGFJmuoD5vNzstrFQPwHed1cSvi1Tsxiqev7g/AP9ccUHxIpXlQWeP7iOnU8AFqSswjyzIIppKHL+tNZEig+w/CQAQFmOmbFM31w5JZMLkvK+8axS8LLuHHP13Iq7cO5ffjezDhnARuCV7PXdXLAVhQNZ3Ja+JYuv4Ip4qa9/p5e9MxbHYY2z2e7u0ilXlYPScpN25721MPTxAMSVCAmcGdYgD9p69E6GjE8s1pVFbbGNgxmiE1L5YzaRsZzJWDlEjOsproj7fZeTyfjYdzCTCbHGJDC4Z0imVgcgyV1Tbe2aSTOUk1fLM7k0OnSogKCXB0h3WHKUM7MnVEJ+x2uH/FdrKP71VuiExSxg40RHhbSs3hmE12ruhQytXNnBpvdEwmE8lxYUzsm8gDF/fkP2MKeMrybwC+irqR5fZJ/JpewFOf7+bchWuY+foWPtmR3uT+TGWVVlbWDKyc6TqlfMh05XLnf6FaXwJcEHyN6tPZKkJHOJPKahtv13x4zxrTpUET6awxKYBiDj5Z4OY07Gbw6g/KrKQrByVpOqvGZHIKrXc2HdPNTBW73c6S75XnaMbolGZHUxZM7kO/DlGcLq3irS/WKVc2lrYC1h/MZV+1Yqy9f7DZUAZkr7LmCUy2auh/PZfe/wqbHx7PE1f2ZWByDFabnbX7TvH7FTsY9n+r+cN7O/npYA7WBtoXfLwjnYKyKpLjQrmwpq8VAN3GQ2R7KMtTfECC0Ipx7ZCs+Ry7BhChowFf7TpJdlEF7SKDuax/w9UgfZOiObdrHFaXycne4khOCV/tygTgrvO7efVcTUHxLoWQU1zZ9HlRXmb9wRx+TS8gNNBSb8qxKYQEWnj55qFEhQRgU3voxDV8vMpqGws+3cVhu/KaSbYao6mi17Hb4VTNWIxx88Fspk1EMDNGp/DJnDGs+cMF3HdRd5LjQimptPLhthPc/J/NjHn2OxZ+uYe9mYVnHM7uGMky/dyU2q0VLAEw6GZle9tbPnhwgqBfBifHEmgxkVlYzonT3v8i3lxE6GiAmoa65dzOBAU0/idQB14u35xGaWUDYwRayL9/OIzdDhf1bqeLKp5Ai5kZagPB9Ud08Y1Bbc43dUQn4sJb5l9KjgvjHzcOopMpG4C9FXEN7v/6T0c4dKqEk4FK+X19U8xbHUWZUF0GJkudHqdubSOYd0kvfvjjhbx/tzKPKSokgMzCcl794TCTFv/IpMU/8O8fDpFZUM7mI3nszSwiNNDCDcOSzz7f4FuUy0PfQ742fa4EQQ+EBlno3yEa0LdPR4SOj9mWdpqdx/MJspiZ1kR/x0W929G5TRgFZVWs2pbulXVlF5U7xi7cfYH20RyVqcM7ERpoYW+m9hPdU4+dZtPhPAItJmaf7xn/0vhzEhgdp0QUlv1m52B23c3oMgvK+ecaRdgMGTxcubKO4Z6tEnV8RnRHsNSfSjSZlCZnz1zTn62PTOCVW4YwsW8CgRYTezOLeObLvYx6dg1z3lWmlF89uAPRYXUcL64LpJwH2GHHci88IEEwDsMd6Stt358bQoSOj3m9Jppz5aAk4iOCm3Qf19EIrzd1NELxKfjlPbA1zdvyxk9Hqay2MbhTDMNT9DOcLzoskOuHKeXbWjcQVCutrh3c8ax2AC0huSaic7AqnrvfqXv459Nf7qG00srgTjGcO2KUcmVO7eGerZYmpv5cCQ6wMKlfe169dRhb/zKBp6/px7DOsdjtkFvTzHHG6AZaKwyp6aOz/Z0m/48Jgj8yUjUkH/VdZbC7NEvoLFmyhJSUFEJCQhg5ciRbtmxpcP/FixfTq1cvQkNDSU5O5oEHHqC83Dm5+PHHH8dkMtX66d27d61jlJeXM2fOHNq0aUNERARTpkwhKyvrzFPpmsyCcr769STgNBk3leuHKaMRDp0qYd2BRkYj2O2wYhqsmg27P2n02MUV1Q5ztC+Gd7qLYthWJrof0mii+56ThXy7JxuTCe66oKvnDlxdialAidKVhidzMLuY+WcM/9x4KJfPdmZgMinT7c1taoZ7VhYpaZvWjmMgavOibDFhQdw8sjMf3DOaH/54IX+a1It/3Diw4UaV51wBIdHK1PnDa5t1XkHwB4Z2jsNkUjye2UXljd9BA9wWOitXrmTevHksWLCAbdu2MXDgQCZOnEh2dnad+y9fvpyHHnqIBQsWsGfPHpYuXcrKlSt5+OGHa+3Xt29fTp486fhZv359rdsfeOABPvvsM95//33WrVtHRkYG1157rbvL15S3Nx2l2mZnRJc4+iZFu3Vf19EIyxqLbBz5AU7UiM/sPY0e+7+b0ygqr6Zr2/A6B1NqTZf4cMdEd3Vkhq95ea1SaXVZ//Z0bRvhuQMXHAfsEBjGUzdfiMVs4tOdGQ7hWWVVDMgAN4/sRL8O0bWHe4pPp1kRnfro1CaM343rzjWDG2kCGRgKA25UtsWULLRiokMDHV8Kth7RZ1THbaGzaNEiZs+ezaxZs+jTpw+vvPIKYWFhLFu2rM79N2zYwJgxY5g2bRopKSlccsklTJ069awoUEBAAImJiY6f+Ph4x20FBQUsXbqURYsWcdFFFzF06FBef/11NmzYwKZNm9x9CJpQXmVl+WbFuHibm9EclRmjUzCb4McDOezPamCw4I9/d243YpasrLY5UkJ3nd9Vt2281dlfH6amk19a2cjenuVYbgmf/6JUff1unIf9S45oRArDu7RxDP986nNl+OebG46yP6uY2LBAHrzEZZRBTeNA8engfA7jPBhpawqDb1Uu934BJfr1JwiCtxmpc5+OW0KnsrKS1NRUJkyY4DyA2cyECRPYuHFjnfcZPXo0qampDmFz+PBhvvzySy677LJa+x04cICkpCS6du3KzTffTFqa8wM6NTWVqqqqWuft3bs3nTp1qve8FRUVFBYW1vrRkk92pHO6tIoOMaFc3CexWcdQG6RBA5GNEz/DkXXO3xsROp/sSCezsJyEqGDH9HQ9MqprG85pH0VZlZXlW3xb6fLKusPY7DCuV1u3I3GNcsbohzOHfy7+VonY/GlS79pdqh1TzA96dj1GJK9lqatm034AtB8Etir4ZYVvzy0IOkKdZK7Xyiu3hE5OTg5Wq5WEhNrpjYSEBDIz6/YKTJs2jSeffJKxY8cSGBhIt27dGDduXK3U1ciRI3njjTf4+uuvefnllzly5AjnnXceRUVK1CIzM5OgoCBiYmKafN6FCxcSHR3t+ElOrqNM1EfY7XaHCXnG6M61+3K4iRrZWLUt/ewJ2OCM5rTro1w2IHRsNjuv1gymvG1MF4IDfDu80x1cGwi+teEYVT6a6J5VWM6HqUo12pwLu3v+BGcIHXX4Z5f4cDIKyimuqGZgx2huPLPMWRU6rT11VZavNO+DJjVc9DhDaqI6294WY7jQahneRSlg2ZdVREFplcarORuvV12tXbuWZ555hpdeeolt27axatUqvvjiC5566inHPpdeeinXX389AwYMYOLEiXz55Zfk5+fz3nvvNfu88+fPp6CgwPFz/PhxTzycZrHxcK6jL8eNw9wfGeDKsM6x9O8QTUW1jeWbz2ggmPVbTbdWE1z2vHJdUQZY637hfbc3m4PZxUQGBzC1GaMMfM3kge2Jjwgms7CcL2tM3d7mPz8eptJqY3hKrONbi0epY5hnZEggL908hJBAMyYTPHlVv7NTim3UiE4rT12paavwdhDsQe9UU+l3HQSEwqk9SjRVEFoh7SJD6Bofjt0OPx/TX1THLaETHx+PxWI5q9opKyuLxMS60zGPPvoot956K3fccQf9+/fnmmuu4ZlnnmHhwoXYbHV/K4+JiaFnz54cPKiE5RMTE6msrCQ/P7/J5w0ODiYqKqrWj1ao0ZwpQ+vpy+EGtSIbG49RWe3yHP64SLnscxV0HgMBIWC3QWHdvXdeWacYbG8+tzNRBhgMGRxgYXrNNPWlPmggeLqkkndrfFW/80Y0B1yETu20yznto/hkzlg+vGc0A5Njzr6f6tHJPw5V+u1I6nU8aERuFqExyv8bwHYxJQutF/WL4JajBhc6QUFBDB06lDVr1jius9lsrFmzhlGjRtV5n9LSUszm2qexWJQUSX0fVMXFxRw6dIj27ZVW90OHDiUwMLDWefft20daWlq959ULabmlfLtHEYYzR3vmzfiy/u1pFxlMdlGFM7KRewh+W6VsnzcPTCalgRrUmb76+WgePx87TZDF3GxztBbcPLITQQFmfjlRwM/HvOvwf2PDUUorrfRpH8W4nm09fwK7HU7XROXqSLv0SoxkSKd6ehqFxyvlzdiVv31rpYWl5R5BTV/tWgUV2rQ/EAStcZ17pTfcTl3NmzeP1157jTfffJM9e/Zwzz33UFJSwqxZswCYPn068+fPd+w/efJkXn75ZVasWMGRI0dYvXo1jz76KJMnT3YIngcffJB169Zx9OhRNmzYwDXXXIPFYmHq1KkAREdHc/vttzNv3jy+//57UlNTmTVrFqNGjeLcc8/1xPPgNd7ceBS7Hc7v2Zbu7TwTWg8KMJ8d2fhpsRK96X4xtB+o7Ki2w69D6LyyTvHmXDukA+2iGpmYrSPaRARzbY1peumP3is1L66o5o2aeUe/u9BLvYVK86CixiRfx+iCBjGZnFGd1uzT0TqiA0r0NK4rVBbDbx9ptw6h9XBqPxyruxBHK0Z3b8O8i3sy/9JztF7KWQS4e4cbb7yRU6dO8dhjj5GZmcmgQYP4+uuvHQbltLS0WhGcRx55BJPJxCOPPEJ6ejpt27Zl8uTJPP300459Tpw4wdSpU8nNzaVt27aMHTuWTZs20bat81v0P/7xD8xmM1OmTKGiooKJEyfy0ksvteSxe53iimre26p4g9xtENgY00Z25sXvDvJregE7d+9m0I7/Kjec/6Bzp3qEzoGsIr7dk4XJBLPP93FJrge4bWwXVmw9zje7MzmeV0pyXJjHz/HfzWkUlFXRJT6cS/s1PHi12ahpq8gkCGyG2GzTA05shZxWLHTqSf35FJNJKTVf8wRsf9sZ4REEb2C3w1tXQnE2zNsNkc2r4vU07aNDuW98D62XUSduCx2AuXPnMnfu3DpvW7t2be0TBASwYMECFixYUO/xVqxovDQzJCSEJUuWsGTJErfWqiUf/HycoopqusaHc0EPz6Y+4sKDuHZIB/675Ti53/xdKXHtPAY6uUS46hE6/66ptLqkTwLdPNn8zkf0TIjkvB7x/Hggh798vIsnr+xLSny4x45fUW3ltR+V5+juC7q2qEquQVx66DQLR4l5KxY6eojoAAyaBt/9HxzfDKf2Qdtejd9HEJrD6SNQpFoWDupG6OgZmXXlJWw2O29uVPwXs8akeKUR36wxXYijkNH5nylXnPeH2juo3XPznRVnJwvK+HiHYk7W0/BOd5lzYXfMJvhh/ynGL1rHvPd2cCSnxCPH/jA1neyiCtpHhzTeIbcl1FFx5RbxrbzyqrrCabTXMqIDyodNz4nKtnRKFrxJxnbndoF3hjz7GyJ0vMTa/dkcySkhMiSAa4d458OyZ0IkC9qtI9RUSUZYb+h2Ue0domt6r7hEdJatP0KV1c7ILnEMrs/oagDO7dqGVb8bw4W92mK12Vm1LZ3xf1/LAyt3tGgeVrXV5qhGm31eV4ICvPgv0lKho5aY57bS4Z6njwF2CIpUzNlaM2S6crnzv1Dt2+7dQiuiltDRrm2KkRCh4yXUkvKbhicTHtysDGHjlBdwWdnnAPy15AqKK8+YoqymrgrTwVpNQVmVYwyFkaM5KoOSY3h91gg+njOGi3q3w2aHj7anc/Gidfx+xXYOZrsveL749SRpeaXEhgVy0wgvN5lsqdCJ6wImi2KCbY3DPR2jH1IUn4zWdL8YIhKhNBf2f6X1agR/JWOHc7ue1iFCbUToeIEDWUX8eCAHswmmj0rx3om2/ofAqiKOmjvyacUg3v/5DHUfkQCWILBboTCddzYdo6TSSq+ESMb18kK5tEYMSo5h2czhfDp3DBPOUQTPJzsyuPgf67j3v9s50NBcMBdsNjsvfa9Ec24b04WwIC8JVJUGSsubREAwxNakJ1tj+ipP8VFpnrZSsQQoXh2Q9JXgHWw2OLnT+bukrpqECB0v8HpNWfLFfRK8UhEEQGUpbFSqztL73oMdM29sOIrV5pLCMJsd6avK3KOOKNNdF3T1Trm0xgzoGMN/Zgzn83vHcnGfBOx2+GxnBpcs/oE5y7exL7NhwfPd3mz2ZRURHmTxrkAFJbVRqIyWaNHogtZcYq4XI7Irg29RLg+ugYIT2q5F8D/yDjtbUoBEdJqICB0Pk19ayaptyhvcrDFefAPe9haU5kBMJwZffgfRoYEcyy3lu73ZtferSV+l7txJTnEFHWJCmTwwyXvr0gH9OkTz2vRhfHHfWCb2VQTPF7+cZOLiH/jdu6nszTx7wKvdbmfJWqUT9y2jOre4g3WjFBxX+h4FhkFEu+Yfp01Nx+bWWHmlh2aBZ9KmG3QeC9hh+7tar0bwN1R/TmiNv1LEdJMQoeNhVmw9TnmVjXPaRzlG13uc6krY8IKyPeZ+wkJCmDpCETRL1x+uvW+N0Nm79zdAmY4daGkdf/a+SdG8euswvvr9eVzaTynB/PLXTCYt/pG7305ld4ZT8Gw6nMf2tHyCAsyOERtexdWf05LomhrRaY1CR48RHXCakre/o6QaBMFTqEKn56XKZXk+VHqm2tSfaR2feD6i2mrjrZq01awxKd5LD/2yQglZRiTCoJsB51T0TYfz+C2jwLlvjJK6iijLIDo0kBuHazfFXSvOaR/Fy7cM5ev7z+Py/u0xmeDr3zK57IUfufOtn9mVXsBLNdGcG4Z1pF2kDzpFt7SHjkpr7aVjs0K+6nHSmdDpcyUER0NBGhxZq/VqBH9CFTpdzofgmvmN4tNpFBE6HuSb3VlkFJTTJjyIK72VHrJZYf0/lO3Rcx0dddtHh3JZf6WDr+rFAbBHKxGdjqYcZozq7L0KMAPQOzGKJTcP4X/3n88VAxTB883uLK54cT0/HsjBYjZx1/k+qkZracWVihrRKTiu+LZaC4UZYK0Ec6BzppteCAyFAdcr29ve1nYtgv9gszqNyEmDIUoZhePw+gn1IkLHg7z+k/ItfdrIToQEWrxzkt0fK4a00FgYOqvWTepwzk93ZJBdVA7Ab6UxACSbTzF9dIp31mQweiZE8q9pQ/jm/vO5cmCSI3N01cAk75nHz8RTQiesDYTEAHbIa0XDPdWIWEwnMHvpf60lDK4ZA7H3c2WmmSC0lJwDUFUCgeFKJDe6RuhIRKdRROh4iF3pBWw9epoAs4lbzu3snZPY7fDjImV75D0QXHt8w+BOsQzpFEOl1ca7m5R+Of/5Vemt096UR3yoDj8QNKRHQiQvTB3M6gcu4PHJfXjiqr6+O7mnhI7rcM/WlL5y+HN0OqstaRAkDlCiTr+s1Ho1gj+gpq3aD1TEvRrREUNyo4jQ8RDLaqI5lw9oT4K3poHv/x9k7YKgCBgxu85dbqsx0r6z6Rg7jufzyWErlXYLFqzO+ShCLbq3i2DmmC5Ehni50krFbm95Dx1XWqNP57ROjciuqKbkX9/Xdh2Cf6AKnaTByqWaspXUVaOI0PEAp4oq+HynIiK8VlJut8OPf1O2h98OYXVXdE3qm0hSdAi5JZXc+dbP2DGTH1Qz9O2M4Z6CRpSddvbCULtXtwS1xLw19dLRW7PAuug6TrnM3ts6R3QInuXkDuUyaZByGSWpq6YiQscDvLv5GJVWG4M7xTAoOcY7Jzn6I5zYCpZgOHdOvbsFWMzMqPHiZBdVABDWVvldhI5OUKMRke0V42pLadWpKx0LnZhOYDIrvori7Mb3F4T6sFbDyV+UbUdERzUji9BpDBE6LaSi2so7NX4YrzYI/PHvyuWQ6RCZ0OCuNw3vRGiNGfq8HvFEJNT4GETo6ANP+XNU4lvZcE+73eU51LHQCQiGqJr0gipuBaE55OyD6jJlgG1cTWWo+toqSG8d//ctQIROC/nil5PkFFeQGBXiaErncU6kwuG1YA6AMfc1unt0WCD3jOtGRHAAD1zcE2JqzNEidPSBp4VOrOtwz1bgwyrNc6b+Yr1k/PcUasQp73DD+wlCQzj8OYOU0T7gjOhUlSiNA4V6ab1NVTzEuV3bcNcFXWkfFeK9jsNqNKf/DU32dNw3vgf3ja/5pn+65j5qgzVBWzwdjQgIUkRT3iFluGeUf4/4cKb+kjyT+vMmcV3hyDpnqk0QmoOr0FEJDFXaS5TmKlEddSyEcBYS0WkhSTGhzL/0HGZ6K22VtRv2fQGYYOwDzTuGKo4Kjje8n+Ab8jzUFdmV1uTTMYI/R0UiOoInOLPiSiVKfDpNQYSO3llf0zenz5XQtmfzjlEzBoKCE0p3TUFbPFlarhLfioZ76nGYZ32ofX5E6AjNpboSMncp22cKHbXEXHrpNIgIHT2Tdxh2fahsn/eH5h8nsr3i77FVtw4Ph56prnT2vfBGRKc1lJg7Ijopmi6jSahiTMzIQnM5tQesFRASfba4l6aBTUKEjp5ZvxjsNuh+sdINs7mYLU7lL4ZkbSk4rvxNA0Ihop3njtumFTUNPK3zrsiuqKmrstMyCkJoHq5pqzMHRUuJeZMQoaNXCjNgx3Jl+/wHW3481acjQkdbXCuuPDndvjUN98wzUOoqKBwiaqoxJaojNAfH6IdBZ9/mWmIu1IsIHb2y4V9gq4LOY6DTuS0/nggdfeDp0nKV8DbOqgt/Hu5ZWQLFmcq2EczI4GJIFqEjNIOMHcrlmf4ccInoSOqqIUTo6JGSXEh9Xdk+b55njim9dPSBt4QOuKSv9nv+2HpBff5CYoxTTuswJIvQEdykugKyflO26xI6jqqrDLDZfLcugyFCR49sfhmqSpVQZbfxnjlmdE3llQgdbfGm0HGUmB/0/LH1gpFKy1XixJAsNJOs35TIfmhc3T3UopIAE1groTTH58szCiJ09EZ5AWz+t7J93h885+OQ1JU+8KrQUUvM/TmiYyB/jkqs9NIRmklDRmQASyBE1njApPKqXkTo6I2tS6GiAOJ7Qe8rPHdcR9NA6aWjGa4zmrwRkWgNJeaGjOhILx2hmdTXKNAVaRrYKCJ09ERlKWxcomyfN88508QTOHrpVEFRpueOKzSdstPOGU1NHOXhFg6Pjh8P9zRiREcVZcVZiplaEJpKQ0ZkFdWQLJVX9SJCR0/s+kDJs8Z0gn5TPHtsS4BT+Uv6ShscM5rae2dGU1wXRcxWlSjmRH/EiBGd0FiXijjx6QhNpKoMsncr2w1GdGpKzKXyql5E6OiJ7D3KZZ+rlNyrp5GZV9riTX8OKK8Z9dj+6NOxVjtfu0ZoFuiKpK8Ed8ncBXYrhLdreFBvtHRHbgwROnpCHc+gRl48TYxMMdcUbwsdcPHp+GHlVcFxZYxJQIizCZ9RkFEQvqUs3/jl1q4TyxsqSomS1FVjiNDRE6p3JtJLb+JSeaUtvhA6bfx4uKfDn5PiWf+aL5CIju/I3gvPd4PP7tN6JS3j5A7lsqG0FTjH+2htRi7Lh8xfoaJY23XUgcHeLfwc1VcR2d47xxehoy2+jOj4Y+pKFQlGMiKrSNNA33HoOyXyd3yL1itpGU2puAJnRKfopJLe1Yoj6+CVsfDWldqtoR5E6OgFu10iOv6OT4ROTeWVP6aujGhEVpExEL4j81flsuSUtutoCZUlcGqvsl3XjCtXIhLAHKgMCy7WsKJW/SIS1027NdSDCB29UHYarBXKtrcjOgUnjJ+/NhrWKqdZ0KupqxqhU3Dc/0qZHULRiEKnJqJTcFxp6y94j6waoVOWp/zfGZHMXxXhEtkeohr5PDCbnfto6dPJrZmx10aEjlAfajQnNA4Cgr1zjsgkMFmUduHFWd45h1A3BceVN66AEOUbmLcIb6O8hsD5xuMvGDmiE94WgiIAu0RUvUl1peLRUSnN1W4tLaGpaSsVPZSYOyI6+quIbJbQWbJkCSkpKYSEhDBy5Ei2bGk4F7p48WJ69epFaGgoycnJPPDAA5SXlztuX7hwIcOHDycyMpJ27dpx9dVXs2/fvlrHGDduHCaTqdbP3Xff3Zzl65MiL/tzQHrpaIlr2spTYz3qI94Ph3u6dpU2YkTHZJJREL4gZ5/SFFWlOFu7tbQEd4WOHpoG+lPqauXKlcybN48FCxawbds2Bg4cyMSJE8nOrvsFtXz5ch566CEWLFjAnj17WLp0KStXruThhx927LNu3TrmzJnDpk2bWL16NVVVVVxyySWUlNQOvc+ePZuTJ086fp577jl3l69fvO3PURGfjjbk+bCjrz/6dIqzlUaIJrN3ukr7gjgROl5H9eeoGNWn43ZER+MxEJUlzvYobfQX0Qlw9w6LFi1i9uzZzJo1C4BXXnmFL774gmXLlvHQQw+dtf+GDRsYM2YM06ZNAyAlJYWpU6eyefNmxz5ff/11rfu88cYbtGvXjtTUVM4//3zH9WFhYSQmGqx/RlNx9NDxYkQHlA+JY0gvHV/jCyOyShs/jOiopeVRHSEgSNu1NBcxJHufzF21fzei0CkvdLaHaMyIrKKWmGvVNFAV765dwHWEWxGdyspKUlNTmTBhgvMAZjMTJkxg48aNdd5n9OjRpKamOtJbhw8f5ssvv+Syyy6r9zwFBQUAxMXF1br+3XffJT4+nn79+jF//nxKS0vrPUZFRQWFhYW1fnSNI6LjA6EDEtHxNb4UOo4Scz/qpWNkf46K9NLxPpm/KJfmms7yRhQ6mb8AdkXUR7Rt2n2iNO6OrPoBdZi2AjcjOjk5OVitVhISapspExIS2Lt3b533mTZtGjk5OYwdOxa73U51dTV33313rdSVKzabjfvvv58xY8bQr1+/Wsfp3LkzSUlJ/PLLL/z5z39m3759rFq1qs7jLFy4kCeeeMKdh6cthTURHV+lrmQMhG/xqdBxSV3ZbMZrrlcXp/1I6Eh3ZO9gtztTV53OhaM/GtOj4xjkOajp94nWOHWlincdVlyBD6qu1q5dyzPPPMNLL73Etm3bWLVqFV988QVPPfVUnfvPmTOHXbt2sWLFilrX33nnnUycOJH+/ftz880389Zbb/HRRx9x6FDdlSXz58+noKDA8XP8uM4/2NXUldcjOsnKpUR0fEctI22K988Xm1Iz3LPUaXI3Or70OHkLxxiIY9o2dvNXCk5Aeb7y2k85T7muJEfTJTULd/054Ky6KjmlTfuCPH1HdNwSOvHx8VgsFrKyapcmZ2Vl1eudefTRR7n11lu544476N+/P9dccw3PPPMMCxcuxHZGL5e5c+fy+eef8/3339OxY8cG1zJy5EgADh6s23AZHBxMVFRUrR9d43Mz8nFj99LJOQh/7QJrn9V6JY1TdhoqalKnvjDSWgKdH6r+kr5yVHQYWOhEdQBLsFIVJJOmPU9WjT+nbW9nhKPEiBGdZgidsDgICFW2tYjq5Oq3tBzcFDpBQUEMHTqUNWvWOK6z2WysWbOGUaNG1Xmf0tJSzGeEzi0WCwB2u91xOXfuXD766CO+++47unRp/M1sx44dALRv7+UIiC+wWZ19bSIbmFLrCaI6KJUr1gpjvgmo7P5IaQi2+xOtV9I4ajQnIhGCwnxzTn/z6Zz2g4iO2eyM6Ikh2fOoaavE/srEbzCeR6cs3xkdcUfomEzalpg7Uld+IHQA5s2bx2uvvcabb77Jnj17uOeeeygpKXFUYU2fPp358+c79p88eTIvv/wyK1as4MiRI6xevZpHH32UyZMnOwTPnDlzeOedd1i+fDmRkZFkZmaSmZlJWVkZAIcOHeKpp54iNTWVo0eP8umnnzJ9+nTOP/98BgwY4InnQVtKcsBuVQRIeBPNZ83FEugfvXSOb1UuTx9TUkN6xpdpK5X4muGeuX4gdMoLnY3fjBzRASkx9yaqETmhn9PEW2wwoXNyp3IZ01mJ0riDViXmFcXO0RM6jei4XV5+4403curUKR577DEyMzMZNGgQX3/9tcOgnJaWViuC88gjj2AymXjkkUdIT0+nbdu2TJ48maefftqxz8svvwwoTQFdef3115k5cyZBQUF8++23LF68mJKSEpKTk5kyZQqPPPJIcx6z/lB9FOHtlKZ+3iamk2JGzk+D5BHeP5+nsdvhRI3QqSpRPgTD47VdU0NoIXT8qcRcjeaExUNwpLZraSlSeeU9akV0aoROySnl/cLbTTo9RXPSVipalZg7SsvjdFlaDs0QOqB4aebOnVvnbWvXrq19goAAFixYwIIFC+o9nr2Rb+TJycmsW7fO7XUaBl/5c1RiOsGxn4wb0ck7rKStVE4fE6FzJo7UlR80DfSH0nIVhyH5qKbL8DvKC53PaWJ/CApXtm1VikFZpx/AZ9ESoaNVRCdPvzOuVPyg7tQPcDQL9LI/RyXa4JVXx88YOaL3cl0tSqPVEvPCE8Yf7ukP/hwVieh4h6zflMuojjXG3GAIjlauM1LlVYsiOhp5dHQ8+kFFhI4e0CKiA8YVOifOEDp67/KsRUQnLA7C2ijbRh8F4Yjo6DP/7xau3ZH17i0zEo60lbP3mtOnY5Cii9I853tZ+4Hu3z9Ko9RVrr576IAIHX1Q6IOBnq4YXeioRuR2fZXL0zoWOtYq5xuPL4UOuPh0DG5I9odmgSoxncBkgeoy5xccoeWoRuTE/s7rXH06RkCN5sR1hdAY9+/vaBroa4+O2kNHv19EROjoAa0iOgXHjfetsqIIsmvC1P2nKJd6jugUHAe7DQJCICKh8f09SbyfCJ28o8qlP6SuLIHOpp2SvvIcag8dIwudkzuUy+akrcDp0SkvUCqhfEWuCB2hKTiEjo88Omovnepy47wJqGRsV4RDVEdIPle5Ts8RHde0la8rPxyjIAwsdKornONK/CGiAzIKwtNYqyFrt7Kd4JK6MprQaYk/ByAkyulL8pUhuaLI2Y9NhI7QIEU+mnOlEhDkTJMZLX2lGpGTh0NsZ2W74LjSdFGPaOHPUXFUXhm4xDw/DbBDYLj3e0z5iljppeNRcg8oDVCDImpH/SJqmgYaxaPjmHHVTKEDLoZkH6Wv1NdwWJvmpdt8hAgdramugNKaqgBfeXTAxaej42hIXaj9czqOUJ4vcyDYqrUbZtcYWgod1aOTe8i44z5cS8uN0gulMaTyyrOoRuSEfrUH2KotJ4wQ0Sk+VRO5NEFiC5rg+rrEXOdTy1VE6GiNOvrBHOh+J8yWYERDsmujwOQRYLY4H4de01daCp3YzsrrqqpUv0KwMRyl5SmaLsOjuFZeCS3HtVGgK0YaA6H6c+J7KCmo5uLrEnOdTy1XEaGjNQ5/TnvffmM1otDJO6x0QbYEO7/1qOkrvUamtBQ6lkDnh6pRfTr+1CxQxRHRkRJzj1BXaTk4U51GSF211J+jopaY+6ryygA9dECEjvY4mgX6eDipEYWO6s9JGqT4jECZCQMS0akPo5eY+1OzQBX1tVBRoEy2F5qP3V5/REf16BihYaCnhI6vIzqO1JW+/z9F6GiNr0vLVRxC57hvz9sSHP6c4c7r9BzRKc1TSj3BKch8jdFLzP0xohMY6qywFJ9OyyjOUjyOJjO061P7NtWjU1kEVWW+X5s7qEKn/aCWHSfK12Zk/Y9/ABE62uPrZoEqrmMgjBI+VzsiuwodPUd01GhORCIEhWmzBofQMWDllc3mfA51XLraLMSQ7BnUaE58T0VAuhIcpaS5Qd8+naJMJbJvMp8dlXIXdbBnYbr339fLC53Pq87/P0XoaI1WEZ3ojoBJ6dBqhNBuRbFzno3rxHU9R3S0TluBs8TciGMgik4qZcPmAKf3wF8QQ7JnUDsiJ/Q7+zaTycWno2Oho5aVx/eC4IiWHUudl1hV6v20qKO0PB5Cor17rhYiQkdrHD10fNQsUCUg2Fi9dDK2ORsFug4/jUlRLotO6i88rQeh06a7clmY7ttuqZ5A9efEdAJLgLZr8TRx0kvHI9Tnz1GJMEDTQE/5c0CJaoXVpOy8XWlpkLQViNDRHq0iOmCsXjqujQJdCYuDoEhlW29+Iz0InbA45xuf0aI6qgjwJyOyiqSuPENmHaMfXHF0R9Zx5ZUnhQ74zpBskIorEKGjPY6Ijo89OmCsyivXRoGumEz6TV/pQeiAyygIowkdPzQiq8gYiJZTWeJ8TdcrdHTeS8du97zQ8VWJuWNqub79OSBCR1sqiqGiUNnWMqJToLNIyJm4NgrsOPzs2x2G5KM+W1KT0JvQMZoh2R9Ly1XUx1RySpkXJLhP1m7ArgzLVUvJz0StvNKrR6cwQ4k2mSxn9wFqLj6L6Oh/mKeKCB0tUbsiB0W0rBtmc4lxqbzSM45GgUHQvo726HqM6FirnCWeWgsdo/bS8eeITkiUM6UohuTmoRqRG6pUitB5REeN5rTrc3bVWHPx1RgIg4x/ABE62uLrYZ5nYpTUlRrNaT9IMVGfiR5LzAtOgN0KASHKN04tcQz3NJjQ8eeIDoghuaVkNeLPAf17dBxpq0GeO6ZaYu7NiE55gXNGo0R0hAYp1NCfA06BoPdeOg4j8oi6b4/VYepKXUtM59qDBrWgbS/lMmcfVFdqu5am4tpsUeuImLcQQ3LLaKziClyEjk5baHhD6DiaBnrRkqC+ZsPbapONcBMROlqidURHVf5VpUpqSK/U1SjQlRgdpq70NIwyNgVC48Ba6fwWrHfU5y+yvXbNFr2NGJKbj83q7KuV0ASho8d5V94wIoPTo1OYoTTd9AYGSluBCB1t0bK0HM7opaMjkeCKa6PA+oSOGtEpL4CyfJ8sq1EcHX11kHYxmaDDEGU7PVXbtTSVPD9PW4HzsYlHx33yDitf0AJCG+7jonp0SnMVcaQnCo5DWR6YA+tueNhcItsDJrBVec+bZJCp5SoidLREq2aBrjhGQei08ipje02jwA7ObypnEhTu/OamF8Gml4orlSRV6GzTdh1N5bQfG5FVJHXVfNS0VUJfMFvq3y80DjABdv1FrdVoTkKfur2HzcUS6PwC660Sc0cPHf37c0CEjrZoHdEB/RuSG0tbqejNkKw3odNhqHKZYRChk3dUufTniI76IVGYrr+u3nqnKf4cUDpqh7VRtvVWeeWNtJWKt0vMc41TWg4idLSlSKOBnq7oXegcr6m4qs+IrKK3EnPdCZ2aiM6pfcowPr3j+Mbox0InLE4ZPAn6EehGwSF0mpDyUdNXevPpeFPoeLvE3EDjH0CEjnbY7RLRaQy73SWi04jQ0VPTwLLTzoohdV1aE9GuJk1ph5M7tF5N4/h7aTko3ikpMW8eDqFTR1+tM1GbBuqp8spbRmQVR4m5F1JXZfnONKBEdIQGKc+H6nJlWyI6ddNYo0BXYnWUulLFVkSCviqGOhjEp1NV5vSv+XNEB5xCTiqvmk7xKSjOBExKo73GcIyB0FFE5/QR5cuQJRjanuP543szouMoLW8HwZGeP74XEKGjFWo0JzQWAkO0W4cacSg4rr9eOo5GgQMbN+upKSI9pK70lrZSUX06eq+8Up+/4Gjl/8OfMbohefOr8OFs33qMsmqiOW26QXBE4/uH63CCuRrNSewHAUGeP743PToGq7gCETraUagDfw44Q5yVxUrKRU/UN8izLvTU/FCvQscolVeO0Q8pSnrHn3EIHQNGdGxW+PYJ+PU92PO5787rqLhqYkl2hNpLR4dCp/0g7xzfMdjTC0LHYD10QISOdujBnwNKNEkdUaCHaIgrjo7IjVRcgSLYTGYlHajOENMK3QqdQYBJKTkt0vg5aojW4M9RMbJHJ/cgVJUo27s/9t15m1pxpaLLiM4O5dIb/hxwRnSKToK12rPHdkR0jOHPARE62qGHHjoqevTpVJa4NApsQkTHEuj8FqO1T8fR7C5F02WcRXAktO2tbOu5zNwR0THOG2mzUR9jfpoyCNZIqFEJgIPfKs09fUGmOuOqCUZk0J9Hx2aDkzuVbW8JnfB2SiNCu835WeMpDDS1XEWEjlboJaID+hQ66duUoZgNNQo8E72UmDsiOjqMSBihQ3JraBaoEpGodPe1W707m8gbqFEJUCKpB1d7/5xVZZCzX9l2O6Kjk6qrvMNQUagM/FW/eHgasxmiar5Eezp9JakrocloPefKFT0KnaY2CnRFDyXm1ipnSafeIjpgjMqr1jD+QcVsdr5OjJa+UtsURNe8f+z+xPvnzN6jiMKwNk1/74xwmXeltX8PXIzIA5SGht7CGyXmZaeVsRUgER2hCRRpPLncFYfQ0dE3SrVRoDtCRw8l5gUnlDfiABfvk55Icono6OFN/0ys1U7B3RoiOmBMQ7LN6ky/XPiwcrn/G+9XX7n6c5pqVFcjOtYKJZKiNd7sn+OKN0rMVTEekdi0ijedIEJHKxypKx0InWidRXTsdmfFVWMdkV3RQ4m5Gk2K6ax8W9cbCf2UvkTl+fqMIBSeUIYRWoL14V/zBQ5DsoGETs4BZahmYDgMuEFpRllVAgfXePe8Wao/p4lpK4DAUAiq6feih/SVr4SON0rMc40140qlWe/ES5YsISUlhZCQEEaOHMmWLVsa3H/x4sX06tWL0NBQkpOTeeCBBygvL3frmOXl5cyZM4c2bdoQERHBlClTyMrSceVIQ9hsTqETpQOh45q60sO3/NNHoDSnplHgwKbfTw/zrvRacaUSEOQ0cbqaSfWCI22lU6HoDYxYeaWmrdoPUIZqnnOl8ru301fudER2Re2OrPUYCNdImCEjOuroBz8XOitXrmTevHksWLCAbdu2MXDgQCZOnEh2dt0voOXLl/PQQw+xYMEC9uzZw9KlS1m5ciUPP/ywW8d84IEH+Oyzz3j//fdZt24dGRkZXHvttc14yDqgNEdJb2ByVgRoSUzNBPPKIn300jnuRqNAV9TUVeEJ7SpY9C50QN+G5NZUWq6ifjs2UnfkM6MSfa5SLvd9BdUV3jmnzeasuGpqDx0Vdd6V1iXmOQeUyFdgOMT38O65vOHRccygM44RGZohdBYtWsTs2bOZNWsWffr04ZVXXiEsLIxly5bVuf+GDRsYM2YM06ZNIyUlhUsuuYSpU6fWitg0dsyCggKWLl3KokWLuOiiixg6dCivv/46GzZsYNOmTc186BqiNguMaOddM1pTCQx1Ci49pK+aOt/qTCISFG+M3eadGS9NwRBCR+2QrENDcl4rqrhSiXVJXdls2q6lqagVV2rDu47DlTR8ZREc+t4758w/qhzfEuy+SHBUXmkc0XE0CqyJhHkTb0R0DDa1XMUtoVNZWUlqaioTJkxwHsBsZsKECWzcuLHO+4wePZrU1FSHsDl8+DBffvkll112WZOPmZqaSlVVVa19evfuTadOneo9b0VFBYWFhbV+dIOeSstV9FR55U6jQFdMJufj0KryKvegcqnnD2pV6Jzcqb/eLa0xohOdDOYAxSxblKH1ahrHZoXMX5TtpEHKpdnsTF/t+dQ751WjOe3OUfpmuYNeSsx95c8BZ0Sn5BRUlTe8b1Mx2NRyFbeETk5ODlarlYSE2tUkCQkJZGZm1nmfadOm8eSTTzJ27FgCAwPp1q0b48aNc6SumnLMzMxMgoKCiImJafJ5Fy5cSHR0tOMnOTnZnYfqXfTULFBFTV9p3cujVqNAN4UOuIyC0MCnU10Jp/Yp2wl9fX/+phLXDYKjoLpMKdfVE3lHlUuDfWNsEZYA5+vWCIbknP2KETkoAtp0d17fp0bo7P1c+V/wNO52RHYl3KXEXEt8KXRCY5UeTeCZqE5pntPaYLD/T6+7/dauXcszzzzDSy+9xLZt21i1ahVffPEFTz31lFfPO3/+fAoKChw/x4/rqHRaIjr1k7Fd8S9FJjm/kbiDliXmOfuUiqGQaOVbul4xm51vtHrqkGy3t65mga4YyZCspq0Sz0i/dBqlCIryAjj6g+fP2xKhowePjrXa+Rh8IXRMJud7qCeEjirCI9tDUHjLj+dD3BI68fHxWCyWs6qdsrKySEys+0P70Ucf5dZbb+WOO+6gf//+XHPNNTzzzDMsXLgQm83WpGMmJiZSWVlJfn5+k88bHBxMVFRUrR/dUKSTgZ6u6EXoNDdtpaJlibmrUVLvwyj1OMm8JEcZLotLCrK1YKQp5mrFlZq2UjFb4JzJyrY3qq9aFNGpqbrSUujk7FOiqEGRvjPzerLE3ICjH1TcEjpBQUEMHTqUNWucvRJsNhtr1qxh1KhRdd6ntLQU8xllohaL8i3Abrc36ZhDhw4lMDCw1j779u0jLS2t3vPqGl1GdFymf2uJOxPL60LLEvOsZlaEaIEeOySr0Zzoju5V2/kDRqq8aij9olZf7f3Cs8MkS/OUakpoXlo4XAcRHcfzNsh3rRMcU8w9UJxhUCMygNslP/PmzWPGjBkMGzaMESNGsHjxYkpKSpg1axYA06dPp0OHDixcuBCAyZMns2jRIgYPHszIkSM5ePAgjz76KJMnT3YInsaOGR0dze233868efOIi4sjKiqKe++9l1GjRnHuued66rnwHapHJ0pPHh0dRHTsdpeITjOFjpbzrhxCR8f+HBU1opO9R/FF6SEUrUYz9Fyx5i1iDZK6slmdkRW14sqVzmMhNA5Kc+HYT9D1As+cV/3fiumspIbdxeHR0YnQ8RUejeioU8uNZUSGZgidG2+8kVOnTvHYY4+RmZnJoEGD+Prrrx1m4rS0tFoRnEceeQSTycQjjzxCeno6bdu2ZfLkyTz99NNNPibAP/7xD8xmM1OmTKGiooKJEyfy0ksvteSxa4ceIzqqp6SiEMryITTG92tobqNAV9SITskp336A2+0uU5UNENGJSlLauBdnwslfoLMOIqOtsbRcxZG6Oqq8lvSa+qzPiKxiCYDel8P2t5X0laeETkvSVuCcd1VRoPT50SJimLVbuXS32WFL8GSJuYFTV81q4jJ37lzmzp1b521r166tfYKAABYsWMCCBQuafUyAkJAQlixZwpIlS9xer66ornSGT/Xk0QkKg7B4RWjkp2kjdNRGgYkDmv9GFBqjfOMrL1DSVwl9PLa8BinOUp47kxna+eicLaXDUNj3heLT0YPQaY2l5SqxnQGT0iemJMf5waw3HH1gBtaffulztSJ09nwGlz3vmX4xze2IrBISA+ZApVig5FTzCh1aihot92XE0pMRHQNOLVdpJT3WdURxjenaHKiEePWE1umr5sy3qgstSszVaE6b7koDRiOg+nT0UnnVmiM6AcHOD189p6/ObBRYF13OV75slGTD8c2eOW9mM2ZcuWIyufTS0SB9Za1yFqH40mjvKY9OaZ4yHw8MGdERoeNrXNNWepvlo7nQUTsiN7PiSkX9xuRLQ3JWzTdOIxiRVfQ2CqI1R3TAKfD0bEiur+LKlYAg6HW5su2J6qvqSji1V9luSVrYMe9KA6FTmKF0bLcE+XbsjxrRKS+AiqLmH0cV35FJSvTfYOjsk7YV4GgWqKO0lYqWQqeyxPmtraURHS0MyWqTQyP4c1TUqpnTR6EkV9OlUFHk/KbdGiM6oH9DsrVa8XNB431g1OaBuz9t+ViLU3s9059Ky146aiPW6I6+/YIbHAnBNebtlqSvDFxxBSJ0fI8ejcgqWgqdljYKdEWLEvPmDhvUktBYp6FU60nm6siOsDbNq6rxB/TeSydnf9P7wHS9UNmvKAPSf27ZeV39OS0xaWs57ypfFToaNBJVozotSV8ZdGq5iggdX6PHZoEqqkAo0EDotLRRoCu+bhpYVa58CICxhA5Akk7SV3mtPG0FLkJHp6krNW3VfkDjUYnAEOg1Sdluafoqq4X+HBUt512pXx5jtBA66hRzT0R0jGdEBhE6vkfXEZ2af0ItIjqORoEeEDqOiM5RpVTX25zaq0SjQmP11RupKeilQ3JrHf3git7HQLg7p0ltHrj705b9H2Z6yP+m5bwr9cuj+t7kSzxRYq6+JiV1JTQJPTYLVFHDquUFSi8dX2G3t7wjsitqCq6yWKkW8DZZBhr9cCaq0MnY5htRWB8S0XE+9rI83/7/NZWmVFy50m08BIYpH/LNTY3a7c5J6S2N6Gjp0dFD6qq5ER273bBTy1VE6PgaPUd0giMUjwT4dor56aPKm485sPmNAl0JDFGa4QHkH2358RrDYURu4RuxFiT2B3OA8vxrObne8Y2xFQud4AiIqGmSqrfKq1oDKQc17T5BYdDjEmW7uemrguPKFy9zILTt3bxjqGhZXq7+b2mRumppiXlpnvI3AMN+ERGh42sKdVx1BdoYktVoTvuBikjxBL4sMXeE1g0w+uFMAkOc69Zy7lVrLy1X0WvlVXMHUqrpqz3NTF+pJv+2vZWy9ZagldCx2aCgRmQYMaKjvhajOhiytBxE6PiWyhKlBTnoM6ID2gidls63qgtflZjb7cYa5lkXWhuSqyudHwStOaID+jUkO9JWDXRErosel0BAiPJhqf6fuIOj4soD/1uO1FVOy0ve3aE4C6yVStd0LSwLrh6d5ohNA49+UBGh40vUtFVgOARHabuW+lC/ceT7MI3hqUaBrviqxLwwA8pOg8nS8tC6VjgMyRpFdAqOK83UAsOcqZvWisOQrDOh05RGgXURHAHdJyjbzUlfecqfA860vN2q/M/6CjVtFdUBLIG+O6+KKnSqSpv3uA3eQwdE6PgWV3+OXk2rvh6f4Noo0JNCJ9al8sqbqN9S43t6Lu3ma1Shc3KHMp3a1ziMyCn6/b/wFXrtpeNuxZUrjuqr5gidFg7zdMXiMnbHl7101Oi4FmkrUN6Xwmq6Qhc0w6djcCMyiNDxLXruiqzi69RVxo6aRoHtPTtoz1eCLctAE8vro20vJcpYWezsB+RLHKXlxv3G6DH0OAbCWu38MtLUiitXek5URh/k7IfsvU2/X3mB8//XU2lhLXw6WhqRVaJbUGJu8NJyEKHjWxxCR6f+HPC90HFNW3ny27zDo3Pcu1EKR0dkAxqRVcwWZ0pCC5+Oa0SntaOakYtOQmWptmtRqWVEbsaHXUg0dLtI2XYnqqNWM0Z1hDAPDUBWfTq+7KWjZWm5inpudyM6djvkqkJHIjpCU9BzabmK+q2jPN9ZUuhNjntoYvmZRHVQyqZtVU6B6Q0cRmQDlpa74hjwqYFPR5oFOgmLg5AYZdvbadem4khbDWr+nKbmpK88mbZSUQd7+jKi4+iK7MOp5WfS3KaBpbnOAhoD/3+K0PElem4WqBIc6cxje9uQbLe7RHQ8LHTMFue3GG8ZkqvKIPegsm3k1BVoW3klzQJrozefjmvFVXPpdanyxSP7N8g52LT7eNKIrBKuQdNAPaWu3C0xd5SWd4TAUM+uyYeI0PElRojogPMf0tsN5DzdKPBMvF1inr1bqRYKizd+tZBqSM7apczu8hU2mzNyYeBvjB5Fb6MgHBVXzTAiq4TGQpcLlO09TYzqZHpoxpUrvh4DYbe7pK4MGNFxVFwZ+39ThI4vKdTxQE9XfOXTcTQKHOCdiiVvl5g7OiIbcPTDmcR0UgSbrbp5/U6aS3Gm4v8wWbT1MOgJNaKjB0NyrY7ILRA64F76yloF2XuUbU9GSyN8PNiz7DRUlSjbniy2cBfHYE83PTp+UHEFInR8h91uoIiOGgnxkdDxdNpKxdsl5pkGbxToisnk4tPxYfpKTVvFJGvTY0SP6Kk78qm9UF2u9P1qaWqx9xWKoD25s/E+QTkHwFqhGKBjUlp2XlccVVc+iuio0eTwdtq2n3BEdDLca5Zo8KnlKiJ0fEV5gfLNFQwU0fFyabajI7IH++e44u0Sc6N3RD4TLSaZy+iHs9GTR0dNW7nbEbkuwttAyhhle8+nDe/r2rahpeettQYfe3TUtJWWRmRQPnNMZqU4w53H7gel5SBCx3eo0ZyQGP2bunyRuqosdb6ZeS2ik6JceiN1Zbe7eAj8ROgkaVB5lScVV2ehfqgUnFDGY2iJa8WVJ3CkrxoROt4wIoOz6qr4VPPGIbiLHozIAJYA56Djpqav7Han0JHUldAkigzizwEXoeNFM3LGdsUP4ulGga6oEZ2ik1Bd4dljFxxXyi7NgRDfy7PH1go1dZV7AMryfXNOieicTUQ7pYGj3ebbmXN14ai4GuSZ4/WeDJgg/eeG318cg3I9/CVC7aNTXaZ0Zfc2euiho+JoGthEoVOSAxWFgMnw/58idHyFUfw54PynLMuDiiLvnMNRVj7Me0be8HjlAwO750WbY6pyr5ZPVdYL4fFOcah+k/c2joiOsUPjHsVk0keHZGuVM+raUiOySmQCdB6tbO/5rO597Hbv9NABCApXZqqBb3w6BTpJXYGLIbmJlVeqETm6o3HH29QgQsdXGGH8g0pIlLNpmbeiOse9bEQG5QPDUWJ+1LPHViuujNwRuS7UqE6Gj9JX0iywbvRQYu4wIkd79hv9OVcql/VVXxVlKo3qTBZod47nzqsS7sPKK9UfqIeIjrsl5g5/jvH/N0Xo+Ao1ohNlAKED3vXp2O3OiitPd0Q+kxgvVV5leSm0rjW+nGRelu+cpizjH2qjh8orR9pqgGcNwedMVi6Pb4bCOrqWq9Gc+J7e8TP6speOXszI4H6JuZ9UXIEIHd9hlB46Kt4UOvnHlLCxOdBzuf/6cJSYe9iQ7G9GZBVfCh01mhORoKQUBCeOyisNU1eORoGDPHvc6A41kVw77P387NsdRmQv/W9F+KjyqqJIGaUD2puRoRkRHf/ooQMidHyHkTw64N3S7ONebhToijceR2WJ85u20WdcnUn7gUoZalGGU5x7Cxn9UD96KDF3VFx5yJ/jSkPNA73lz1Hx1bwrNZoTEqOM1tEad8dA+ElpOYjQ8R0OoWOUiI4Xx0B4a75VXXgjopO1G7ArkQi106q/EBQObWt8Ed6O6viRB8DjOMzIR8Fm9f35rVXOqKU3oq59anw6x35SSr1dyfLC6AdXfNVLRy+l5SpRNamr4kyl43VD+MnUchUROr7AZlNeXGAgoePF1NVxl4orb6N6PzwZ0XE0CvQzI7KKrwzJR35QLv3gjdTjRHUAS5DS4M3d+USe4NRepTNxcLR3vtHHdFIiRXZb7fRVRbHTG+KtaKmvPDrqe6eWM65cCW+r2AXsNmdxTH2UnILKIpTS8hRfrM6riNDxBaW5Ss8YTM78sN7xltBxbRTobSMyOFNXZaeV7tSewN86Ip+JL0ZBHFwDR9Ypb7z9r/PeeYyK2eJ87WqRvnKkrQZ6r/1DXemrbDVamui9aKmv5l2p7516MCKDYiiPSlK2GzMkq2IzOtnwpeUgQsc3qM0Cw9saZ56PWg5Zmqt8y/IUJ3cooi8i0Tcll8ERENZG2fZU+sobU5X1hMOQvN29uThNxWaF1QuU7RF3SuqqPrQ0JHu6UWBdqGXmR36A0jxl21sdkV3x1bwrvaWuwFl51ViU0M/SyiJ0fIHRjMgAoTEQEq1se9Kn4zrfylcTvz1pSLbZXHro+GlEp10fCAhROj97I5rwy0qlPD84Gs5/0PPH9xe0NCR7q+LKlTbdFEFjt8LeL5TrfPElwlceHT11RVZpaom5H1VcgQgd36DmQ9WwoVHwRvrK2xPL68KThuT8Y0ru2hIE8T1afjw9YgmExAHKtqfTV1Vl8N3/Kdvn/wHC4jx7fH9Cq6aBrkZkb1RcuXJOTfpKHfLp7YorcEZ0yk4rj9Vb6DGi09QScz/qoQMidHyDESM64DTReUro2O0uER0fCh1PRnTUaE7bXsZJQzYHb00y3/Sy8iYbnQwj7vLssf0NNaLj6WaXjZG9RzEih3i4I3JdqD6dQ98r6Sv1/8ubQic0Vum6DN7z6VSVQ3GWsq0XMzI0vcTcT4Z5qojQ8QVGaxao4smITkkOrLxFyYtbgpR+Lb7CkxEdhxHZT/05Kt6ovCrJhfX/ULYvesQvTI5exTV15YtJ2ypq2qq9F43IKm17Ku0MbFWw8V/KsM3AMO/2bjGbve/TUVNDgeH6ilqqJeYNDfZ0nVruBz10QISObzBqRMdTQmf//+ClUUoZqTkQLn3OO63d68OTJeaO0Lqf+nNU1IjOyV+gutIzx/zheWUacmJ/6H+DZ47pz0QnK80bq0qd0QFf4M1GgXWhRnU2vaJcJvRVqs68iUPoeMmnU6BWXCX7zovYFJoS0SnOhspi5bXnB6Xl0Eyhs2TJElJSUggJCWHkyJFs2bKl3n3HjRuHyWQ66+fyyy937FPX7SaTieeff96xT0pKylm3P/vss81Zvu8x0kBPV1oqdCpL4LP7YfkNyjentr1h9hoYNstjS2wSMS4RnZZ+M/b30nKVuK5K6sJaAdm/tfx4eYdh63+U7Yuf8uzsJH8lIMhpZPVl5ZUvKq5cUZsHVpUol77431JLzM9sVugp9GhEBqdHpzRHSa/VhevU8oBg36zLy7j9brNy5UrmzZvHggUL2LZtGwMHDmTixIlkZ9cdAly1ahUnT550/OzatQuLxcL111/v2Mf19pMnT7Js2TJMJhNTpkypdawnn3yy1n733nuvu8vXBqN1RVZpidA58TO8MhZSX1d+P/d3cOc636asVKKTAZMSFm9Jk7DyQqdfwt+FjskESWo/HQ+kr9Y8qaQnuk+Abhe2/HitBV8bkqsrnT4Zb1ZcudKuD7Tp7vzdF20bvB7R0aERGRR/UmCYsl2fIdnP0lbQDKGzaNEiZs+ezaxZs+jTpw+vvPIKYWFhLFu2rM794+LiSExMdPysXr2asLCwWkLH9fbExEQ++eQTLrzwQrp2rf1ER0ZG1tovPNwAgwCtVc5/JqMKndIcpdFfU7BWwfcLYeklyj9MVAeY/glMWqidJyMgyPlNpiXpq+w9ymVkewhv0/J16R1PDfg88TP89hFggglPtHhZrQqHIdlHEZ1TPjQiq5hMzvQVOCv+vIm3PTqOrsg6EzomU+OVV35WcQVuCp3KykpSU1OZMGGC8wBmMxMmTGDjxo1NOsbSpUu56aab6hUpWVlZfPHFF9x+++1n3fbss8/Spk0bBg8ezPPPP091df3zOioqKigsLKz1ownFWYAdzAHOxnVGITQGgqOU7ab00sk5qAicdc8qvTH6XQf3/ARdx3lzlU3DE4bkrBp/jr9Hc1Q8UXllt8M3jyrbg6b5v7fJ0/i6l45r2sqX3hJV6JgskNDH++dzCB0vVV2pqSu9dEV2xeHTqceQ7Gc9dAAC3Nk5JycHq9VKQkJCresTEhLYu3dvo/ffsmULu3btYunSpfXu8+abbxIZGcm1115b6/r77ruPIUOGEBcXx4YNG5g/fz4nT55k0aJFdR5n4cKFPPGEDr49qmmriERj+hJiOim+lPw0paS6Lux2+Hkp/O8RJT0UEg2XL9JXa/+YzsoAwfyjzT+Go5lZK/mwViuvTu2FiqLmTWDe9xWkbVAaEF74F8+urzUQ6+PUlS8aBdZF4gCY9Kwy6TvIB5F6dRSPt+ZdFehZ6KhNA+uL6PjPME8Vt4ROS1m6dCn9+/dnxIj6e6gsW7aMm2++mZCQ2mmOefPmObYHDBhAUFAQd911FwsXLiQ4+GzD1Pz582vdp7CwkORkDcKIjmaBBktbqTiETj2RkKJM+GQuHFyt/N7lfLj6Zec/k17wSESnlRiRVSITlTB3YTqc3AkpY927v7Uavq0Z9XDu75zfJIWm4+sxEGrFla+MyComE5x7j+/O583UlbXa2VJEb6kraLjE3A9Ly8HN1FV8fDwWi4WsrNqljllZWSQmNlw6XVJSwooVK+pMSan8+OOP7Nu3jzvuuKPRtYwcOZLq6mqOHj1a5+3BwcFERUXV+tEEo5aWqzRkSN79qVI2fnA1WIJh4kK49RP9iRxoeYm5zQZZu5Vtf51xVRcdWmBI3v4W5OxXUrZj7/fosloN6uu2PN85D8pb1DIi+6i0XCu8mboqylBS95YgiEhofH9f01CJeXGWUv3mR6Xl4KbQCQoKYujQoaxZs8Zxnc1mY82aNYwaNarB+77//vtUVFRwyy231LvP0qVLGTp0KAMHNl6Zs2PHDsxmM+3a6XwauFGbBarUJXTKC+Hj38F7t0JZnvLBf9c6GPU7/abnHCXmR5t3/9NHlDeAgBC/Cuk2iqPyyk2fTkWRYkoHuODPzrlpgnsEhTnfO7wd1Tm1B6yVSvrIjz7k6sS16srTg2vV98qoDvp8P2zIjOw6tTwgyHdr8jJup67mzZvHjBkzGDZsGCNGjGDx4sWUlJQwa5bSG2X69Ol06NCBhQsX1rrf0qVLufrqq2nTpm5DbmFhIe+//z5///vfz7pt48aNbN68mQsvvJDIyEg2btzIAw88wC233EJsbKy7D8G3GD2io4ZeVXPdsQ3w0V01/8wm5Zv6uIf1/0+hpq4K0pXQssXNl76atmrb2/37GpnmVl5t+JeSFojrCkN93DfJ34jrqqTATx+BjkO9dx5H2soHHZG1RhU6tmolWubJ7sV6NiJDwx4dP0xbQTOEzo033sipU6d47LHHyMzMZNCgQXz99dcOg3JaWhrmM1Tsvn37WL9+Pd988029x12xYgV2u52pU6eedVtwcDArVqzg8ccfp6Kigi5duvDAAw/U8uDoFkezQIMN9FRR/1lPH4VvH4f1iwG7cv01r0Ln0dqtzR0iEpX0mrVCyU27+421tRmRVVRTakGa0lxNbbTWEEWZsOFFZXv8Av2LYL0T20Ux0nvbkKxWXPl72gqU12RINJQXKFEdTwodvfbQUVEjOhUFZxcZ+GHFFTTTjDx37lzmzp1b521r164967pevXphb6Qj7Z133smdd95Z521Dhgxh06ZNbq9TFxg9ouPaS0edUzToFqUvTohGvqfmYDYrbzy5BxVDsrtCp7XMuDqTkGiI76l4bTK2Qc+Jjd9n7UIlzddxeO3+KELzcDQN9HLqSquKK60Ib+cUOvVVlDYHRw8dnUZ0giOcIq8gHdr1dt7mhz10QGZdeZ8ig3t0QmOdvXRC4+CGt+HqJcYSOSotmWLeWiM64F4/nVP7YNtbyvbFT/l/CsQX+KKXjqsR2dcVV1qhpq88XWKuCh29RnSg/sorP5tariJCx5tUliqqGYwb0TGZ4JKnYMgM+N1G51waI6JGcdwtMS8vcA7pS+jr0SUZAndGQaxeAHYb9L4COjdcoCA0EV+Mgcje3XqMyCoRXqq8UlNXeiwtV6mraaCflpaDj/votDqKa9JWAaHGrjoZOlP5MTqxzay8Ur/pRnVUIlytDdeIjt1ef5Tm6HrY/5XS3XbC4z5bnt+jNg0syYaKYiX14Glc01atJQrnjV46NptTPOjVjAx1G5KLMqGqVCktV6PffoJEdLyJ6s+Jat963jz0THNTV605bQXK4zYHKq0E6hOJrqMehs6E+B6+Wp3/ExrjHB/jrZlXWjUK1JLwmtYknhzsWZKtRMZMZojScQFKXSXmqhE5ppPfFRCI0PEmRu+h4280tztya5txdSYBwU6Rl1FP+uq3VcptQREw7iHfra214O1REK2p4kolPF65LPag0FFLyyOTwBLoueN6GkdExyV15adpKxCh412MXnHlb6gRnZLspk9jB4noQMP9dKor4NuauXJjfu+cIyR4Dm+OgqiucOmIPMjzx9crEV6I6KjRYj0bkaHuiI6fVlyBCB3v4uihIxEdXeBaQVbXSIu6sFkhe4+y3dpKy11pqPJq61LlDT4iEUbN8e26Wguq0Nn/NVirPHvs7N1gq1KMyH7mzWgQb3h09DzM0xXXMRBq6xc/7aEDInS8iyOiI0JHF5hM7vt08g4rE9kDQp3VL60RtfLq5E6ls7RKWT788JyyfeHDvpk83Rrpfx0EhkPaRvjqT84PJ0/gmrZqTV5Cb8y7yjdAxRU4IzrVZVB2Wtn2w6nlKiJ0vImkrvSHuz6dTNWf0wfMFu+syQjE94CgSKUq49Re5/Xr/6G8UbbtDYNu1m59/k58D7huKWCCn5fBppc9d+zW1ihQRRU6lcXupbIbQu9dkVUCgp2Pv+CEX5eWgwgd72L0ZoH+iKOXztGm7e/oiNyK/TmgiDz1g1BNX+Ufd37gXvxk65oBpgW9LoVL/k/Z/t/DsO9rzxy3NVZcgTL6ICBE2faUT8coER2o7dMpOqlEd0wW55dBP0KEjrew2yWio0fcTV05jMit2J+j0qEmfaVWXn3/tDI7LOU86HGJdutqTYyaU9PTyg4f3OaMODaX6grI2q1st6aKK1DSdK5TzFuK3e7SFVnnHh2oXXmV61JarudqsWYiQsdbVBQqYX6QiI6ecDd1pVajtPaIDtQ2JJ/8BXauUH6/+MnW5e3QEpMJLvsbdB2nzBNbfqPzC1VzUI3IobHG+HD2NJ4UOmWnlb8JOEWEnnEVOqoR2Q/TViBCx3uobz4h0RAUpu1aBCeuEZ3GDJ2lec5ZMAl9vLsuI6AakrN2w9cPAXbod50z0iP4BksgXP+mMmy1MB3+e1PzPSauaavWKFY9Oe9KjeaEt4PA0JYfz9u4pq78dMaViggdbyHNAvWJ+q21otBZbVAfajQnppOxR3h4iuiOypu43QrHfgJLEIx/VOtVtU5CY2DaSmXQbsZ2+OhOZfyAu7TGRoGuRHgwomMUI7KKa4m5H/fQARE63kP8OfokKMzZ+r0xn47DiCz+HED5xq+mrwBG3Nl6BkDqkbiucNNyRXDu+Qy+e9L9Y7TWiisVT46BMJIRGWpPMJeIjtAspFmgfmlq5ZV0RD4bNU0VEg3n/UHbtQjKhPgr/6Vsr/8HbH+n6fd1NSK3toorFU96dBxGZIMIHTWiU3jS2XFbPDqCW0izQP3SVEOylJafzaCblSqrK1+EsDitVyMADLwRzv+jsv3Z/coU+aaQ9VuNETmudRqRwTkGwhMeHUfqyiDl2RGJyvBRW5WztNxPXwcidLyF9NDRL00pMbdWu4x+6Ov9NRmF6A4w83Poc5XWKxFcGfcw9L1G+dBaeYvTc9EQrmmr1mhEBudgT090R1YjOkZJXVkCan8+xXb2y9JyEKHjPcSjo1+aEtHJPaj0iAmKcE6OFgS9YjbD1S8rHqqy0/Du9UrVYEO01kaBrjg8Op6M6BhE6ICz8gr8Nm0FInS8h6Su9EtTIjpq2qpdH+VDRBD0TmAo3PRfJaKQdwjemw7VlfXv39orrsDp0SnNqz3DzV0qipxVnEaJ6IDTpwN+W3EFInS8g83mFDpRInR0hxrRyU+rvyRX7TgrRmTBSEQmwNQVSiTy6I/wxQN194uqKnemZltrxRUoPjOTGbBDaW7zj6NWXIVEQ0iUR5bmE1wbG/ppxRWI0PEOpblKrhwgIkHbtQhnE9VRMd5ZK53VcWciHZEFo5LYD657XfkA3/4O/PTPs/fJdjEiGykC4WnMFghro2y3JH3lSFsZzMwb5SJ0JKIjuIX64Rne1m/NXYbGEuD8JlNf+koqrgQj0/MSmLhQ2f72caXPjiuuaavWakRW8UQvHYcR2WBCp1bqyn+9iCJ0vIEYkfVPQ4bkklynWJXRD4JRGXkXDL8DsMOHs53mY5BGga6olVfFLRA6RjQig9OMbA4wTll8MxCh4w0czQKTtF2HUD8NGZKzavw5sV0gONJ3axIET2IywaS/QrfxSp+U5Tcp7f5BKq5cifBERMdgXZFVEvtDlwuULueWAK1X4zVE6HgDiejon4YiOtIRWfAXLAFw/evQtjcUZ8J/b1QqjBxG5FZccaXi6I7cAo+O0boiq1gCYcanMGmh1ivxKiJ0vIE0C9Q/MSnKZZ0RHdWILDOuBD8gJFoZABoWr1QTvnEF2KoVE65r1U1rxSF0WtA00Khm5FaCCB1vIBEd/dNQREdNXUlHZMFfiE2Bqf8FS7BScQVK2qq1G5HBKXSaOwaiqhyKs5Rto5mRWwkidLyBDPTUP+pgz8J0ZbihirUKTu1TtiV1JfgTySPg6pecv0vaSqGlHp3CGt9TYJjMf9MpInS8gTQL1D/hbZU3JuxQcMJ5fc5+pb9OcJRfVyEIrZT+1yll53FdlW3BZd5VM4WOmv6OTpYImU4RoeNprFXOEKhEdPSLyeTMp58+6rxeNSIn9JU3LcE/GfU7uG87tDtH65XoA9c+OnV1kW6MfIOWlrciROh4muJswK503g2L13o1QkPUVWIujQIFoXWhenSslVBe4P79xYise0ToeBpXI7IMg9Q3dRmSs1wiOoIg+D+BIUqqGppXeWXUHjqtCPkk9jRiRDYOdUV0HD10pLRcEFoNDp9OMyqvJKKje0ToeBqH0JHSct3jiOgcVS6Ls2ve6EziXxCE1kRL5l055lxJREeviNDxNBLRMQ5qibmausqs6Z/TphsEhWuyJEEQNMAx78rNiI61GgprGsSKGVm3NEvoLFmyhJSUFEJCQhg5ciRbtmypd99x48ZhMpnO+rn88ssd+8ycOfOs2ydNmlTrOHl5edx8881ERUURExPD7bffTnFxcXOW712kWaBxUFNXZXlQUeTSEVmMyILQqnD00nHTo1OUAXYrmAMhQt7z9YrbQmflypXMmzePBQsWsG3bNgYOHMjEiRPJzq5bCa9atYqTJ086fnbt2oXFYuH666+vtd+kSZNq7fff//631u0333wzv/32G6tXr+bzzz/nhx9+4M4773R3+d5HIjrGISQKQmOV7dPHpOJKEForzZ135TAid5TiEx3j9l9m0aJFzJ49m1mzZtGnTx9eeeUVwsLCWLZsWZ37x8XFkZiY6PhZvXo1YWFhZwmd4ODgWvvFxsY6btuzZw9ff/01//nPfxg5ciRjx47lxRdfZMWKFWRkZLj7ELyLNAs0Fq6GZBnmKQitE4fQcdOjUyA9dIyAW0KnsrKS1NRUJkyY4DyA2cyECRPYuHFjk46xdOlSbrrpJsLDa3sg1q5dS7t27ejVqxf33HMPubm5jts2btxITEwMw4YNc1w3YcIEzGYzmzdvrvM8FRUVFBYW1vrxCYUy0NNQqIbknAOQUzP6QSI6gtC6cMy7clPoOIzIUnGlZ9wSOjk5OVitVhISEmpdn5CQQGZmZqP337JlC7t27eKOO+6odf2kSZN46623WLNmDX/9619Zt24dl156KVarFYDMzEzatWtX6z4BAQHExcXVe96FCxcSHR3t+ElO9oHiriqD8nxlWzw6xkCN6Bz4RpnoHBItE50FobXR3HlXqtCRiI6uCfDlyZYuXUr//v0ZMWJEretvuukmx3b//v0ZMGAA3bp1Y+3atYwfP75Z55o/fz7z5s1z/F5YWOh9saOmrQJCICTGu+cSPINaeZVWE5FM6C+jHwShtdHi1JVEdPSMWxGd+Ph4LBYLWVlZta7PysoiMbHhCEZJSQkrVqzg9ttvb/Q8Xbt2JT4+noMHDwKQmJh4ltm5urqavLy8es8bHBxMVFRUrR+v46i4ai8flkZBTV3Zbcql+HMEofWhCp2KQqgqb/r9pCuyIXBL6AQFBTF06FDWrFnjuM5ms7FmzRpGjRrV4H3ff/99KioquOWWWxo9z4kTJ8jNzaV9e8XnMmrUKPLz80lNTXXs891332Gz2Rg5cqQ7D8G7FIk/x3DEpNT+XUY/CELrIyQaLEHKdlOjOjYbFJxQtiV1pWvcrrqaN28er732Gm+++SZ79uzhnnvuoaSkhFmzZgEwffp05s+ff9b9li5dytVXX02bNm1qXV9cXMwf//hHNm3axNGjR1mzZg1XXXUV3bt3Z+LEiQCcc845TJo0idmzZ7NlyxZ++ukn5s6dy0033URSUlJzHrd3kB46xiMmGXCJvokRWRBaHyaT++mrkmywVoDJDFEdvLc2ocW47dG58cYbOXXqFI899hiZmZkMGjSIr7/+2mFQTktLw3xGP4F9+/axfv16vvnmm7OOZ7FY+OWXX3jzzTfJz88nKSmJSy65hKeeeorg4GDHfu+++y5z585l/PjxmM1mpkyZwgsvvODu8r2L9NAxHgHByt+rKEN5w5LRD4LQOglvC4XpTRc6atoqMgksgd5bl9BimmVGnjt3LnPnzq3ztrVr1551Xa9evbDb7XXuHxoayv/+979GzxkXF8fy5cvdWqfPkR46xiS2syJ02vSAwFCtVyMIghY4Ssyb2DSwQCqujIK0cvQkhRLRMSRqibkYkQWh9eJuibkYkQ2DCB1PIpPLjUmPi8EcAL0u03olgiBohTrYs6lCR7oiGwaf9tHxa+z22uXlgnHofx2cM1nx6wiC0DoJdzeio3ZFFqGjdySi4ykqiqCqRNmWiI7xEJEjCK0bdz06+dIs0CiI0PEUajQnOBqCwhveVxAEQdAXEWp5eU7j+9rt0hXZQIjQ8RSOZoESzREEQTAcjj46TYjolJ2GymJlW2bj6R4ROp5CmgUKgiAYF9WjU5oLNmvD+6rRnPC20pLCAIjQ8RTSLFAQBMG4hLUBTMrcu9K8hvcVI7KhEKHjKaRZoCAIgnGxBEBYnLLdWOWVGJENhQgdT1EoAz0FQRAMTVN9OtJDx1CI0PEU4tERBEEwNuFNrLxypK4komMEROh4CmkWKAiCYGya2ktHIjqGQoSOJ7DbxYwsCIJgdJo670rMyIZChI4nKM0FW5WyHZGg7VoEQRCE5uGYd9VARKeiWOmjAxLRMQgidDyBGs0Ji4eAIG3XIgiCIDQPx7yrBjw6atoqJFr5EXSPCB1PIP4cQRAE49MUj45aWi5GZMMgQscTOPw5UnElCIJgWCKaENHJP6ZcStrKMIjQ8QTSLFAQBMH4uHp07Pa691FTV2JENgwidDyBNAsUBEEwPmrqqrrcObTzTKQrsuEQoeMJpFmgIAiC8QkKh8BwZbs+n4700DEcInQ8gfTQEQRB8A8iGumOnC+pK6MhQscTSNWVIAiCf9DQvKuqciiueb+X1JVhEKHTUqzVzn8IETqCIAjGJryB7siF6cplQCiEtfHdmoQWIUKnpZRkg90GJovTsS8IgiAYEzV1VVyH0FFHP8R0ApPJd2sSWoQInZai+nMiEsBs0XYtgiAIQstwpK7qEDpiRDYkInRaivTQEQRB8B8cqas6PDpiRDYkAVovwPB0Hg0zvwAkjCkIgmB4VAtCg6krETpGQoROSwmNhZSxWq9CEARB8AQRDZiRC2TOlRGR1JUgCIIgqDRUXi5dkQ2JCB1BEARBUFGFTnkBVFc6r7dWO8vLJXVlKEToCIIgCIJKSAyYa1wdrumropNgt4I5ECJk3I+REKEjCIIgCCpmc90l5qoRObqDso9gGOSvJQiCIAiuqJVXrkKnQErLjYoIHUEQBEFwpa4xEA4jcmffr0doESJ0BEEQBMEVNXVV7FJ5VSA9dIyKCB1BEARBcCWiLo+OpK6MSrOEzpIlS0hJSSEkJISRI0eyZcuWevcdN24cJpPprJ/LL78cgKqqKv785z/Tv39/wsPDSUpKYvr06WRkZNQ6TkpKylnHePbZZ5uzfEEQBEGon4bMyBLRMRxuC52VK1cyb948FixYwLZt2xg4cCATJ04kO7uO5krAqlWrOHnypONn165dWCwWrr/+egBKS0vZtm0bjz76KNu2bWPVqlXs27ePK6+88qxjPfnkk7WOde+997q7fEEQBEFomDM9OjYbFJxQtqVZoOFwewTEokWLmD17NrNmzQLglVde4YsvvmDZsmU89NBDZ+0fFxdX6/cVK1YQFhbmEDrR0dGsXr261j7/+te/GDFiBGlpaXTq5HxRRUZGkpgo/QsEQRAEL+Lw6NQInZJTYK0AkxmiOmi3LqFZuBXRqaysJDU1lQkTJjgPYDYzYcIENm7c2KRjLF26lJtuuonw8PB69ykoKMBkMhETE1Pr+meffZY2bdowePBgnn/+eaqrq+s9RkVFBYWFhbV+BEEQBKFRzvToqKXlke3BEqjNmoRm41ZEJycnB6vVSkJCQq3rExIS2Lt3b6P337JlC7t27WLp0qX17lNeXs6f//xnpk6dSlRUlOP6++67jyFDhhAXF8eGDRuYP38+J0+eZNGiRXUeZ+HChTzxxBNNfGSCIAiCUIOrR8dmc2kWKP4cI+LT6eVLly6lf//+jBgxos7bq6qquOGGG7Db7bz88su1bps3b55je8CAAQQFBXHXXXexcOFCgoODzzrW/Pnza92nsLCQ5GR5kQqCIAiNEFbTMNBuhfJ8MSIbHLdSV/Hx8VgsFrKysmpdn5WV1ah3pqSkhBUrVnD77bfXebsqco4dO8bq1atrRXPqYuTIkVRXV3P06NE6bw8ODiYqKqrWjyAIgiA0SkCQMvMKlF46BTK13Mi4JXSCgoIYOnQoa9ascVxns9lYs2YNo0aNavC+77//PhUVFdxyyy1n3aaKnAMHDvDtt9/Spk2bRteyY8cOzGYz7dq1c+chCIIgCELjRLhUXkkPHUPjdupq3rx5zJgxg2HDhjFixAgWL15MSUmJowpr+vTpdOjQgYULF9a639KlS7n66qvPEjFVVVVcd911bNu2jc8//xyr1UpmZiagVGwFBQWxceNGNm/ezIUXXkhkZCQbN27kgQce4JZbbiE2Nra5j10QBEEQ6ia8LeTshxLXiI4IHSPittC58cYbOXXqFI899hiZmZkMGjSIr7/+2mFQTktLw3zGZNd9+/axfv16vvnmm7OOl56ezqeffgrAoEGDat32/fffM27cOIKDg1mxYgWPP/44FRUVdOnShQceeKCWB0cQBEEQPIZribnDjCypKyNistvtdq0X4QsKCwuJjo6moKBA/DqCIAhCw3zxIGx9DYbfAVv/o1z38EkICtN2Xa2Qln5+y6wrQRAEQTgT1aOTnqpchrcVkWNQROgIgiAIwpmE15SYZ+5SLsWIbFhE6AiCIAjCmajzrmxVyqUYkQ2LCB1BEARBOJOIM1qXSETHsIjQEQRBEIQzUVNXKtIs0LCI0BEEQRCEMwk/I6IjQsewiNARBEEQhDMJCoeAUOfvkroyLCJ0BEEQBOFMTCaIaOv8XczIhkWEjiAIgiDUhdodOTgaQqK1XYvQbEToCIIgCEJdqD4dieYYGhE6giAIglAXauWVGJENjQgdQRAEQaiLmM7KZZvu2q5DaBFuTy8XBEEQhFbBiDsUb06/a7VeidACROgIgiAIQl2ExsLIO7VehdBCJHUlCIIgCILfIkJHEARBEAS/RYSOIAiCIAh+iwgdQRAEQRD8FhE6giAIgiD4LSJ0BEEQBEHwW0ToCIIgCILgt4jQEQRBEATBbxGhIwiCIAiC3yJCRxAEQRAEv0WEjiAIgiAIfosIHUEQBEEQ/BYROoIgCIIg+C2tZnq53W4HoLCwUOOVCIIgCILQVNTPbfVz3F1ajdApKioCIDk5WeOVCIIgCILgLkVFRURHR7t9P5O9uRLJYNhsNjIyMoiMjMRkMnn02IWFhSQnJ3P8+HGioqI8emyhfuR51wZ53rVBnndtkOfd95z5nNvtdoqKikhKSsJsdt9x02oiOmazmY4dO3r1HFFRUfKPoAHyvGuDPO/aIM+7Nsjz7ntcn/PmRHJUxIwsCIIgCILfIkJHEARBEAS/RYSOBwgODmbBggUEBwdrvZRWhTzv2iDPuzbI864N8rz7Hk8/563GjCwIgiAIQutDIjqCIAiCIPgtInQEQRAEQfBbROgIgiAIguC3iNARBEEQBMFvEaHTQpYsWUJKSgohISGMHDmSLVu2aL0kv+bxxx/HZDLV+undu7fWy/I7fvjhByZPnkxSUhImk4mPP/641u12u53HHnuM9u3bExoayoQJEzhw4IA2i/UjGnveZ86cedbrf9KkSdos1o9YuHAhw4cPJzIyknbt2nH11Vezb9++WvuUl5czZ84c2rRpQ0REBFOmTCErK0ujFfsHTXnex40bd9Zr/u6773brPCJ0WsDKlSuZN28eCxYsYNu2bQwcOJCJEyeSnZ2t9dL8mr59+3Ly5EnHz/r167Vekt9RUlLCwIEDWbJkSZ23P/fcc7zwwgu88sorbN68mfDwcCZOnEh5ebmPV+pfNPa8A0yaNKnW6/+///2vD1fon6xbt445c+awadMmVq9eTVVVFZdccgklJSWOfR544AE+++wz3n//fdatW0dGRgbXXnuthqs2Pk153gFmz55d6zX/3HPPuXciu9BsRowYYZ8zZ47jd6vVak9KSrIvXLhQw1X5NwsWLLAPHDhQ62W0KgD7Rx995PjdZrPZExMT7c8//7zjuvz8fHtwcLD9v//9rwYr9E/OfN7tdrt9xowZ9quuukqT9bQmsrOz7YB93bp1drtdeX0HBgba33//fcc+e/bssQP2jRs3arVMv+PM591ut9svuOAC++9///sWHVciOs2ksrKS1NRUJkyY4LjObDYzYcIENm7cqOHK/J8DBw6QlJRE165dufnmm0lLS9N6Sa2KI0eOkJmZWeu1Hx0dzciRI+W17wPWrl1Lu3bt6NWrF/fccw+5ublaL8nvKCgoACAuLg6A1NRUqqqqar3me/fuTadOneQ170HOfN5V3n33XeLj4+nXrx/z58+ntLTUreO2mqGeniYnJwer1UpCQkKt6xMSEti7d69Gq/J/Ro4cyRtvvEGvXr04efIkTzzxBOeddx67du0iMjJS6+W1CjIzMwHqfO2rtwneYdKkSVx77bV06dKFQ4cO8fDDD3PppZeyceNGLBaL1svzC2w2G/fffz9jxoyhX79+gPKaDwoKIiYmpta+8pr3HHU97wDTpk2jc+fOJCUl8csvv/DnP/+Zffv2sWrVqiYfW4SOYCguvfRSx/aAAQMYOXIknTt35r333uP222/XcGWC4H1uuukmx3b//v0ZMGAA3bp1Y+3atYwfP17DlfkPc+bMYdeuXeL98zH1Pe933nmnY7t///60b9+e8ePHc+jQIbp169akY0vqqpnEx8djsVjOct1nZWWRmJio0apaHzExMfTs2ZODBw9qvZRWg/r6lte+9nTt2pX4+Hh5/XuIuXPn8vnnn/P999/TsWNHx/WJiYlUVlaSn59fa395zXuG+p73uhg5ciSAW695ETrNJCgoiKFDh7JmzRrHdTabjTVr1jBq1CgNV9a6KC4u5tChQ7Rv317rpbQaunTpQmJiYq3XfmFhIZs3b5bXvo85ceIEubm58vpvIXa7nblz5/LRRx/x3Xff0aVLl1q3Dx06lMDAwFqv+X379pGWliav+RbQ2PNeFzt27ABw6zUvqasWMG/ePGbMmMGwYcMYMWIEixcvpqSkhP9v345VGomiMI6fRZzBgA5OEJMIMwhJmzKYZhohASGQkGJIFUTSJAgmqF2QgG/gA9hN7xOkTRnSBRwCKYytILE8W+wiLLvoLlsMXv4/mG7gfJzqu3Dv6elp0tGMdXl5KbVaTXzfl6enJ7m5uZGNjQ1ptVpJRzPK6+vrLyemxWIh0+lUXNcVz/Pk4uJCbm9vpVAoyOHhoQyHQ8nlclKv15MLbYCP9u66roxGI2k2m5LJZCSOY7m+vpZ8Pi/VajXB1F9fr9eTKIrk4eFBtre33+/dOI4jW1tb4jiOnJ2dyWAwENd1ZWdnR87Pz6VcLsvR0VHC6b+uz/Yex7FEUSQnJyeSTqdlNptJv9+XIAikWCz+/aD/erMFvbu7U8/z1LIsLZVKOplMko5ktDAMNZvNqmVZenBwoGEY6uPjY9KxjDMej1VEfvva7baq/nhiPhwOdX9/X23b1uPjY53P58mGNsBHe1+v11qpVHRvb083NzfV933tdDr6/PycdOwv7087FxG9v79//+ft7U273a7u7u5qKpXSRqOhq9UqudAG+Gzvy+VSgyBQ13XVtm3N5/N6dXWlLy8v/zTn289hAAAAxuGODgAAMBZFBwAAGIuiAwAAjEXRAQAAxqLoAAAAY1F0AACAsSg6AADAWBQdAABgLIoOAAAwFkUHAAAYi6IDAACMRdEBAADG+g6Pf8jO/wS1/AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# accuracies\n", + "plt.plot(r.history['accuracy'], label='train acc')\n", + "plt.plot(r.history['val_accuracy'], label='val acc')\n", + "plt.legend()\n", + "plt.show()\n", + "plt.savefig('AccVal_acc')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "model_resnet.save('resnet_new_model_2.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "72/72 [==============================] - 61s 843ms/step - loss: 0.7182 - accuracy: 0.8411\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.7181549072265625, 0.8411458134651184]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_resnet.evaluate(test_ds_r)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}