diff --git a/sw_lab9-10_1.ipynb b/sw_lab9-10_1.ipynb index 5d3a4bb..5632c1c 100644 --- a/sw_lab9-10_1.ipynb +++ b/sw_lab9-10_1.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "source": [ "### Aleksandra Jonas, Aleksandra Gronowska, Iwona Christop\n", - "# Zadanie 9-10 - VGG16 + ResNet on train_test_sw " + "# Zadanie 9-10, zadanie 1 - VGG16 + ResNet on train_test_sw " ] }, { @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 61, "id": "2fe63b50", "metadata": {}, "outputs": [], @@ -156,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ @@ -190,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -204,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ @@ -220,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 65, "id": "cc941c5a", "metadata": {}, "outputs": [], @@ -237,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 66, "id": "25040ac9", "metadata": {}, "outputs": [], @@ -248,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 67, "id": "a1fe47e6", "metadata": {}, "outputs": [], @@ -262,14 +262,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 68, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Training data size: 820\n", + "Training data size: 821\n", "Test data size: 259\n", "Validation data size: 206\n" ] @@ -289,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ @@ -298,7 +298,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ @@ -335,18 +335,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 71, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jonas/Library/Python/3.9/lib/python/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" - ] - } - ], + "outputs": [], "source": [ "from keras.optimizers import Adam\n", "opt = Adam(lr=0.001)\n", @@ -355,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 72, "metadata": {}, "outputs": [ { @@ -404,13 +395,13 @@ " \n", " conv2d_25 (Conv2D) (None, 14, 14, 512) 2359808 \n", " \n", - " flatten_1 (Flatten) (None, 100352) 0 \n", + " flatten_2 (Flatten) (None, 100352) 0 \n", " \n", - " dense_3 (Dense) (None, 4096) 411045888 \n", + " dense_4 (Dense) (None, 4096) 411045888 \n", " \n", - " dense_4 (Dense) (None, 4096) 16781312 \n", + " dense_5 (Dense) (None, 4096) 16781312 \n", " \n", - " dense_5 (Dense) (None, 5) 20485 \n", + " dense_6 (Dense) (None, 5) 20485 \n", " \n", "=================================================================\n", "Total params: 442,562,373\n", @@ -426,31 +417,121 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 73, "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" + "WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n", + "Epoch 1/25\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/6b/j4d60ym516x2s6wymzj707rh0000gn/T/ipykernel_9339/4100383455.py:4: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", - " hist_vgg = model.fit_generator(steps_per_epoch=len(train_ds), generator=train_ds, validation_data= validation_ds, validation_steps=len(validation_ds), epochs=1, callbacks=[checkpoint,early])\n" + "/var/folders/3r/c8tg1h051m18qhsdccdysrt40000gn/T/ipykernel_2029/3158629982.py:4: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", + " hist_vgg = model.fit_generator(steps_per_epoch=len(train_ds), generator=train_ds, validation_data= validation_ds, validation_steps=len(validation_ds), epochs=25, callbacks=[checkpoint,early])\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "25/25 [==============================] - ETA: 0s - loss: 1.6126 - accuracy: 0.1663 \n", - "Epoch 1: val_accuracy improved from -inf to 0.18750, saving model to vgg16_1.h5\n", - "25/25 [==============================] - 515s 21s/step - loss: 1.6126 - accuracy: 0.1663 - val_loss: 1.6102 - val_accuracy: 0.1875\n" + "25/25 [==============================] - ETA: 0s - loss: 1.6264 - accuracy: 0.1900 \n", + "Epoch 1: val_accuracy improved from -inf to 0.18229, saving model to vgg16_1.h5\n", + "25/25 [==============================] - 854s 34s/step - loss: 1.6264 - accuracy: 0.1900 - val_loss: 1.6109 - val_accuracy: 0.1823\n", + "Epoch 2/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6108 - accuracy: 0.1950 \n", + "Epoch 2: val_accuracy improved from 0.18229 to 0.18750, saving model to vgg16_1.h5\n", + "25/25 [==============================] - 897s 36s/step - loss: 1.6108 - accuracy: 0.1950 - val_loss: 1.6098 - val_accuracy: 0.1875\n", + "Epoch 3/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6097 - accuracy: 0.2062 \n", + "Epoch 3: val_accuracy improved from 0.18750 to 0.19792, saving model to vgg16_1.h5\n", + "25/25 [==============================] - 870s 35s/step - loss: 1.6097 - accuracy: 0.2062 - val_loss: 1.6102 - val_accuracy: 0.1979\n", + "Epoch 4/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6097 - accuracy: 0.2037 \n", + "Epoch 4: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 692s 28s/step - loss: 1.6097 - accuracy: 0.2037 - val_loss: 1.6106 - val_accuracy: 0.1979\n", + "Epoch 5/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6095 - accuracy: 0.1963 \n", + "Epoch 5: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 634s 26s/step - loss: 1.6095 - accuracy: 0.1963 - val_loss: 1.6114 - val_accuracy: 0.1823\n", + "Epoch 6/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6094 - accuracy: 0.1925 \n", + "Epoch 6: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 643s 26s/step - loss: 1.6094 - accuracy: 0.1925 - val_loss: 1.6112 - val_accuracy: 0.1719\n", + "Epoch 7/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6095 - accuracy: 0.2025 \n", + "Epoch 7: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 697s 28s/step - loss: 1.6095 - accuracy: 0.2025 - val_loss: 1.6115 - val_accuracy: 0.1823\n", + "Epoch 8/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6097 - accuracy: 0.1762 \n", + "Epoch 8: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 667s 27s/step - loss: 1.6097 - accuracy: 0.1762 - val_loss: 1.6106 - val_accuracy: 0.1979\n", + "Epoch 9/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6096 - accuracy: 0.2025 \n", + "Epoch 9: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 656s 26s/step - loss: 1.6096 - accuracy: 0.2025 - val_loss: 1.6103 - val_accuracy: 0.1927\n", + "Epoch 10/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6095 - accuracy: 0.1950 \n", + "Epoch 10: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 651s 26s/step - loss: 1.6095 - accuracy: 0.1950 - val_loss: 1.6104 - val_accuracy: 0.1927\n", + "Epoch 11/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6094 - accuracy: 0.2062 \n", + "Epoch 11: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 646s 26s/step - loss: 1.6094 - accuracy: 0.2062 - val_loss: 1.6105 - val_accuracy: 0.1927\n", + "Epoch 12/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6095 - accuracy: 0.2062 \n", + "Epoch 12: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 648s 26s/step - loss: 1.6095 - accuracy: 0.2062 - val_loss: 1.6103 - val_accuracy: 0.1927\n", + "Epoch 13/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6096 - accuracy: 0.2025 \n", + "Epoch 13: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 636s 26s/step - loss: 1.6096 - accuracy: 0.2025 - val_loss: 1.6108 - val_accuracy: 0.1927\n", + "Epoch 14/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6097 - accuracy: 0.2050 \n", + "Epoch 14: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 664s 27s/step - loss: 1.6097 - accuracy: 0.2050 - val_loss: 1.6110 - val_accuracy: 0.1875\n", + "Epoch 15/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6096 - accuracy: 0.1775 \n", + "Epoch 15: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 657s 27s/step - loss: 1.6096 - accuracy: 0.1775 - val_loss: 1.6105 - val_accuracy: 0.1875\n", + "Epoch 16/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6095 - accuracy: 0.2000 \n", + "Epoch 16: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 664s 27s/step - loss: 1.6095 - accuracy: 0.2000 - val_loss: 1.6102 - val_accuracy: 0.1927\n", + "Epoch 17/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6094 - accuracy: 0.1937 \n", + "Epoch 17: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 676s 27s/step - loss: 1.6094 - accuracy: 0.1937 - val_loss: 1.6104 - val_accuracy: 0.1927\n", + "Epoch 18/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6093 - accuracy: 0.1975 \n", + "Epoch 18: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 673s 27s/step - loss: 1.6093 - accuracy: 0.1975 - val_loss: 1.6103 - val_accuracy: 0.1823\n", + "Epoch 19/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6094 - accuracy: 0.2050 \n", + "Epoch 19: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 681s 27s/step - loss: 1.6094 - accuracy: 0.2050 - val_loss: 1.6111 - val_accuracy: 0.1771\n", + "Epoch 20/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6093 - accuracy: 0.2050 \n", + "Epoch 20: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 672s 27s/step - loss: 1.6093 - accuracy: 0.2050 - val_loss: 1.6108 - val_accuracy: 0.1927\n", + "Epoch 21/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6094 - accuracy: 0.2050 \n", + "Epoch 21: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 663s 27s/step - loss: 1.6094 - accuracy: 0.2050 - val_loss: 1.6110 - val_accuracy: 0.1927\n", + "Epoch 22/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6096 - accuracy: 0.1850 \n", + "Epoch 22: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 675s 27s/step - loss: 1.6096 - accuracy: 0.1850 - val_loss: 1.6111 - val_accuracy: 0.1927\n", + "Epoch 23/25\n", + "25/25 [==============================] - ETA: 0s - loss: 1.6092 - accuracy: 0.1963 \n", + "Epoch 23: val_accuracy did not improve from 0.19792\n", + "25/25 [==============================] - 664s 27s/step - loss: 1.6092 - accuracy: 0.1963 - val_loss: 1.6110 - val_accuracy: 0.1823\n", + "Epoch 23: early stopping\n" ] } ], @@ -458,17 +539,17 @@ "from keras.callbacks import ModelCheckpoint, EarlyStopping\n", "checkpoint = ModelCheckpoint(\"vgg16_1.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", - "hist_vgg = model.fit_generator(steps_per_epoch=len(train_ds), generator=train_ds, validation_data= validation_ds, validation_steps=len(validation_ds), epochs=1, callbacks=[checkpoint,early])" + "hist_vgg = model.fit_generator(steps_per_epoch=len(train_ds), generator=train_ds, validation_data= validation_ds, validation_steps=len(validation_ds), epochs=25, callbacks=[checkpoint,early])" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 74, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -492,23 +573,23 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 75, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "8/8 [==============================] - 32s 4s/step - loss: 1.6094 - accuracy: 0.1992\n" + "8/8 [==============================] - 35s 4s/step - loss: 1.6097 - accuracy: 0.1953\n" ] }, { "data": { "text/plain": [ - "[1.609419822692871, 0.19921875]" + "[1.6096564531326294, 0.1953125]" ] }, - "execution_count": 31, + "execution_count": 75, "metadata": {}, "output_type": "execute_result" } @@ -527,28 +608,21 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 76, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n", - "94765736/94765736 [==============================] - 5s 0us/step\n" - ] - } - ], + "outputs": [], "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", + "import ssl\n", + "ssl._create_default_https_context = ssl._create_unverified_context\n", + "from keras.applications import ResNet50\n", "\n", "# re-size all the images to this\n", "IMAGE_SIZE = [224, 224]\n", @@ -572,21 +646,21 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Model: \"model\"\n", + "Model: \"model_1\"\n", "__________________________________________________________________________________________________\n", " Layer (type) Output Shape Param # Connected to \n", "==================================================================================================\n", - " input_1 (InputLayer) [(None, 224, 224, 3 0 [] \n", + " input_3 (InputLayer) [(None, 224, 224, 3 0 [] \n", " )] \n", " \n", - " conv1_pad (ZeroPadding2D) (None, 230, 230, 3) 0 ['input_1[0][0]'] \n", + " conv1_pad (ZeroPadding2D) (None, 230, 230, 3) 0 ['input_3[0][0]'] \n", " \n", " conv1_conv (Conv2D) (None, 112, 112, 64 9472 ['conv1_pad[0][0]'] \n", " ) \n", @@ -1051,9 +1125,9 @@ " \n", " conv5_block3_out (Activation) (None, 7, 7, 2048) 0 ['conv5_block3_add[0][0]'] \n", " \n", - " flatten_2 (Flatten) (None, 100352) 0 ['conv5_block3_out[0][0]'] \n", + " flatten_3 (Flatten) (None, 100352) 0 ['conv5_block3_out[0][0]'] \n", " \n", - " dense_6 (Dense) (None, 5) 501765 ['flatten_2[0][0]'] \n", + " dense_7 (Dense) (None, 5) 501765 ['flatten_3[0][0]'] \n", " \n", "==================================================================================================\n", "Total params: 24,089,477\n", @@ -1073,14 +1147,21 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 78, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/25\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/6b/j4d60ym516x2s6wymzj707rh0000gn/T/ipykernel_9339/2291254579.py:10: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", + "/var/folders/3r/c8tg1h051m18qhsdccdysrt40000gn/T/ipykernel_2029/3602206220.py:10: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", " r = model.fit_generator(\n" ] }, @@ -1088,7 +1169,55 @@ "name": "stdout", "output_type": "stream", "text": [ - "25/25 [==============================] - 54s 2s/step - loss: 7.2784 - accuracy: 0.2350 - val_loss: 2.7387 - val_accuracy: 0.2240\n" + "25/25 [==============================] - 38s 1s/step - loss: 6.4809 - accuracy: 0.1950 - val_loss: 2.9878 - val_accuracy: 0.2344\n", + "Epoch 2/25\n", + "25/25 [==============================] - 35s 1s/step - loss: 2.2159 - accuracy: 0.2338 - val_loss: 2.3206 - val_accuracy: 0.2396\n", + "Epoch 3/25\n", + "25/25 [==============================] - 35s 1s/step - loss: 1.9435 - accuracy: 0.2237 - val_loss: 1.8788 - val_accuracy: 0.2292\n", + "Epoch 4/25\n", + "25/25 [==============================] - 35s 1s/step - loss: 2.1113 - accuracy: 0.2350 - val_loss: 1.5820 - val_accuracy: 0.2604\n", + "Epoch 5/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.7911 - accuracy: 0.2975 - val_loss: 1.6257 - val_accuracy: 0.3229\n", + "Epoch 6/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.8471 - accuracy: 0.2975 - val_loss: 1.6844 - val_accuracy: 0.3542\n", + "Epoch 7/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.7567 - accuracy: 0.3075 - val_loss: 1.4758 - val_accuracy: 0.3281\n", + "Epoch 8/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.6541 - accuracy: 0.3550 - val_loss: 1.6412 - val_accuracy: 0.2708\n", + "Epoch 9/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4498 - accuracy: 0.3762 - val_loss: 1.3539 - val_accuracy: 0.3958\n", + "Epoch 10/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.5093 - accuracy: 0.3525 - val_loss: 1.4342 - val_accuracy: 0.3385\n", + "Epoch 11/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4125 - accuracy: 0.4062 - val_loss: 1.6245 - val_accuracy: 0.3438\n", + "Epoch 12/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.5308 - accuracy: 0.3650 - val_loss: 1.6150 - val_accuracy: 0.2292\n", + "Epoch 13/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4149 - accuracy: 0.4263 - val_loss: 1.5404 - val_accuracy: 0.3906\n", + "Epoch 14/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4894 - accuracy: 0.3925 - val_loss: 1.8275 - val_accuracy: 0.2292\n", + "Epoch 15/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.5978 - accuracy: 0.3775 - val_loss: 1.3376 - val_accuracy: 0.4375\n", + "Epoch 16/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4227 - accuracy: 0.4175 - val_loss: 1.5674 - val_accuracy: 0.3958\n", + "Epoch 17/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4758 - accuracy: 0.3837 - val_loss: 1.5279 - val_accuracy: 0.3698\n", + "Epoch 18/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.6931 - accuracy: 0.4137 - val_loss: 1.8716 - val_accuracy: 0.2865\n", + "Epoch 19/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.3378 - accuracy: 0.4500 - val_loss: 1.4395 - val_accuracy: 0.4271\n", + "Epoch 20/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.3173 - accuracy: 0.4825 - val_loss: 1.2535 - val_accuracy: 0.4583\n", + "Epoch 21/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.2702 - accuracy: 0.4900 - val_loss: 1.4282 - val_accuracy: 0.4896\n", + "Epoch 22/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.2848 - accuracy: 0.4600 - val_loss: 1.3511 - val_accuracy: 0.4115\n", + "Epoch 23/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.4002 - accuracy: 0.4487 - val_loss: 1.5821 - val_accuracy: 0.3281\n", + "Epoch 24/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.2507 - accuracy: 0.4800 - val_loss: 1.2901 - val_accuracy: 0.4635\n", + "Epoch 25/25\n", + "25/25 [==============================] - 36s 1s/step - loss: 1.3626 - accuracy: 0.4462 - val_loss: 1.5347 - val_accuracy: 0.3906\n" ] } ], @@ -1105,7 +1234,7 @@ "r = model.fit_generator(\n", " train_ds,\n", " validation_data=validation_ds,\n", - " epochs=1,\n", + " epochs=25,\n", " steps_per_epoch=len(train_ds),\n", " validation_steps=len(validation_ds)\n", ")" @@ -1113,12 +1242,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 79, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGwklEQVR4nO3deXxN597///dOsDMnQkjSpqaaqjHUVHVaVE5JUdTUFDEEHdCietRNi/YUPTpoq3W3vUmOc4qipe1pNUVNNQ8nSg1FU/OsEjEkJNfvDz/7a0uQkGSt8Ho+HuvBvta11vqsJey3a11rb4cxxggAAMCGPKwuAAAA4FoIKgAAwLYIKgAAwLYIKgAAwLYIKgAAwLYIKgAAwLYIKgAAwLYIKgAAwLYIKgAAwLYIKgBy5HA4NHr06Dxv98cff8jhcCghISHfawJw5yGoADaWkJAgh8Mhh8Ohn3/+Odt6Y4wiIiLkcDjUunVrCyoEgIJFUAGKAC8vL02fPj1b+9KlS7V//345nU4LqgKAgkdQAYqAxx9/XLNnz9bFixfd2qdPn666desqNDTUosruHGfOnLG6BOCORFABioCYmBidOHFCCxYscLVlZGRozpw5evrpp3Pc5syZM3rppZcUEREhp9OpqlWr6u2339bVX5ienp6uwYMHKyQkRP7+/nriiSe0f//+HPd54MAB9e7dW2XLlpXT6VSNGjU0derUmzqnkydPaujQoYqMjJSfn58CAgIUHR2tTZs2Zet7/vx5jR49WlWqVJGXl5fCwsL05JNPavfu3a4+WVlZev/99xUZGSkvLy+FhISoZcuWWr9+vaTrz525ej7O6NGj5XA4tHXrVj399NMqWbKk/vKXv0iSfvnlF/Xs2VMVK1aUl5eXQkND1bt3b504cSLH6xUXF6fw8HA5nU5VqFBBzz33nDIyMvT777/L4XDovffey7bdypUr5XA4NGPGjLxeVuC2U8zqAgDcWPny5dWoUSPNmDFD0dHRkqT58+crJSVFTz31lD744AO3/sYYPfHEE1q8eLHi4uJUu3ZtJSYm6uWXX9aBAwfc3hz79Omjf//733r66af10EMP6aefflKrVq2y1XDkyBE9+OCDcjgcGjBggEJCQjR//nzFxcUpNTVVgwYNytM5/f7775o3b546deqkChUq6MiRI/rkk0/UpEkTbd26VeHh4ZKkzMxMtW7dWosWLdJTTz2lF198UadPn9aCBQu0ZcsWVapUSZIUFxenhIQERUdHq0+fPrp48aKWL1+u1atXq169enmq7bJOnTqpcuXKGjt2rCvgLViwQL///rt69eql0NBQ/frrr/r000/166+/avXq1XI4HJKkgwcPqkGDBjp16pT69eunatWq6cCBA5ozZ47Onj2rihUrqnHjxvr88881ePBgt+N+/vnn8vf3V9u2bW+qbuC2YgDYVnx8vJFk1q1bZyZNmmT8/f3N2bNnjTHGdOrUyTRr1swYY0y5cuVMq1atXNvNmzfPSDJ///vf3fbXsWNH43A4zK5du4wxxiQlJRlJ5vnnn3fr9/TTTxtJZtSoUa62uLg4ExYWZo4fP+7W96mnnjKBgYGuupKTk40kEx8ff91zO3/+vMnMzHRrS05ONk6n07z++uuutqlTpxpJ5t133822j6ysLGOMMT/99JORZF544YVr9rleXVef66hRo4wkExMTk63v5fO80owZM4wks2zZMldbbGys8fDwMOvWrbtmTZ988omRZLZt2+Zal5GRYUqXLm169OiRbTvgTsStH6CI6Ny5s86dO6f//Oc/On36tP7zn/9c87bP999/L09PT73wwgtu7S+99JKMMZo/f76rn6Rs/a4eHTHG6Msvv1SbNm1kjNHx48ddS4sWLZSSkqKNGzfm6XycTqc8PC79E5SZmakTJ07Iz89PVatWddvXl19+qdKlS2vgwIHZ9nF59OLLL7+Uw+HQqFGjrtnnZjz77LPZ2ry9vV2/P3/+vI4fP64HH3xQklx1Z2Vlad68eWrTpk2OozmXa+rcubO8vLz0+eefu9YlJibq+PHj6tat203XDdxOCCpAERESEqKoqChNnz5dX331lTIzM9WxY8cc++7Zs0fh4eHy9/d3a69evbpr/eVfPTw8XLdPLqtatarb62PHjunUqVP69NNPFRIS4rb06tVLknT06NE8nU9WVpbee+89Va5cWU6nU6VLl1ZISIh++eUXpaSkuPrt3r1bVatWVbFi175TvXv3boWHhys4ODhPNdxIhQoVsrWdPHlSL774osqWLStvb2+FhIS4+l2u+9ixY0pNTdX9999/3f0HBQWpTZs2bk90ff7557rrrrv06KOP5uOZAEUXc1SAIuTpp59W3759dfjwYUVHRysoKKhQjpuVlSVJ6tatm3r06JFjn5o1a+Zpn2PHjtWrr76q3r1764033lBwcLA8PDw0aNAg1/Hy07VGVjIzM6+5zZWjJ5d17txZK1eu1Msvv6zatWvLz89PWVlZatmy5U3VHRsbq9mzZ2vlypWKjIzUN998o+eff9412gTc6QgqQBHSvn17PfPMM1q9erW++OKLa/YrV66cFi5cqNOnT7uNqmzfvt21/vKvWVlZrlGLy3bs2OG2v8tPBGVmZioqKipfzmXOnDlq1qyZpkyZ4tZ+6tQplS5d2vW6UqVKWrNmjS5cuKDixYvnuK9KlSopMTFRJ0+evOaoSsmSJV37v9Ll0aXc+PPPP7Vo0SKNGTNGr732mqt9586dbv1CQkIUEBCgLVu23HCfLVu2VEhIiD7//HM1bNhQZ8+eVffu3XNdE3C7I7IDRYifn58mT56s0aNHq02bNtfs9/jjjyszM1OTJk1ya3/vvffkcDhcTw5d/vXqp4YmTpzo9trT01MdOnTQl19+meOb77Fjx/J8Lp6entkelZ49e7YOHDjg1tahQwcdP34827lIcm3foUMHGWM0ZsyYa/YJCAhQ6dKltWzZMrf1H3/8cZ5qvnKfl119vTw8PNSuXTt9++23rsejc6pJkooVK6aYmBjNmjVLCQkJioyMzPPoFHA7Y0QFKGKudevlSm3atFGzZs00YsQI/fHHH6pVq5Z+/PFHff311xo0aJBrTkrt2rUVExOjjz/+WCkpKXrooYe0aNEi7dq1K9s+x48fr8WLF6thw4bq27ev7rvvPp08eVIbN27UwoULdfLkyTydR+vWrfX666+rV69eeuihh7R582Z9/vnnqlixolu/2NhYTZs2TUOGDNHatWv18MMP68yZM1q4cKGef/55tW3bVs2aNVP37t31wQcfaOfOna7bMMuXL1ezZs00YMAASZcexR4/frz69OmjevXqadmyZfrtt99yXXNAQIAeeeQR/eMf/9CFCxd011136ccff1RycnK2vmPHjtWPP/6oJk2aqF+/fqpevboOHTqk2bNn6+eff3a7bRcbG6sPPvhAixcv1ltvvZWn6wjc9ix73gjADV35ePL1XP14sjHGnD592gwePNiEh4eb4sWLm8qVK5sJEya4Ho297Ny5c+aFF14wpUqVMr6+vqZNmzZm37592R7ZNcaYI0eOmP79+5uIiAhTvHhxExoaapo3b24+/fRTV5+8PJ780ksvmbCwMOPt7W0aN25sVq1aZZo0aWKaNGni1vfs2bNmxIgRpkKFCq7jduzY0ezevdvV5+LFi2bChAmmWrVqpkSJEiYkJMRER0ebDRs2uO0nLi7OBAYGGn9/f9O5c2dz9OjRaz6efOzYsWx179+/37Rv394EBQWZwMBA06lTJ3Pw4MEcr9eePXtMbGysCQkJMU6n01SsWNH079/fpKenZ9tvjRo1jIeHh9m/f/91rxtwp3EYc9UYJgCg0NWpU0fBwcFatGiR1aUAtsIcFQCw2Pr165WUlKTY2FirSwFshxEVALDIli1btGHDBr3zzjs6fvy4fv/9d3l5eVldFmArjKgAgEXmzJmjXr166cKFC5oxYwYhBcgBIyoAAMC2GFEBAAC2RVABAAC2VaQ/8C0rK0sHDx6Uv7//LX1DKgAAKDzGGJ0+fVrh4eE3/F6rIh1UDh48qIiICKvLAAAAN2Hfvn26++67r9unSAeVy1+2tm/fPgUEBFhcDQAAyI3U1FRFRES4fWnqtRTpoHL5dk9AQABBBQCAIiY30zaYTAsAAGyLoAIAAGyLoAIAAGyrSM9RAYCiLDMzUxcuXLC6DCDfFS9eXJ6envmyL4IKABQyY4wOHz6sU6dOWV0KUGCCgoIUGhp6y59zRlABgEJ2OaSUKVNGPj4+fGAlbivGGJ09e1ZHjx6VJIWFhd3S/ggqAFCIMjMzXSGlVKlSVpcDFAhvb29J0tGjR1WmTJlbug3EZFoAKESX56T4+PhYXAlQsC7/jN/qPCyCCgBYgNs9uN3l1884QQUAANgWQQUAANgWQQUAkCerVq2Sp6enWrVqZXUpuAMQVAAAeTJlyhQNHDhQy5Yt08GDBy2rIyMjw7Jjo/AQVAAAuZaWlqYvvvhCzz33nFq1aqWEhAS39d9++63q168vLy8vlS5dWu3bt3etS09P17BhwxQRESGn06l7771XU6ZMkSQlJCQoKCjIbV/z5s1zm5A5evRo1a5dW//3f/+nChUqyMvLS5L0ww8/6C9/+YuCgoJUqlQptW7dWrt373bb1/79+xUTE6Pg4GD5+vqqXr16WrNmjf744w95eHho/fr1bv0nTpyocuXKKSsr61YvGW4Rn6MCABYzxujchUxLju1d3DNPT2fMmjVL1apVU9WqVdWtWzcNGjRIw4cPl8Ph0Hfffaf27dtrxIgRmjZtmjIyMvT999+7to2NjdWqVav0wQcfqFatWkpOTtbx48fzVO+uXbv05Zdf6quvvnJ9NseZM2c0ZMgQ1axZU2lpaXrttdfUvn17JSUlycPDQ2lpaWrSpInuuusuffPNNwoNDdXGjRuVlZWl8uXLKyoqSvHx8apXr57rOPHx8erZs6c8PPj/vNUIKgBgsXMXMnXfa4mWHHvr6y3kUyL3bwVTpkxRt27dJEktW7ZUSkqKli5dqqZNm+rNN9/UU089pTFjxrj616pVS5L022+/adasWVqwYIGioqIkSRUrVsxzvRkZGZo2bZpCQkJcbR06dHDrM3XqVIWEhGjr1q26//77NX36dB07dkzr1q1TcHCwJOnee+919e/Tp4+effZZvfvuu3I6ndq4caM2b96sr7/+Os/1If8RFQEAubJjxw6tXbtWMTExkqRixYqpS5curts3SUlJat68eY7bJiUlydPTU02aNLmlGsqVK+cWUiRp586diomJUcWKFRUQEKDy5ctLkvbu3es6dp06dVwh5Wrt2rWTp6en5s6dK+nSbahmzZq59gNrMaICABbzLu6pra+3sOzYuTVlyhRdvHhR4eHhrjZjjJxOpyZNmuT62PQcj3OddZLk4eEhY4xbW06faOrr65utrU2bNipXrpw+++wzhYeHKysrS/fff79rsu2Njl2iRAnFxsYqPj5eTz75pKZPn67333//utug8BBUAMBiDocjT7dfrHDx4kVNmzZN77zzjh577DG3de3atdOMGTNUs2ZNLVq0SL169cq2fWRkpLKysrR06VLXrZ8rhYSE6PTp0zpz5owrjCQlJd2wrhMnTmjHjh367LPP9PDDD0uSfv75Z7c+NWvW1P/93//p5MmT1xxV6dOnj+6//359/PHHunjxop588skbHhuFw95/MwAAtvCf//xHf/75p+Li4hQYGOi2rkOHDpoyZYomTJig5s2bq1KlSnrqqad08eJFff/99xo2bJjKly+vHj16qHfv3q7JtHv27NHRo0fVuXNnNWzYUD4+Pvqf//kfvfDCC1qzZk22J4pyUrJkSZUqVUqffvqpwsLCtHfvXr3yyitufWJiYjR27Fi1a9dO48aNU1hYmP773/8qPDxcjRo1kiRVr15dDz74oIYNG6bevXvfcBQGhYc5KgCAG5oyZYqioqKyhRTpUlBZv369goODNXv2bH3zzTeqXbu2Hn30Ua1du9bVb/LkyerYsaOef/55VatWTX379tWZM2ckScHBwfr3v/+t77//XpGRkZoxY4ZGjx59w7o8PDw0c+ZMbdiwQffff78GDx6sCRMmuPUpUaKEfvzxR5UpU0aPP/64IiMjNX78+Gzf6BsXF6eMjAz17t37Jq4QCorDXH1TsAhJTU1VYGCgUlJSFBAQYHU5AHBD58+fV3JystvngMAe3njjDc2ePVu//PKL1aXcFq73s56X929GVAAAd7S0tDRt2bJFkyZN0sCBA60uB1exNKiUL19eDocj29K/f38rywIA3EEGDBigunXrqmnTptz2sSFLJ9OuW7dOmZn/79MYt2zZor/+9a/q1KmThVUBAO4kCQkJuZq4C2tYGlSu/tCe8ePHq1KlSrf8gUAAAOD2YJvHkzMyMvTvf/9bQ4YMueb3TqSnpys9Pd31OjU1tbDKAwAAFrDNZNp58+bp1KlT6tmz5zX7jBs3ToGBga4lIiKi8AoEAACFzjZBZcqUKYqOjnb7aOarDR8+XCkpKa5l3759hVghAAAobLa49bNnzx4tXLhQX3311XX7OZ1OOZ3OQqoKAABYzRYjKvHx8SpTpoxatWpldSkAAMBGLA8qWVlZio+PV48ePVSsmC0GeAAABaRp06YaNGiQ63X58uU1ceLE627jcDg0b968Wz52fu0HhcvyoLJw4ULt3buXD9kBABtr06aNWrZsmeO65cuXy+Fw3NRHz69bt079+vW71fLcjB49WrVr187WfujQIUVHR+frsa7l3LlzCg4OVunSpd2eVkXeWR5UHnvsMRljVKVKFatLAQBcQ1xcnBYsWKD9+/dnWxcfH6969eqpZs2aed5vSEiIfHx88qPEGwoNDS20eY5ffvmlatSooWrVqlk+imOM0cWLFy2t4VZYHlQAAPbXunVrhYSEZPsE17S0NM2ePVtxcXE6ceKEYmJidNddd8nHx8f1LcjXc/Wtn507d+qRRx6Rl5eX7rvvPi1YsCDbNsOGDVOVKlXk4+OjihUr6tVXX9WFCxckXfqU2TFjxmjTpk2ur2W5XPPVt342b96sRx99VN7e3ipVqpT69euntLQ01/qePXuqXbt2evvttxUWFqZSpUqpf//+rmNdz5QpU9StWzd169ZNU6ZMybb+119/VevWrRUQECB/f389/PDD2r17t2v91KlTVaNGDTmdToWFhWnAgAGSpD/++EMOh0NJSUmuvqdOnZLD4dCSJUskSUuWLJHD4dD8+fNVt25dOZ1O/fzzz9q9e7fatm2rsmXLys/PT/Xr19fChQvd6kpPT9ewYcMUEREhp9Ope++9V1OmTJExRvfee6/efvttt/5JSUlyOBzatWvXDa/JzWJSCABYzRjpwllrjl3cR7rGh2xeqVixYoqNjVVCQoJGjBjh+mDO2bNnKzMzUzExMUpLS1PdunU1bNgwBQQE6LvvvlP37t1VqVIlNWjQ4IbHyMrK0pNPPqmyZctqzZo1SklJcZvPcpm/v78SEhIUHh6uzZs3q2/fvvL399ff/vY3denSRVu2bNEPP/zgehMODAzMto8zZ86oRYsWatSokdatW6ejR4+qT58+GjBggFsYW7x4scLCwrR48WLt2rVLXbp0Ue3atdW3b99rnsfu3bu1atUqffXVVzLGaPDgwdqzZ4/KlSsnSTpw4IAeeeQRNW3aVD/99JMCAgK0YsUK16jH5MmTNWTIEI0fP17R0dFKSUnRihUrbnj9rvbKK6/o7bffVsWKFVWyZEnt27dPjz/+uN588005nU5NmzZNbdq00Y4dO3TPPfdIkmJjY7Vq1Sp98MEHqlWrlpKTk3X8+HE5HA717t1b8fHxGjp0qOsY8fHxeuSRR3Tvvffmub7cIqgAgNUunJXGXvszpArU/xyUSvjmqmvv3r01YcIELV26VE2bNpV06Y2qQ4cOrg/ivPJNbODAgUpMTNSsWbNyFVQWLlyo7du3KzEx0fWZWmPHjs02r2TkyJGu35cvX15Dhw7VzJkz9be//U3e3t7y8/NTsWLFFBoaes1jTZ8+XefPn9e0adPk63vp/CdNmqQ2bdrorbfeUtmyZSVJJUuW1KRJk+Tp6alq1aqpVatWWrRo0XWDytSpUxUdHa2SJUtKklq0aKH4+HiNHj1akvTRRx8pMDBQM2fOVPHixSXJbfrD3//+d7300kt68cUXXW3169e/4fW72uuvv66//vWvrtfBwcGqVauW6/Ubb7yhuXPn6ptvvtGAAQP022+/adasWVqwYIGioqIkSRUrVnT179mzp1577TWtXbtWDRo00IULFzR9+vRsoyz5jVs/AIBcqVatmh566CFNnTpVkrRr1y4tX75ccXFxkqTMzEy98cYbioyMVHBwsPz8/JSYmKi9e/fmav/btm1TRESE2wd/NmrUKFu/L774Qo0bN1ZoaKj8/Pw0cuTIXB/jymPVqlXLFVIkqXHjxsrKytKOHTtcbTVq1JCnp6frdVhYmI4ePXrN/WZmZuqf//ynunXr5mrr1q2bEhISlJWVJenS7ZKHH37YFVKudPToUR08eFDNmzfP0/nkpF69em6v09LSNHToUFWvXl1BQUHy8/PTtm3bXNcuKSlJnp6e1/y+vfDwcLVq1cr15//tt98qPT29wL9ImBEVALBacZ9LIxtWHTsP4uLiNHDgQH300UeKj493+yLZCRMm6P3339fEiRMVGRkpX19fDRo0SBkZGflW7qpVq9S1a1eNGTNGLVq0cI1MvPPOO/l2jCtdHSYcDocrcOQkMTFRBw4cUJcuXdzaMzMztWjRIv31r3+Vt7f3Nbe/3jpJ8vC4NL5gjHG1XWvOzJUhTJKGDh2qBQsW6O2339a9994rb29vdezY0fXnc6NjS1KfPn3UvXt3vffee4qPj1eXLl0KfDI0IyoAYDWH49LtFyuWXMxPuVLnzp3l4eGh6dOna9q0aerdu7drvsqKFSvUtm1bdevWTbVq1VLFihX122+/5Xrf1atX1759+3To0CFX2+rVq936rFy5UuXKldOIESNUr149Va5cWXv27HHrU6JECWVmZt7wWJs2bdKZM2dcbStWrJCHh4eqVq2a65qvNmXKFD311FNKSkpyW5566inXpNqaNWtq+fLlOQYMf39/lS9fXosWLcpx/yEhIZLkdo2unFh7PStWrFDPnj3Vvn17RUZGKjQ0VH/88YdrfWRkpLKysrR06dJr7uPxxx+Xr6+vJk+erB9++KFQPlqEoAIAyDU/Pz916dJFw4cP16FDh9y+SLZy5cpasGCBVq5cqW3btumZZ57RkSNHcr3vqKgoValSRT169NCmTZu0fPlyjRgxwq1P5cqVtXfvXs2cOVO7d+/WBx98oLlz57r1KV++vJKTk5WUlKTjx4/n+DkmXbt2lZeXl3r06KEtW7Zo8eLFGjhwoLp37+6an5JXx44d07fffqsePXro/vvvd1tiY2M1b948nTx5UgMGDFBqaqqeeuoprV+/Xjt37tS//vUv1y2n0aNH65133tEHH3ygnTt3auPGjfrwww8lXRr1ePDBBzV+/Hht27ZNS5cudZuzcz2VK1fWV199paSkJG3atElPP/202+hQ+fLl1aNHD/Xu3Vvz5s1TcnKylixZolmzZrn6eHp6qmfPnho+fLgqV66c4625/EZQAQDkSVxcnP7880+1aNHCbT7JyJEj9cADD6hFixZq2rSpQkND1a5du1zv18PDQ3PnztW5c+fUoEED9enTR2+++aZbnyeeeEKDBw/WgAEDVLt2ba1cuVKvvvqqW58OHTqoZcuWatasmUJCQnJ8RNrHx0eJiYk6efKk6tevr44dO6p58+aaNGlS3i7GFS5PzM1pfknz5s3l7e2tf//73ypVqpR++uknpaWlqUmTJqpbt64+++wz122mHj16aOLEifr4449Vo0YNtW7dWjt37nTta+rUqbp48aLq1q2rQYMG6e9//3uu6nv33XdVsmRJPfTQQ2rTpo1atGihBx54wK3P5MmT1bFjRz3//POqVq2a+vbt6zbqJF3688/IyFCvXr3yeoluisNceaOriElNTVVgYKBSUlIUEBBgdTkAcEPnz59XcnKyKlSoIC8vL6vLAfJs+fLlat68ufbt23fd0afr/azn5f2bybQAAOCG0tPTdezYMY0ePVqdOnW66VtkecWtHwAAcEMzZsxQuXLldOrUKf3jH/8otOMSVAAAwA317NlTmZmZ2rBhg+66665COy5BBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQCQKz179szTd/cA+YGgAgAAbIugAgC4ZUuXLlWDBg3kdDoVFhamV155RRcvXnStnzNnjiIjI+Xt7a1SpUopKirK9a28S5YsUYMGDeTr66ugoCA1btxYe/bssepUYDN8KSEAWMwYo3MXz1lybO9i3nI4HLe0jwMHDujxxx9Xz549NW3aNG3fvl19+/aVl5eXRo8erUOHDikmJkb/+Mc/1L59e50+fVrLly+XMUYXL15Uu3bt1LdvX82YMUMZGRlau3btLdeE2wdBBQAsdu7iOTWc3tCSY695eo18ivvc0j4+/vhjRUREaNKkSXI4HKpWrZoOHjyoYcOG6bXXXtOhQ4d08eJFPfnkkypXrpwkKTIyUpJ08uRJpaSkqHXr1qpUqZIkqXr16rd2UritcOsHAHBLtm3bpkaNGrmNgjRu3FhpaWnav3+/atWqpebNmysyMlKdOnXSZ599pj///FOSFBwcrJ49e6pFixZq06aN3n//fR06dMiqU4ENMaICABbzLuatNU+vsezYBc3T01MLFizQypUr9eOPP+rDDz/UiBEjtGbNGlWoUEHx8fF64YUX9MMPP+iLL77QyJEjtWDBAj344IMFXhvsj6ACABZzOBy3fPvFStWrV9eXX34pY4xrVGXFihXy9/fX3XffLenSOTZu3FiNGzfWa6+9pnLlymnu3LkaMmSIJKlOnTqqU6eOhg8frkaNGmn69OkEFUgiqAAA8iAlJUVJSUlubf369dPEiRM1cOBADRgwQDt27NCoUaM0ZMgQeXh4aM2aNVq0aJEee+wxlSlTRmvWrNGxY8dUvXp1JScn69NPP9UTTzyh8PBw7dixQzt37lRsbKw1JwjbIagAAHJtyZIlqlOnjltbXFycvv/+e7388suqVauWgoODFRcXp5EjR0qSAgICtGzZMk2cOFGpqakqV66c3nnnHUVHR+vIkSPavn27/vnPf+rEiRMKCwtT//799cwzz1hxerAhhzHGWF3EzUpNTVVgYKBSUlIUEBBgdTkAcEPnz59XcnKyKlSoIC8vL6vLAQrM9X7W8/L+zVM/AADAtggqAADAtggqAADAtggqAADAtggqAADAtggqAADAtggqAADAtiwPKgcOHFC3bt1UqlQpeXt7KzIyUuvXr7e6LAAAYAOWfjLtn3/+qcaNG6tZs2aaP3++QkJCtHPnTpUsWdLKsgAAgE1YOqLy1ltvKSIiQvHx8WrQoIEqVKigxx57TJUqVbKyLABAAWnatKkGDRrkel2+fHlNnDjxuts4HA7Nmzfvlo+dX/tB4bI0qHzzzTeqV6+eOnXqpDJlyqhOnTr67LPPrtk/PT1dqampbgsAoOC1adNGLVu2zHHd8uXL5XA49Msvv+R5v+vWrVO/fv1utTw3o0ePVu3atbO1Hzp0SNHR0fl6rKslJCQoKCioQI9xp7E0qPz++++aPHmyKleurMTERD333HN64YUX9M9//jPH/uPGjVNgYKBriYiIKOSKAeDOFBcXpwULFmj//v3Z1sXHx6tevXqqWbNmnvcbEhIiHx+f/CjxhkJDQ+V0OgvlWMg/lgaVrKwsPfDAAxo7dqzq1Kmjfv36qW/fvvrf//3fHPsPHz5cKSkprmXfvn2FXDEA3Jlat26tkJAQJSQkuLWnpaVp9uzZiouL04kTJxQTE6O77rpLPj4+ioyM1IwZM66736tv/ezcuVOPPPKIvLy8dN9992nBggXZthk2bJiqVKkiHx8fVaxYUa+++qouXLgg6dKIxpgxY7Rp0yY5HA45HA5XzVff+tm8ebMeffRReXt7q1SpUurXr5/S0tJc63v27Kl27drp7bffVlhYmEqVKqX+/fu7jnUz9u7dq7Zt28rPz08BAQHq3Lmzjhw54lq/adMmNWvWTP7+/goICFDdunVdD5js2bNHbdq0UcmSJeXr66saNWro+++/v+laigpLJ9OGhYXpvvvuc2urXr26vvzyyxz7O51O0jCA244xRubcOUuO7fD2lsPhuGG/YsWKKTY2VgkJCRoxYoRrm9mzZyszM1MxMTFKS0tT3bp1NWzYMAUEBOi7775T9+7dValSJTVo0OCGx8jKytKTTz6psmXLas2aNUpJSXGbz3KZv7+/EhISFB4ers2bN6tv377y9/fX3/72N3Xp0kVbtmzRDz/8oIULF0qSAgMDs+3jzJkzatGihRo1aqR169bp6NGj6tOnjwYMGOAWxhYvXqywsDAtXrxYu3btUpcuXVS7dm317dv3hueT0/ldDilLly7VxYsX1b9/f3Xp0kVLliyRJHXt2lV16tTR5MmT5enpqaSkJBUvXlyS1L9/f2VkZGjZsmXy9fXV1q1b5efnl+c6ihpLg0rjxo21Y8cOt7bffvtN5cqVs6giACh85tw57XigriXHrrpxgxy5vPXSu3dvTZgwQUuXLlXTpk0lXbrt06FDB9ct+aFDh7r6Dxw4UImJiZo1a1augsrChQu1fft2JSYmKjw8XJI0duzYbPNKRo4c6fp9+fLlNXToUM2cOVN/+9vf5O3tLT8/PxUrVkyhoaHXPNb06dN1/vx5TZs2Tb6+vpKkSZMmqU2bNnrrrbdUtmxZSVLJkiU1adIkeXp6qlq1amrVqpUWLVp0U0Fl0aJF2rx5s5KTk11TF6ZNm6YaNWpo3bp1ql+/vvbu3auXX35Z1apVkyRVrlzZtf3evXvVoUMHRUZGSpIqVqyY5xqKIktv/QwePFirV6/W2LFjtWvXLk2fPl2ffvqp+vfvb2VZAIAcVKtWTQ899JCmTp0qSdq1a5eWL1+uuLg4SVJmZqbeeOMNRUZGKjg4WH5+fkpMTNTevXtztf9t27YpIiLCFVIkqVGjRtn6ffHFF2rcuLFCQ0Pl5+enkSNH5voYVx6rVq1arpAiXfrPc1ZWltt/oGvUqCFPT0/X67CwMB09ejRPx7rymBEREW7zK++77z4FBQVp27ZtkqQhQ4aoT58+ioqK0vjx47V7925X3xdeeEF///vf1bhxY40aNeqmJi8XRZaOqNSvX19z587V8OHD9frrr6tChQqaOHGiunbtamVZAFCoHN7eqrpxg2XHzou4uDgNHDhQH330keLj41WpUiU1adJEkjRhwgS9//77mjhxoiIjI+Xr66tBgwYpIyMj3+pdtWqVunbtqjFjxqhFixYKDAzUzJkz9c477+TbMa50+bbLZQ6HQ1lZWQVyLOnSE0tPP/20vvvuO82fP1+jRo3SzJkz1b59e/Xp00ctWrTQd999px9//FHjxo3TO++8o4EDBxZYPXZgaVCRLk3Qat26tdVlAIBlHA5Hrm+/WK1z58568cUXNX36dE2bNk3PPfeca77KihUr1LZtW3Xr1k3SpTkZv/32W7a5iNdSvXp17du3T4cOHVJYWJgkafXq1W59Vq5cqXLlymnEiBGutj179rj1KVGihDIzM294rISEBJ05c8Y1qrJixQp5eHioatWquao3ry6f3759+1yjKlu3btWpU6fcrlGVKlVUpUoVDR48WDExMYqPj1f79u0lSREREXr22Wf17LPPavjw4frss89u+6Bi+UfoAwCKDj8/P3Xp0kXDhw/XoUOH1LNnT9e6ypUra8GCBVq5cqW2bdumZ555xu2JlhuJiopSlSpV1KNHD23atEnLly93CySXj7F3717NnDlTu3fv1gcffKC5c+e69SlfvrySk5OVlJSk48ePKz09PduxunbtKi8vL/Xo0UNbtmzR4sWLNXDgQHXv3t01P+VmZWZmKikpyW3Ztm2boqKiFBkZqa5du2rjxo1au3atYmNj1aRJE9WrV0/nzp3TgAEDtGTJEu3Zs0crVqzQunXrVL16dUnSoEGDlJiYqOTkZG3cuFGLFy92rbudEVQAAHkSFxenP//8Uy1atHCbTzJy5Eg98MADatGihZo2barQ0FC1a9cu1/v18PDQ3Llzde7cOTVo0EB9+vTRm2++6dbniSee0ODBgzVgwADVrl1bK1eu1KuvvurWp0OHDmrZsqWaNWumkJCQHB+R9vHxUWJiok6ePKn69eurY8eOat68uSZNmpS3i5GDtLQ01alTx21p06aNHA6Hvv76a5UsWVKPPPKIoqKiVLFiRX3xxReSJE9PT504cUKxsbGqUqWKOnfurOjoaI0ZM0bSpQDUv39/Va9eXS1btlSVKlX08ccf33K9ducwxhiri7hZqampCgwMVEpKigICAqwuBwBu6Pz580pOTlaFChXk5eVldTlAgbnez3pe3r8ZUQEAALZFUAEAALZFUAEAALZFUAEAALZFUAEACxTh5xiAXMmvn3GCCgAUosufdHr27FmLKwEK1uWf8as/3TevLP9kWgC4k3h6eiooKMj1fTE+Pj65+vZioKgwxujs2bM6evSogoKC3L4r6WYQVACgkF3+Vt+b/XI7oCgICgq67jdY5xZBBQAKmcPhUFhYmMqUKaMLFy5YXQ6Q74oXL37LIymXEVQAwCKenp759o85cLtiMi0AALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtggoAALAtS4PK6NGj5XA43JZq1apZWRIAALCRYlYXUKNGDS1cuND1ulgxy0sCAAA2YXkqKFasmEJDQ60uAwAA2JDlc1R27typ8PBwVaxYUV27dtXevXuv2Tc9PV2pqaluCwAAuH1ZGlQaNmyohIQE/fDDD5o8ebKSk5P18MMP6/Tp0zn2HzdunAIDA11LREREIVcMAAAKk8MYY6wu4rJTp06pXLlyevfddxUXF5dtfXp6utLT012vU1NTFRERoZSUFAUEBBRmqQAA4CalpqYqMDAwV+/fls9RuVJQUJCqVKmiXbt25bje6XTK6XQWclUAAMAqls9RuVJaWpp2796tsLAwq0sBAAA2YGlQGTp0qJYuXao//vhDK1euVPv27eXp6amYmBgrywIAADZh6a2f/fv3KyYmRidOnFBISIj+8pe/aPXq1QoJCbGyLAAAYBOWBpWZM2daeXgAAGBztpqjAgAAcCWCCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsC2CCgAAsK2bCioXL17UwoUL9cknn+j06dOSpIMHDyotLS1fiwMAAHe2PAeVPXv2KDIyUm3btlX//v117NgxSdJbb72loUOH3nQh48ePl8Ph0KBBg256HwAA4PaS56Dy4osvql69evrzzz/l7e3tam/fvr0WLVp0U0WsW7dOn3zyiWrWrHlT2wMAgNtTnoPK8uXLNXLkSJUoUcKtvXz58jpw4ECeC0hLS1PXrl312WefqWTJknneHgAA3L7yHFSysrKUmZmZrX3//v3y9/fPcwH9+/dXq1atFBUVdcO+6enpSk1NdVsAAMDtK89B5bHHHtPEiRNdrx0Oh9LS0jRq1Cg9/vjjedrXzJkztXHjRo0bNy5X/ceNG6fAwEDXEhERkafjAQCAosVhjDF52WD//v1q0aKFjDHauXOn6tWrp507d6p06dJatmyZypQpk6v97Nu3T/Xq1dOCBQtcc1OaNm2q2rVruwWhK6Wnpys9Pd31OjU1VREREUpJSVFAQEBeTgMAAFgkNTVVgYGBuXr/znNQkS49njxz5kz98ssvSktL0wMPPKCuXbu6Ta69kXnz5ql9+/by9PR0tWVmZsrhcMjDw0Pp6elu63KSlxMFAAD2UOBBJT+cPn1ae/bscWvr1auXqlWrpmHDhun++++/4T4IKgAAFD15ef8ultedT5s27brrY2Njc7Uff3//bGHE19dXpUqVylVIAQAAt788B5UXX3zR7fWFCxd09uxZlShRQj4+PrkOKgAAADeS56Dy559/ZmvbuXOnnnvuOb388su3VMySJUtuaXsAAHB7yZcvJaxcubLGjx+fbbQFAADgVuTbtycXK1ZMBw8ezK/dAQAA5P3WzzfffOP22hijQ4cOadKkSWrcuHG+FQYAAJDnoNKuXTu31w6HQyEhIXr00Uf1zjvv5FddAAAAeQ8qWVlZBVEHAABANvk2RwUAACC/5WpEZciQIbne4bvvvnvTxQAAAFwpV0Hlv//9b6525nA4bqkYAACAK+UqqCxevLig6wAAAMiGOSoAAMC28vzUjyStX79es2bN0t69e5WRkeG27quvvsqXwgAAAPI8ojJz5kw99NBD2rZtm+bOnasLFy7o119/1U8//aTAwMCCqBEAANyh8hxUxo4dq/fee0/ffvutSpQooffff1/bt29X586ddc899xREjQAA4A6V56Cye/dutWrVSpJUokQJnTlzRg6HQ4MHD9ann36a7wUCAIA7V56DSsmSJXX69GlJ0l133aUtW7ZIkk6dOqWzZ8/mb3UAAOCOluugcjmQPPLII1qwYIEkqVOnTnrxxRfVt29fxcTEqHnz5gVTJQAAuCPl+qmfmjVrqn79+mrXrp06deokSRoxYoSKFy+ulStXqkOHDho5cmSBFQoAAO48DmOMyU3H5cuXKz4+XnPmzFFWVpY6dOigPn366OGHHy7oGq8pNTVVgYGBSklJUUBAgGV1AACA3MvL+3eub/08/PDDmjp1qg4dOqQPP/xQf/zxh5o0aaIqVarorbfe0uHDh2+5cAAAgCvleTKtr6+vevXqpaVLl+q3335Tp06d9NFHH+mee+7RE088URA1AgCAO1Sub/1cy5kzZ/T5559r+PDhOnXqlDIzM/Orthvi1g8AAEVPXt6/b+oj9CVp2bJlmjp1qr788kt5eHioc+fOiouLu9ndAQAAZJOnoHLw4EElJCQoISFBu3bt0kMPPaQPPvhAnTt3lq+vb0HVCAAA7lC5DirR0dFauHChSpcurdjYWPXu3VtVq1YtyNoAAMAdLtdBpXjx4pozZ45at24tT0/PgqwJAABAUh6CyjfffFOQdQAAAGST58eTAQAACgtBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2BZBBQAA2JalQWXy5MmqWbOmAgICFBAQoEaNGmn+/PlWlgQAAGzE0qBy9913a/z48dqwYYPWr1+vRx99VG3bttWvv/5qZVkAAMAmHMYYY3URVwoODtaECRMUFxd3w76pqakKDAxUSkqKAgICCqE6AABwq/Ly/p3rb08uaJmZmZo9e7bOnDmjRo0aWV0OAACwAcuDyubNm9WoUSOdP39efn5+mjt3ru67774c+6anpys9Pd31OjU1tbDKBAAAFrD8qZ+qVasqKSlJa9as0XPPPacePXpo69atOfYdN26cAgMDXUtEREQhVwsAAAqT7eaoREVFqVKlSvrkk0+yrctpRCUiIoI5KgAAFCFFco7KZVlZWW5h5EpOp1NOp7OQKwIAAFaxNKgMHz5c0dHRuueee3T69GlNnz5dS5YsUWJiopVlAQAAm7A0qBw9elSxsbE6dOiQAgMDVbNmTSUmJuqvf/2rlWUBAACbsDSoTJkyxcrDAwAAm7P8qR8AAIBrIagAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbIqgAAADbsjSojBs3TvXr15e/v7/KlCmjdu3aaceOHVaWBAAAbMTSoLJ06VL1799fq1ev1oIFC3ThwgU99thjOnPmjJVlAQAAm3AYY4zVRVx27NgxlSlTRkuXLtUjjzxyw/6pqakKDAxUSkqKAgICCqFCAABwq/Ly/l2skGrKlZSUFElScHBwjuvT09OVnp7uep2amloodQEAAGvYZjJtVlaWBg0apMaNG+v+++/Psc+4ceMUGBjoWiIiIgq5SgAAUJhsc+vnueee0/z58/Xzzz/r7rvvzrFPTiMqERER3PoBAKAIKXK3fgYMGKD//Oc/WrZs2TVDiiQ5nU45nc5CrAwAAFjJ0qBijNHAgQM1d+5cLVmyRBUqVLCyHAAAYDOWBpX+/ftr+vTp+vrrr+Xv76/Dhw9LkgIDA+Xt7W1laQAAwAYsnaPicDhybI+Pj1fPnj1vuD2PJwMAUPQUmTkqNpnHCwAAbMo2jycDAABcjaACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsy9KgsmzZMrVp00bh4eFyOByaN2+eleUAAACbsTSonDlzRrVq1dJHH31kZRkAAMCmill58OjoaEVHR1tZAgAAsDFLg0pepaenKz093fU6NTXVwmoAAEBBK1KTaceNG6fAwEDXEhERYXVJAACgABWpoDJ8+HClpKS4ln379lldEgAAKEBF6taP0+mU0+m0ugwAAFBIitSICgAAuLNYOqKSlpamXbt2uV4nJycrKSlJwcHBuueeeyysDAAA2IGlQWX9+vVq1qyZ6/WQIUMkST169FBCQoJFVQEAALuwNKg0bdpUxhgrSwAAADbGHBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbBBUAAGBbtggqH330kcqXLy8vLy81bNhQa9eutbokAABgA5YHlS+++EJDhgzRqFGjtHHjRtWqVUstWrTQ0aNHrS4NAABYzPKg8u6776pv377q1auX7rvvPv3v//6vfHx8NHXqVKtLAwAAFrM0qGRkZGjDhg2KiopytXl4eCgqKkqrVq2ysDIAAGAHxaw8+PHjx5WZmamyZcu6tZctW1bbt2/P1j89PV3p6emu16mpqQVeIwAAsI7lt37yYty4cQoMDHQtERERVpcEAAAKkKVBpXTp0vL09NSRI0fc2o8cOaLQ0NBs/YcPH66UlBTXsm/fvsIqFQAAWMDSoFKiRAnVrVtXixYtcrVlZWVp0aJFatSoUbb+TqdTAQEBbgsAALh9WTpHRZKGDBmiHj16qF69emrQoIEmTpyoM2fOqFevXlaXBgAALGZ5UOnSpYuOHTum1157TYcPH1bt2rX1ww8/ZJtgCwAA7jwOY4yxuoiblZKSoqCgIO3bt4/bQAAAFBGpqamKiIjQqVOnFBgYeN2+lo+o3IrTp09LEk//AABQBJ0+ffqGQaVIj6hkZWXp4MGD8vf3l8PhsLocy11OqIwwFSyuc+HgOhcOrnPh4Vr/P8YYnT59WuHh4fLwuP5zPUV6RMXDw0N333231WXYDk9EFQ6uc+HgOhcOrnPh4VpfcqORlMuK1Ae+AQCAOwtBBQAA2BZB5TbidDo1atQoOZ1Oq0u5rXGdCwfXuXBwnQsP1/rmFOnJtAAA4PbGiAoAALAtggoAALAtggoAALAtggoAALAtgkoRcvLkSXXt2lUBAQEKCgpSXFyc0tLSrrvN+fPn1b9/f5UqVUp+fn7q0KGDjhw5kmPfEydO6O6775bD4dCpU6cK4AyKhoK4zps2bVJMTIwiIiLk7e2t6tWr6/333y/oU7Gdjz76SOXLl5eXl5caNmyotWvXXrf/7NmzVa1aNXl5eSkyMlLff/+923pjjF577TWFhYXJ29tbUVFR2rlzZ0GeQpGQn9f5woULGjZsmCIjI+Xr66vw8HDFxsbq4MGDBX0atpffP89XevbZZ+VwODRx4sR8rroIMigyWrZsaWrVqmVWr15tli9fbu69914TExNz3W2effZZExERYRYtWmTWr19vHnzwQfPQQw/l2Ldt27YmOjraSDJ//vlnAZxB0VAQ13nKlCnmhRdeMEuWLDG7d+82//rXv4y3t7f58MMPC/p0bGPmzJmmRIkSZurUqebXX381ffv2NUFBQebIkSM59l+xYoXx9PQ0//jHP8zWrVvNyJEjTfHixc3mzZtdfcaPH28CAwPNvHnzzKZNm8wTTzxhKlSoYM6dO1dYp2U7+X2dT506ZaKioswXX3xhtm/fblatWmUaNGhg6tatW5inZTsF8fN82VdffWVq1aplwsPDzXvvvVfAZ2J/BJUiYuvWrUaSWbdunatt/vz5xuFwmAMHDuS4zalTp0zx4sXN7NmzXW3btm0zksyqVavc+n788cemSZMmZtGiRXd0UCno63yl559/3jRr1iz/ire5Bg0amP79+7teZ2ZmmvDwcDNu3Lgc+3fu3Nm0atXKra1hw4bmmWeeMcYYk5WVZUJDQ82ECRNc60+dOmWcTqeZMWNGAZxB0ZDf1zkna9euNZLMnj178qfoIqigrvP+/fvNXXfdZbZs2WLKlStHUDHGcOuniFi1apWCgoJUr149V1tUVJQ8PDy0Zs2aHLfZsGGDLly4oKioKFdbtWrVdM8992jVqlWutq1bt+r111/XtGnTbvjlULe7grzOV0tJSVFwcHD+FW9jGRkZ2rBhg9s18vDwUFRU1DWv0apVq9z6S1KLFi1c/ZOTk3X48GG3PoGBgWrYsOF1r/vtrCCuc05SUlLkcDgUFBSUL3UXNQV1nbOystS9e3e9/PLLqlGjRsEUXwTd2e9KRcjhw4dVpkwZt7ZixYopODhYhw8fvuY2JUqUyPaPSdmyZV3bpKenKyYmRhMmTNA999xTILUXJQV1na+2cuVKffHFF+rXr1++1G13x48fV2ZmpsqWLevWfr1rdPjw4ev2v/xrXvZ5uyuI63y18+fPa9iwYYqJibljv1ivoK7zW2+9pWLFiumFF17I/6KLMIKKxV555RU5HI7rLtu3by+w4w8fPlzVq1dXt27dCuwYdmD1db7Sli1b1LZtW40aNUqPPfZYoRwTyA8XLlxQ586dZYzR5MmTrS7ntrJhwwa9//77SkhIkMPhsLocWylmdQF3updeekk9e/a8bp+KFSsqNDRUR48edWu/ePGiTp48qdDQ0By3Cw0NVUZGhk6dOuX2v/0jR464tvnpp5+0efNmzZkzR9KlpygkqXTp0hoxYoTGjBlzk2dmL1Zf58u2bt2q5s2bq1+/fho5cuRNnUtRVLp0aXl6emZ74iyna3RZaGjodftf/vXIkSMKCwtz61O7du18rL7oKIjrfNnlkLJnzx799NNPd+xoilQw13n58uU6evSo28h2ZmamXnrpJU2cOFF//PFH/p5EUWL1JBnkzuVJnuvXr3e1JSYm5mqS55w5c1xt27dvd5vkuWvXLrN582bXMnXqVCPJrFy58pqz129nBXWdjTFmy5YtpkyZMubll18uuBOwsQYNGpgBAwa4XmdmZpq77rrrupMPW7du7dbWqFGjbJNp3377bdf6lJQUJtPm83U2xpiMjAzTrl07U6NGDXP06NGCKbyIye/rfPz4cbd/izdv3mzCw8PNsGHDzPbt2wvuRIoAgkoR0rJlS1OnTh2zZs0a8/PPP5vKlSu7PTa7f/9+U7VqVbNmzRpX27PPPmvuuece89NPP5n169ebRo0amUaNGl3zGIsXL76jn/oxpmCu8+bNm01ISIjp1q2bOXTokGu5k/7RnzlzpnE6nSYhIcFs3brV9OvXzwQFBZnDhw8bY4zp3r27eeWVV1z9V6xYYYoVK2befvtts23bNjNq1KgcH08OCgoyX3/9tfnll19M27ZteTw5n69zRkaGeeKJJ8zdd99tkpKS3H5+09PTLTlHOyiIn+er8dTPJQSVIuTEiRMmJibG+Pn5mYCAANOrVy9z+vRp1/rk5GQjySxevNjVdu7cOfP888+bkiVLGh8fH9O+fXtz6NChax6DoFIw13nUqFFGUralXLlyhXhm1vvwww/NPffcY0qUKGEaNGhgVq9e7VrXpEkT06NHD7f+s2bNMlWqVDElSpQwNWrUMN99953b+qysLPPqq6+asmXLGqfTaZo3b2527NhRGKdia/l5nS//vOe0XPl34E6U3z/PVyOoXOIw5v+flAAAAGAzPPUDAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6ACAABsi6AC4LbicDg0b948q8sAkE8IKgDyTc+ePXP8ZuqWLVtaXRqAIopvTwaQr1q2bKn4+Hi3NqfTaVE1AIo6RlQA5Cun06nQ0FC3pWTJkpIu3ZaZPHmyoqOj5e3trYoVK2rOnDlu22/evFmPPvqovL29VapUKfXr109paWlufaZOnaoaNWrI6XQqLCxMAwYMcFt//PhxtW/fXj4+PqpcubK++eabgj1pAAWGoAKgUL366qvq0KGDNm3apK5du+qpp57Stm3bJElnzpxRixYtVLJkSa1bt06zZ8/WwoUL3YLI5MmT1b9/f/Xr10+bN2/WN998o3vvvdftGGPGjFHnzp31yy+/6PHHH1fXrl118uTJQj1PAPnE6m9FBHD76NGjh/H09DS+vr5uy5tvvmmMMUaSefbZZ922adiwoXnuueeMMcZ8+umnpmTJkiYtLc21/rvvvjMeHh7m8OHDxhhjwsPDzYgRI65ZgyQzcuRI1+u0tDQjycyfPz/fzhNA4WGOCoB81axZM02ePNmtLTg42PX7Ro0aua1r1KiRkpKSJEnbtm1TrVq15Ovr61rfuHFjZWVlaceOHXI4HDp48KCaN29+3Rpq1qzp+r2vr68CAgJ09OjRmz0lABYiqADIV76+vtluxeQXb2/vXPUrXry422uHw6GsrKyCKAlAAWOOCoBCtXr16myvq1evLkmqXr26Nm3apDNnzrjWr1ixQh4eHqpatar8/f1Vvnx5LVq0qFBrBmAdRlQA5Kv09HQdPnzYra1YsWIqXbq0JGn27NmqV6+e/vKXv+jzzz/X2rVrNWXKFElS165dNWrUKPXo0UOjR4/WsWPHNHDgQHXv3l1ly5aVJI0ePVrPPvusypQpo+joaJ0+fVorVqzQwIEDC/dEARQKggqAfPXDDz8oLCzMra1q1aravn27pEtP5MycOVPPP/+8wsLCNGPGDN13332SJB8fHyUmJurFF19U/fr15ePjow4dOujdd9917atHjx46f/683nvvPQ0dOlSlS5dWx44dC+8EARQqhzHGWF0EgDuDw+HQ3Llz1a5dO6tLAVBEMEcFAADYFkEFAADYFnNUABQa7jQDyCtGVAAAgG0RVAAAgG0RVAAAgG0RVAAAgG0RVAAAgG0RVAAAgG0RVAAAgG0RVAAAgG0RVAAAgG39f8sdQ69OASV1AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1144,23 +1273,23 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 80, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "8/8 [==============================] - 12s 1s/step - loss: 2.9013 - accuracy: 0.2031\n" + "8/8 [==============================] - 9s 1s/step - loss: 1.4028 - accuracy: 0.4141\n" ] }, { "data": { "text/plain": [ - "[2.901285171508789, 0.203125]" + "[1.4027552604675293, 0.4140625]" ] }, - "execution_count": 36, + "execution_count": 80, "metadata": {}, "output_type": "execute_result" } @@ -1186,12 +1315,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.6" + "version": "3.10.1 (v3.10.1:2cd268a3a9, Dec 6 2021, 14:28:59) [Clang 13.0.0 (clang-1300.0.29.3)]" }, "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" } } }, diff --git a/sw_lab9-10_2.ipynb b/sw_lab9-10_2.ipynb deleted file mode 100644 index 9aee02c..0000000 --- a/sw_lab9-10_2.ipynb +++ /dev/null @@ -1,1486 +0,0 @@ -{ - "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": 4, - "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": 3, - "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": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAHHCAYAAAC7soLdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACaUUlEQVR4nOzdd3hT1RvA8W+StuneuxTKnmVvlCHIEBCQrQjIcjBERRFxgFtxoKK4GD9UpgiKKHvvjaBsCgVauvdKmtzfH2kDhRZaaJOO9/M8eZrcnHvvm1rp23Pec45KURQFIYQQQohyTG3tAIQQQgghSpokPEIIIYQo9yThEUIIIUS5JwmPEEIIIco9SXiEEEIIUe5JwiOEEEKIck8SHiGEEEKUe5LwCCGEEKLck4RHCCGEEOWeJDxCiGKjUqmYMWNGkc+7dOkSKpWKhQsXFntMQggBkvAIUe4sXLgQlUqFSqVi165dt72vKArBwcGoVCp69eplhQiFEMLyJOERopyyt7dn8eLFtx3fvn07V69eRavVWiEqIYSwDkl4hCinHnnkEVasWEF2dnae44sXL6ZZs2b4+/tbKbKKIy0tzdohCCFySMIjRDk1dOhQ4uLi2Lhxo/mYTqfj119/5fHHH8/3nLS0NF566SWCg4PRarXUrl2bTz75BEVR8rTLysrihRdewMfHBxcXFx599FGuXr2a7zWvXbvGqFGj8PPzQ6vVUr9+febPn39Pnyk+Pp4pU6YQGhqKs7Mzrq6u9OjRg+PHj9/WNjMzkxkzZlCrVi3s7e0JCAjgscce48KFC+Y2RqORL774gtDQUOzt7fHx8aF79+4cOnQIuHNt0a31SjNmzEClUvHff//x+OOP4+HhwQMPPADAP//8w8iRI6lWrRr29vb4+/szatQo4uLi8v1+jR49msDAQLRaLVWrVuXZZ59Fp9Nx8eJFVCoVn3/++W3n7dmzB5VKxZIlS4r6bRWiQrCxdgBCiJIREhJCmzZtWLJkCT169ADg77//JikpiSFDhvDll1/maa8oCo8++ihbt25l9OjRNG7cmPXr1/Pyyy9z7dq1PL9kx4wZw88//8zjjz9O27Zt2bJlCz179rwthqioKFq3bo1KpWLChAn4+Pjw999/M3r0aJKTk5k8eXKRPtPFixdZvXo1AwcOpGrVqkRFRfHdd9/RoUMH/vvvPwIDAwEwGAz06tWLzZs3M2TIEJ5//nlSUlLYuHEjJ0+epHr16gCMHj2ahQsX0qNHD8aMGUN2djY7d+5k3759NG/evEix5Ro4cCA1a9bk/fffNyeKGzdu5OLFizz11FP4+/vz77//8v333/Pvv/+yb98+VCoVABEREbRs2ZLExETGjRtHnTp1uHbtGr/++ivp6elUq1aNdu3a8csvv/DCCy/kue8vv/yCi4sLffr0uae4hSj3FCFEubJgwQIFUA4ePKjMmTNHcXFxUdLT0xVFUZSBAwcqnTp1UhRFUapUqaL07NnTfN7q1asVQHn33XfzXG/AgAGKSqVSzp8/ryiKohw7dkwBlOeeey5Pu8cff1wBlLfeest8bPTo0UpAQIASGxubp+2QIUMUNzc3c1xhYWEKoCxYsOCOny0zM1MxGAx5joWFhSlarVZ5++23zcfmz5+vAMpnn3122zWMRqOiKIqyZcsWBVAmTZpUYJs7xXXrZ33rrbcUQBk6dOhtbXM/582WLFmiAMqOHTvMx4YPH66o1Wrl4MGDBcb03XffKYBy6tQp83s6nU7x9vZWRowYcdt5QggTGdISohwbNGgQGRkZ/Pnnn6SkpPDnn38WOJz1119/odFomDRpUp7jL730Eoqi8Pfff5vbAbe1u7W3RlEUVq5cSe/evVEUhdjYWPOjW7duJCUlceTIkSJ9Hq1Wi1pt+mfLYDAQFxeHs7MztWvXznOtlStX4u3tzcSJE2+7Rm5vysqVK1GpVLz11lsFtrkXzzzzzG3HHBwczM8zMzOJjY2ldevWAOa4jUYjq1evpnfv3vn2LuXGNGjQIOzt7fnll1/M761fv57Y2FiGDRt2z3ELUd5JwiNEOebj40OXLl1YvHgxv/32GwaDgQEDBuTb9vLlywQGBuLi4pLneN26dc3v535Vq9XmYaFctWvXzvM6JiaGxMREvv/+e3x8fPI8nnrqKQCio6OL9HmMRiOff/45NWvWRKvV4u3tjY+PD//88w9JSUnmdhcuXKB27drY2BQ8an/hwgUCAwPx9PQsUgx3U7Vq1duOxcfH8/zzz+Pn54eDgwM+Pj7mdrlxx8TEkJycTIMGDe54fXd3d3r37p1nBt4vv/xCUFAQDz30UDF+EiHKF6nhEaKce/zxxxk7dizXr1+nR48euLu7W+S+RqMRgGHDhjFixIh82zRs2LBI13z//fd54403GDVqFO+88w6enp6o1WomT55svl9xKqinx2AwFHjOzb05uQYNGsSePXt4+eWXady4Mc7OzhiNRrp3735PcQ8fPpwVK1awZ88eQkND+eOPP3juuefMvV9CiNtJwiNEOdevXz+efvpp9u3bx7JlywpsV6VKFTZt2kRKSkqeXp7Tp0+b38/9ajQazb0ouc6cOZPnerkzuAwGA126dCmWz/Lrr7/SqVMn5s2bl+d4YmIi3t7e5tfVq1dn//796PV6bG1t871W9erVWb9+PfHx8QX28nh4eJivf7Pc3q7CSEhIYPPmzcycOZM333zTfPzcuXN52vn4+ODq6srJkyfves3u3bvj4+PDL7/8QqtWrUhPT+fJJ58sdExCVETy54AQ5ZyzszNz585lxowZ9O7du8B2jzzyCAaDgTlz5uQ5/vnnn6NSqcwzvXK/3jrLa/bs2XleazQa+vfvz8qVK/P9JR4TE1Pkz6LRaG6bIr9ixQquXbuW51j//v2JjY297bMA5vP79++PoijMnDmzwDaurq54e3uzY8eOPO9/8803RYr55mvmuvX7pVar6du3L2vWrDFPi88vJgAbGxuGDh3K8uXLWbhwIaGhoUXuLROiopEeHiEqgIKGlG7Wu3dvOnXqxPTp07l06RKNGjViw4YN/P7770yePNlcs9O4cWOGDh3KN998Q1JSEm3btmXz5s2cP3/+tmt++OGHbN26lVatWjF27Fjq1atHfHw8R44cYdOmTcTHxxfpc/Tq1Yu3336bp556irZt23LixAl++eUXqlWrlqfd8OHDWbRoES+++CIHDhzgwQcfJC0tjU2bNvHcc8/Rp08fOnXqxJNPPsmXX37JuXPnzMNLO3fupFOnTkyYMAEwTcH/8MMPGTNmDM2bN2fHjh2cPXu20DG7urrSvn17Pv74Y/R6PUFBQWzYsIGwsLDb2r7//vts2LCBDh06MG7cOOrWrUtkZCQrVqxg165deYYjhw8fzpdffsnWrVv56KOPivR9FKJCstr8MCFEibh5Wvqd3DotXVEUJSUlRXnhhReUwMBAxdbWVqlZs6Yya9Ys85ToXBkZGcqkSZMULy8vxcnJSendu7dy5cqV26ZqK4qiREVFKePHj1eCg4MVW1tbxd/fX+ncubPy/fffm9sUZVr6Sy+9pAQEBCgODg5Ku3btlL179yodOnRQOnTokKdtenq6Mn36dKVq1arm+w4YMEC5cOGCuU12drYya9YspU6dOoqdnZ3i4+Oj9OjRQzl8+HCe64wePVpxc3NTXFxclEGDBinR0dEFTkuPiYm5Le6rV68q/fr1U9zd3RU3Nzdl4MCBSkRERL7fr8uXLyvDhw9XfHx8FK1Wq1SrVk0ZP368kpWVddt169evr6jVauXq1at3/L4JIRRFpSi39LMKIYQoE5o0aYKnpyebN2+2dihClHpSwyOEEGXQoUOHOHbsGMOHD7d2KEKUCdLDI4QQZcjJkyc5fPgwn376KbGxsVy8eBF7e3trhyVEqSc9PEIIUYb8+uuvPPXUU+j1epYsWSLJjhCFJD08QgghhCj3pIdHCCGEEOWeJDxCCCGEKPcq3MKDRqORiIgIXFxc7mtHZCGEEEJYjqIopKSkEBgYeE/7xlW4hCciIoLg4GBrhyGEEEKIe3DlyhUqVapU5PMqXMKTuynilStXcHV1tXI0QgghhCiM5ORkgoOD82xuXBQVLuHJHcZydXWVhEcIIYQoY+61HEWKloUQQghR7knCI4QQQohyTxIeIYQQQpR7Fa6GRwghyjKj0YhOp7N2GEKUCDs7u3uacl4YkvAIIUQZodPpCAsLw2g0WjsUIUqEWq2matWq2NnZFfu1JeERQogyQFEUIiMj0Wg0BAcHl9hfwUJYS+7CwJGRkVSuXLnYFweWhEcIIcqA7Oxs0tPTCQwMxNHR0drhCFEifHx8iIiIIDs7G1tb22K9tvyJIIQQZYDBYAAoka5+IUqL3J/v3J/34iQJjxBClCGyB6Aoz0ry51sSHiGEEEKUe5LwCCGEEKLck4RHCCFEidu7dy8ajYaePXtaOxRRQUnCU0wURSEuI46LSRetHYoQQpQ68+bNY+LEiezYsYOIiAirxSGLNlZckvAUk53XdtJxeUem7phq7VCEEKJUSU1NZdmyZTz77LP07NmThQsX5nl/zZo1tGjRAnt7e7y9venXr5/5vaysLKZOnUpwcDBarZYaNWowb948ABYuXIi7u3uea61evTpP4euMGTNo3LgxP/74I1WrVsXe3h6AdevW8cADD+Du7o6Xlxe9evXiwoULea519epVhg4diqenJ05OTjRv3pz9+/dz6dIl1Go1hw4dytN+9uzZVKlSRRaGLKVkHZ5iEuIaAsClpEsYFSNqleSSQoiSoygKGfrin7pbGA62miLNplm+fDl16tShdu3aDBs2jMmTJzNt2jRUKhVr166lX79+TJ8+nUWLFqHT6fjrr7/M5w4fPpy9e/fy5Zdf0qhRI8LCwoiNjS1SvOfPn2flypX89ttvaDQaANLS0njxxRdp2LAhqampvPnmm/Tr149jx46hVqtJTU2lQ4cOBAUF8ccff+Dv78+RI0cwGo2EhITQpUsXFixYQPPmzc33WbBgASNHjpRFIUspSXiKSaBzILZqWzINmUSmRRLkHGTtkIQQ5ViG3kC9N9db5d7/vd0NR7vC//qYN28ew4YNA6B79+4kJSWxfft2OnbsyHvvvceQIUOYOXOmuX2jRo0AOHv2LMuXL2fjxo106dIFgGrVqhU5Xp1Ox6JFi/Dx8TEf69+/f5428+fPx8fHh//++48GDRqwePFiYmJiOHjwIJ6engDUqFHD3H7MmDE888wzfPbZZ2i1Wo4cOcKJEyf4/fffixyfsAxJQ4uJjdqGKq5VAAhLCrNyNEIIUTqcOXOGAwcOMHToUABsbGwYPHiweVjq2LFjdO7cOd9zjx07hkajoUOHDvcVQ5UqVfIkOwDnzp1j6NChVKtWDVdXV0JCQgAIDw8337tJkybmZOdWffv2RaPRsGrVKsA0vNapUyfzdUTpIz08xaiqW1XOJ57nYuJFHgh6wNrhCCHKMQdbDf+93c1q9y6sefPmkZ2dTWBgoPmYoihotVrmzJmDg4NDwfe5w3tg2mhSUZQ8x/R6/W3tnJycbjvWu3dvqlSpwg8//EBgYCBGo5EGDRqYi5rvdm87OzuGDx/OggULeOyxx1i8eDFffPHFHc8R1iUJTzGq5mbqag1Llh4eIUTJUqlURRpWsobs7GwWLVrEp59+SteuXfO817dvX5YsWULDhg3ZvHkzTz311G3nh4aGYjQa2b59u3lI62Y+Pj6kpKSQlpZmTmqOHTt217ji4uI4c+YMP/zwAw8++CAAu3btytOmYcOG/Pjjj8THxxfYyzNmzBgaNGjAN998Q3Z2No899thd7y2sp3T/31LGVHWrCsDFRJmaLoQQf/75JwkJCYwePRo3N7c87/Xv35958+Yxa9YsOnfuTPXq1RkyZAjZ2dn89ddfTJ06lZCQEEaMGMGoUaPMRcuXL18mOjqaQYMG0apVKxwdHXnttdeYNGkS+/fvv20GWH48PDzw8vLi+++/JyAggPDwcF599dU8bYYOHcr7779P3759+eCDDwgICODo0aMEBgbSpk0bAOrWrUvr1q2ZOnUqo0aNumuvkLAuqeEpRrk9PJeSL1k3ECGEKAXmzZtHly5dbkt2wJTwHDp0CE9PT1asWMEff/xB48aNeeihhzhw4IC53dy5cxkwYADPPfccderUYezYsaSlpQHg6enJzz//zF9//UVoaChLlixhxowZd41LrVazdOlSDh8+TIMGDXjhhReYNWtWnjZ2dnZs2LABX19fHnnkEUJDQ/nwww/Ns7xyjR49Gp1Ox6hRo+7hOyQsSaXcOgBaziUnJ+Pm5kZSUhKurq7Feu10fTqtFrcCYOfgnbjbuxfr9YUQFVdmZiZhYWF51pIR1vfOO++wYsUK/vnnH2uHUi7c6ef8fn9/Sw9PMXK0dSTQyVSYJ3U8QghRfqWmpnLy5EnmzJnDxIkTrR2OKARJeIqZ1PEIIUT5N2HCBJo1a0bHjh1lOKuMkISnmOUmPLIWjxBClF8LFy4kKyuLZcuW3VbXI0onSXiKmbmHRzYRFUIIIUoNSXiKmXktHunhEUIIIUoNSXiKWW4Pz7XUa2RmZ1o5GiGEEEKAJDzFztPeE1c7VxQULidftnY4QgghhEASnmKnUqlkWEsIIYQoZaya8HzwwQe0aNECFxcXfH196du3L2fOnLnreStWrKBOnTrY29sTGhrKX3/9ZYFoC09magkhhBCli1UTnu3btzN+/Hj27dvHxo0b0ev1dO3a1bxseH727NnD0KFDGT16NEePHqVv37707duXkydPWjDyO8vt4ZGZWkIIcf86duzI5MmTza9DQkKYPXv2Hc9RqVSsXr36vu9dXNcR1mfVhGfdunWMHDmS+vXr06hRIxYuXEh4eDiHDx8u8JwvvviC7t278/LLL1O3bl3eeecdmjZtypw5cywY+Z1JD48QQkDv3r3p3r17vu/t3LkTlUp1T1syHDx4kHHjxt1veHnMmDGDxo0b33Y8MjKSHj16FOu9CpKRkYGnpyfe3t5kZWVZ5J4VSamq4UlKSgJMG8IVZO/evXTp0iXPsW7durF3794Sja0obt5E1GA0WDkaIYSwjtGjR7Nx40auXr1623sLFiygefPmNGzYsMjX9fHxwdHRsThCvCt/f3+0Wq1F7rVy5Urq169PnTp1rN6rpCgK2dnZVo2huJWahMdoNDJ58mTatWtHgwYNCmx3/fp1/Pz88hzz8/Pj+vXr+bbPysoiOTk5z6OkBToHYqe2I8uQRWRaZInfTwghSqNevXrh4+PDwoUL8xxPTU1lxYoVjB49mri4OIYOHUpQUBCOjo7mXc/v5NYhrXPnztG+fXvs7e2pV68eGzduvO2cqVOnUqtWLRwdHalWrRpvvPEGer0eMK2aPHPmTI4fP45KpUKlUpljvnVI68SJEzz00EM4ODjg5eXFuHHjSE1NNb8/cuRI+vbtyyeffEJAQABeXl6MHz/efK87mTdvHsOGDWPYsGHMmzfvtvf//fdfevXqhaurKy4uLjz44INcuHDB/P78+fOpX78+Wq2WgIAAJkyYAMClS5dQqVQcO3bM3DYxMRGVSsW2bdsA2LZtGyqVir///ptmzZqh1WrZtWsXFy5coE+fPvj5+eHs7EyLFi3YtGlTnriysrKYOnUqwcHBaLVaatSowbx581AUhRo1avDJJ5/kaX/s2DFUKhXnz5+/6/ekONlY9G53MH78eE6ePMmuXbuK9boffPABM2fOLNZr3o1GraGKWxXOJZzjYtJFKrlUsuj9hRAVgKKAPt0697Z1BJXqrs1sbGwYPnw4CxcuZPr06ahyzlmxYgUGg4GhQ4eSmppKs2bNmDp1Kq6urqxdu5Ynn3yS6tWr07Jly7vew2g08thjj+Hn58f+/ftJSkrKU++Ty8XFhYULFxIYGMiJEycYO3YsLi4uvPLKKwwePJiTJ0+ybt068y9zNze3266RlpZGt27daNOmDQcPHiQ6OpoxY8YwYcKEPEnd1q1bCQgIYOvWrZw/f57BgwfTuHFjxo4dW+DnuHDhAnv37uW3335DURReeOEFLl++TJUqVQC4du0a7du3p2PHjmzZsgVXV1d2795t7oWZO3cuL774Ih9++CE9evQgKSmJ3bt33/X7d6tXX32VTz75hGrVquHh4cGVK1d45JFHeO+999BqtSxatIjevXtz5swZKleuDMDw4cPZu3cvX375JY0aNSIsLIzY2FhUKhWjRo1iwYIFTJkyxXyPBQsW0L59e2rUqFHk+O5HqUh4JkyYwJ9//smOHTuoVOnOyYG/vz9RUVF5jkVFReHv759v+2nTpvHiiy+aXycnJxMcHHz/Qd9FVdeqnEs4R1hSGO0rtS/x+wkhKhh9OrwfaJ17vxYBdk6Fajpq1ChmzZrF9u3b6dixI2D6hde/f3/c3Nxwc3PL88tw4sSJrF+/nuXLlxcq4dm0aROnT59m/fr1BAaavh/vv//+bXU3r7/+uvl5SEgIU6ZMYenSpbzyyis4ODjg7OyMjY1Ngb9LABYvXkxmZiaLFi3Cycn0+efMmUPv3r356KOPzKMPHh4ezJkzB41GQ506dejZsyebN2++Y8Izf/58evTogYeHB2Aq1ViwYAEzZswA4Ouvv8bNzY2lS5dia2sLQK1atcznv/vuu7z00ks8//zz5mMtWrS46/fvVm+//TYPP/yw+bWnpyeNGjUyv37nnXdYtWoVf/zxBxMmTODs2bMsX76cjRs3mstNqlWrZm4/cuRI3nzzTQ4cOEDLli3R6/UsXrz4tl4fS7DqkJaiKEyYMIFVq1axZcsWqlatetdz2rRpw+bNm/Mc27hxI23atMm3vVarxdXVNc/DEqq5y1o8QghRp04d2rZty/z58wE4f/48O3fuZPTo0QAYDAbeeecdQkND8fT0xNnZmfXr1xMeHl6o6586dYrg4GBzsgPk+/tg2bJltGvXDn9/f5ydnXn99dcLfY+b79WoUSNzsgPQrl07jEZjniVV6tevn2dD0YCAAKKjowu8rsFg4H//+x/Dhg0zHxs2bBgLFy7EaDQCpmGgBx980Jzs3Cw6OpqIiAg6d+5cpM+Tn+bNm+d5nZqaypQpU6hbty7u7u44Oztz6tQp8/fu2LFjaDQaOnTokO/1AgMD6dmzp/m//5o1a8jKymLgwIH3HWtRWbWHZ/z48SxevJjff/8dFxcXcx2Om5sbDg4OgKmrLCgoiA8++ACA559/ng4dOvDpp5/Ss2dPli5dyqFDh/j++++t9jnyU9VVZmoJIUqQraOpp8Va9y6C0aNHM3HiRL7++msWLFhA9erVzb8gZ82axRdffMHs2bMJDQ3FycmJyZMno9Ppii3cvXv38sQTTzBz5ky6detm7in59NNPi+0eN7s1KVGpVObEJT/r16/n2rVrDB48OM9xg8HA5s2befjhh82/E/Nzp/cA1GpT34aiKOZjBdUU3ZzMAUyZMoWNGzfyySefUKNGDRwcHBgwYID5v8/d7g0wZswYnnzyST7//HMWLFjA4MGDLVZ0fjOr9vDMnTuXpKQkOnbsSEBAgPmxbNkyc5vw8HAiI28U/rZt25bFixfz/fff06hRI3799VdWr159x0Jna8jt4ZG1eIQQJUKlMg0rWeNRiPqdmw0aNAi1Ws3ixYtZtGgRo0aNMtfz7N69mz59+jBs2DAaNWpEtWrVOHv2bKGvXbduXa5cuZLn98S+ffvytNmzZw9VqlRh+vTpNG/enJo1a3L5ct6tf+zs7DAY7jyrtm7duhw/fjzPWnG7d+9GrVZTu3btQsd8q3nz5jFkyBCOHTuW5zFkyBBz8XLDhg3ZuXNnvomKi4sLISEht41+5PLx8QHI8z26uYD5Tnbv3s3IkSPp168foaGh+Pv7c+nSJfP7oaGhGI1Gtm/fXuA1HnnkEZycnJg7dy7r1q1j1KhRhbp3cbNqD8/N2WZBcivIbzZw4ECrdIcVRRXXKqhQkZiVSEJmAh72HtYOSQghrMLZ2ZnBgwczbdo0kpOTGTlypPm9mjVr8uuvv7Jnzx48PDz47LPPiIqKol69eoW6dpcuXahVqxYjRoxg1qxZJCcnM3369DxtatasSXh4OEuXLqVFixasXbuWVatW5WkTEhJCWFgYx44do1KlSri4uNw2Hf2JJ57grbfeYsSIEcyYMYOYmBgmTpzIk08+edvs4cKKiYlhzZo1/PHHH7f94T58+HD69etHfHw8EyZM4KuvvmLIkCFMmzYNNzc39u3bR8uWLalduzYzZszgmWeewdfXlx49epCSksLu3buZOHEiDg4OtG7dmg8//JCqVasSHR2dp6bpTmrWrMlvv/1G7969UalUvPHGG3l6q0JCQhgxYgSjRo0yFy1fvnyZ6OhoBg0aBIBGo2HkyJFMmzaNmjVrFliCUtJKzbT08sbBxoFAZ9OYsgxrCSEqutGjR5OQkEC3bt3y1Nu8/vrrNG3alG7dutGxY0f8/f3p27dvoa+rVqtZtWoVGRkZtGzZkjFjxvDee+/lafPoo4/ywgsvMGHCBBo3bsyePXt444038rTp378/3bt3p1OnTvj4+OQ7Nd7R0ZH169cTHx9PixYtGDBgAJ07d76vhW9zC6Dzq7/p3LkzDg4O/Pzzz3h5ebFlyxZSU1Pp0KEDzZo144cffjAPn40YMYLZs2fzzTffUL9+fXr16sW5c+fM15o/fz7Z2dk0a9aMyZMn8+677xYqvs8++wwPDw/atm1L79696datG02bNs3TZu7cuQwYMIDnnnuOOnXqMHbs2Nt2TBg9ejQ6nY6nnnqqqN+iYqNSCtPNUo4kJyfj5uZGUlJSiRcwP7PpGXZf281bbd5iQK0BJXovIUT5lpmZSVhYGFWrVsXe3t7a4QhRJDt37qRz585cuXLljr1hd/o5v9/f39LDU4Jk13QhhBAVWVZWFlevXmXGjBkMHDjwnof+ioMkPCUod08tKVwWQghRES1ZsoQqVaqQmJjIxx9/bNVYJOEpQdLDI4QQoiIbOXIkBoOBw4cPExQUZNVYJOEpQbk9PBGpEWRmZ1o5GiGEEKLikoSnBHnae+KudUdB4XLy5bufIIQQQogSIQlPCZM6HiGEEML6JOEpYVLHI4QQQlifJDwlTHp4hBBCCOuThKeE5SY80sMjhBBCWI8kPCUsN+G5lHQJg/HOG9MJIYQQomRIwlPCAp0C0Wq06Iw6ItIirB2OEEJY1MiRI4u0N5YQJUUSnhKmUWuo4loFkGEtIYQQwlok4bEAqeMRQojbbd++nZYtW6LVagkICODVV18lOzvb/P6vv/5KaGgoDg4OeHl50aVLF/Mu3Nu2baNly5Y4OTnh7u5Ou3btuHxZ1jsTBbOxdgAVQe7UdJmpJYQoLoqikJGdYZV7O9g4oFKp7usa165d45FHHmHkyJEsWrSI06dPM3bsWOzt7ZkxYwaRkZEMHTqUjz/+mH79+pGSksLOnTtRFIXs7Gz69u3L2LFjWbJkCTqdjgMHDtx3TKJ8k4THAqSHRwhR3DKyM2i1uJVV7r3/8f042jre1zW++eYbgoODmTNnDiqVijp16hAREcHUqVN58803iYyMJDs7m8cee4wqVUxlAaGhoQDEx8eTlJREr169qF69OgB169a9vw8lyj0Z0rKAm3t4FEWxcjRCCGF9p06dok2bNnl6Zdq1a0dqaipXr16lUaNGdO7cmdDQUAYOHMgPP/xAQkICAJ6enowcOZJu3brRu3dvvvjiCyIjI631UUQZIT08FlDFtQoqVCRlJZGQlYCnvae1QxJClHEONg7sf3y/1e5d0jQaDRs3bmTPnj1s2LCBr776iunTp7N//36qVq3KggULmDRpEuvWrWPZsmW8/vrrbNy4kdatW5d4bKJskh4eC7C3sSfQORCAi4lSxyOEuH8qlQpHW0erPIqjVqZu3brs3bs3T6/37t27cXFxoVKlSubP2K5dO2bOnMnRo0exs7Nj1apV5vZNmjRh2rRp7NmzhwYNGrB48eL7jkuUX9LDYyFV3apyLfUaYclhNPdvbu1whBDCYpKSkjh27FieY+PGjWP27NlMnDiRCRMmcObMGd566y1efPFF1Go1+/fvZ/PmzXTt2hVfX1/2799PTEwMdevWJSwsjO+//55HH32UwMBAzpw5w7lz5xg+fLh1PqAoEyThsZBqbtXYdW2X9PAIISqcbdu20aRJkzzHRo8ezV9//cXLL79Mo0aN8PT0ZPTo0bz++usAuLq6smPHDmbPnk1ycjJVqlTh008/pUePHkRFRXH69Gn+97//ERcXR0BAAOPHj+fpp5+2xscTZYQkPBZinqmVLDO1hBAVx8KFC1m4cGGB7x84cCDf43Xr1mXdunX5vufn55dnaEuIwpAaHgvJnakVligJjxBCCGFpkvBYSG4PT0RahNUWCxNCCCEqKkl4LMTD3gMPrQdg2jldCCGEEJYjCY8FyYrLQgghhHVIwmNBuQmP7KklhBBCWJYkPBYkPTxCCCGEdUjCY0Gya7oQQghhHZLwWFBuD8/l5MsYjAYrRyOEEEJUHJLwWFCgcyBajRa9Uc+11GvWDkcIIYSoMCThsSC1Sk2IawggdTxCCFFYHTt2ZPLkyebXISEhzJ49+47nqFQqVq9efd/3Lq7rCOuThMfCpI5HCFFR9O7dm+7du+f73s6dO1GpVPzzzz9Fvu7BgwcZN27c/YaXx4wZM2jcuPFtxyMjI+nRo0ex3utWCxcuxN3dvUTvISThsTiZqSWEqChGjx7Nxo0buXr16m3vLViwgObNm9OwYcMiX9fHxwdHR8fiCPGu/P390Wq1FrmXKFmS8FhYVXdJeIQQFUOvXr3w8fG5bfPQ1NRUVqxYwejRo4mLi2Po0KEEBQXh6OhIaGgoS5YsueN1bx3SOnfuHO3bt8fe3p569eqxcePG286ZOnUqtWrVwtHRkWrVqvHGG2+g1+sBUw/LzJkzOX78OCqVCpVKZY751iGtEydO8NBDD+Hg4ICXlxfjxo0jNTXV/P7IkSPp27cvn3zyCQEBAXh5eTF+/Hjzve5FeHg4ffr0wdnZGVdXVwYNGkRUVJT5/ePHj9OpUydcXFxwdXWlWbNmHDp0CIDLly/Tu3dvPDw8cHJyon79+vz111/3HEtZJrulW1hV1xuLDyqKgkqlsnJEQoiySFEUlAzr7MuncnAo1L9dNjY2DB8+nIULFzJ9+nTzOStWrMBgMDB06FBSU1Np1qwZU6dOxdXVlbVr1/Lkk09SvXp1WrZsedd7GI1GHnvsMfz8/Ni/fz9JSUl56n1yubi4sHDhQgIDAzlx4gRjx47FxcWFV155hcGDB3Py5EnWrVvHpk2bAHBzc7vtGmlpaXTr1o02bdpw8OBBoqOjGTNmDBMmTMiT1G3dupWAgAC2bt3K+fPnGTx4MI0bN2bs2LF3/Tz5fb7cZGf79u1kZ2czfvx4Bg8ezLZt2wB44oknaNKkCXPnzkWj0XDs2DFsbW0BGD9+PDqdjh07duDk5MR///2Hs7NzkeMoDyThsbAQtxBUqEjWJROfGY+Xg5e1QxJClEFKRgZnmjazyr1rHzmMqpBDSqNGjWLWrFls376djh07AqbhrP79++Pm5oabmxtTpkwxt584cSLr169n+fLlhUp4Nm3axOnTp1m/fj2BgYEAvP/++7fV3bz++uvm5yEhIUyZMoWlS5fyyiuv4ODggLOzMzY2Nvj7+xd4r8WLF5OZmcmiRYtwcnICYM6cOfTu3ZuPPvoIPz8/ADw8PJgzZw4ajYY6derQs2dPNm/efE8Jz+bNmzlx4gRhYWEEBwcDsGjRIurXr8/Bgwdp0aIF4eHhvPzyy9SpUweAmjVrms8PDw+nf//+hIaGAlCtWrUix1BeyJCWhWk1WoKcgwApXBZClH916tShbdu2zJ8/H4Dz58+zc+dORo8eDYDBYOCdd94hNDQUT09PnJ2dWb9+PeHh4YW6/qlTpwgODjYnOwBt2rS5rd2yZcto164d/v7+ODs78/rrrxf6Hjffq1GjRuZkB6Bdu3YYjUbOnDljPla/fn00Go35dUBAANHR0UW61833DA4ONic7APXq1cPd3Z1Tp04B8OKLLzJmzBi6dOnChx9+yIULF8xtJ02axLvvvku7du1466237qlIvLyQHh4rqOpWlaupVwlLCqOFfwtrhyOEKINUDg7UPnLYavcuitGjRzNx4kS+/vprFixYQPXq1enQoQMAs2bN4osvvmD27NmEhobi5OTE5MmT0el0xRbv3r17eeKJJ5g5cybdunXDzc2NpUuX8umnnxbbPW6WO5yUS6VSYTQaS+ReYJph9vjjj7N27Vr+/vtv3nrrLZYuXUq/fv0YM2YM3bp1Y+3atWzYsIEPPviATz/9lIkTJ5ZYPKWV9PBYQe7UdClcFkLcK5VKhdrR0SqPotYeDho0CLVazeLFi1m0aBGjRo0yX2P37t306dOHYcOG0ahRI6pVq8bZs2cLfe26dety5coVIiMjzcf27duXp82ePXuoUqUK06dPp3nz5tSsWZPLly/naWNnZ4fBcOcV8OvWrcvx48dJS0szH9u9ezdqtZratWsXOuaiyP18V65cMR/777//SExMpF69euZjtWrV4oUXXmDDhg089thjLFiwwPxecHAwzzzzDL/99hsvvfQSP/zwQ4nEWtpJwmMFMjVdCFGRODs7M3jwYKZNm0ZkZCQjR440v1ezZk02btzInj17OHXqFE8//XSeGUh306VLF2rVqsWIESM4fvw4O3fuZPr06Xna1KxZk/DwcJYuXcqFCxf48ssvWbVqVZ42ISEhhIWFcezYMWJjY8nKyrrtXk888QT29vaMGDGCkydPsnXrViZOnMiTTz5prt+5VwaDgWPHjuV5nDp1ii5duhAaGsoTTzzBkSNHOHDgAMOHD6dDhw40b96cjIwMJkyYwLZt27h8+TK7d+/m4MGD1K1bF4DJkyezfv16wsLCOHLkCFu3bjW/V9FIwmMF1dxl8UEhRMUyevRoEhIS6NatW556m9dff52mTZvSrVs3OnbsiL+/P3379i30ddVqNatWrSIjI4OWLVsyZswY3nvvvTxtHn30UV544QUmTJhA48aN2bNnD2+88UaeNv3796d79+506tQJHx+ffKfGOzo6sn79euLj42nRogUDBgygc+fOzJkzp2jfjHykpqbSpEmTPI/evXujUqn4/fff8fDwoH379nTp0oVq1aqxbNkyADQaDXFxcQwfPpxatWoxaNAgevTowcyZMwFTIjV+/Hjq1q1L9+7dqVWrFt988819x1sWqRRFUawdhCUlJyfj5uZGUlISrq6uVokhMTORB5c9CMD+x/fjaGuZBbSEEGVXZmYmYWFhVK1aFXt7e2uHI0SJuNPP+f3+/pYeHitwt3fH094TgEvJl6wbjBBCCFEBSMJjJbKJqBBCCGE5kvBYidTxCCGEEJYjCY+V5G4xIT08QgghRMmThMdKcnt4JOERQhRFBZtnIiqYkvz5loTHSnLX4rmcfJlsY7aVoxFClHa5WxUU5wrEQpQ2uT/fN2/NUVxkawkrCXAKwF5jT6Yhk2up16jiWsXaIQkhSjEbGxscHR2JiYnB1tYWtVr+XhXli9FoJCYmBkdHR2xsij89kYTHStQqNSFuIZyOP01YUpgkPEKIO1KpVAQEBBAWFnbbtghClBdqtZrKlSsXefuSwpCEp5gpilLo/1BV3apyOv40F5Mu0jG4Y8kGJoQo8+zs7KhZs6YMa4lyy87OrsR6LyXhKSbpR48SPesTNB4eBH9duGXGZU8tIURRqdVqWWlZiHsgCU8xUTs4kHHkCGpHRxS9HpWt7V3Pyd01XdbiEUIIIUqWVL0VE22tWmjc3TGmp5P577+FOufmHh6ZaiqEEEKUHEl4iolKrcaxRQsA0vYfKNQ5VVyroFapSdGlEJcZV5LhCSGEEBWaJDzFyLFVKwDS9+8rVHutRkuQcxAgdTxCCCFESZKEpxg5tWoJQPqRoxgLOYvCXMeTKHU8QgghREmRhKcY2dWogcbLCyUzk8x//inUOeY6nmTp4RFCCCFKiiQ8xUilUuHYMreOZ3+hzpEeHiGEEKLkScJTzJzMdTyFK1yWHh4hhBCi5EnCU8xyC5czjh3DmJV11/a5Cc/1tOuk69NLNDYhhBCiopKEp5jZhYRg4+uLotORcfTYXdu7ad3wtPcEpJdHCCGEKCmS8BQzlUp1Y3r6gcLV8eT28kgdjxBCCFEyJOEpAbnT0wu7AGFu4bKsxSOEEEKUDEl4SoC5jueffzCm370uRzYRFUIIIUqWJDwlwLZSJWwCA0CvJ/3I0bu2lx4eIYQQomRZNeHZsWMHvXv3JjAwEJVKxerVq+/Yftu2bahUqtse169ft0zAhaRSqXBqmTs9/e51PLk9PJdTLpNtzC7R2IQQQoiKyKoJT1paGo0aNeLrr78u0nlnzpwhMjLS/PD19S2hCO9d7rBWWiEKl/2d/HGwcSDbmM3VlKslHZoQQghR4dhY8+Y9evSgR48eRT7P19cXd3f34g+oGOUWLmee/BdDahoaZ6cC26pVakJcQzgVf4qwpDBC3EIsFKUQQghRMZTJGp7GjRsTEBDAww8/zO7du+/YNisri+Tk5DwPS7ANDMS2cmUwGMg4fOiu7c1T05NkaroQQghR3MpUwhMQEMC3337LypUrWblyJcHBwXTs2JEjR44UeM4HH3yAm5ub+REcHGyxeIsyPV1magkhhBAlp0wlPLVr1+bpp5+mWbNmtG3blvnz59O2bVs+//zzAs+ZNm0aSUlJ5seVK1csFq9jEQqXZaaWEEIIUXKsWsNTHFq2bMmuXbsKfF+r1aLVai0Y0Q2OuXU8//2HISkJjZtbgW1v7uFRFAWVSmWRGIUQQoiKoEz18OTn2LFjBAQEWDuMfNn6+mJXtSooCumH7lzHU8W1CmqVmhR9CrEZsRaKUAghhKgYrNrDk5qayvnz582vw8LCOHbsGJ6enlSuXJlp06Zx7do1Fi1aBMDs2bOpWrUq9evXJzMzkx9//JEtW7awYcMGa32Eu3Js1RJdWBhp+/fj0rlzge3sNHZUcq5EeEo4YUlh+Dj6WDBKIYQQonyzag/PoUOHaNKkCU2aNAHgxRdfpEmTJrz55psAREZGEh4ebm6v0+l46aWXCA0NpUOHDhw/fpxNmzbR+Q6JhLU55W4kWojC5dw6HpmpJYQQQhQvlaIoirWDsKTk5GTc3NxISkrC1dW1xO+XHRfHuXYPAFBz7x5sPDwKbPvZoc9Y8O8CHq/zONNaTSvx2IQQQoiy4n5/f5f5Gp7SzsbLC23NGgCkHzh4x7ayFo8QQghRMiThsQDHVq2Bu09Pl7V4hBBCiJIhCY8F5E5Pv9u+WrkJT1R6FGn6tBKPSwghhKgoJOGxAKcWLUClQnf+AtkxMQW2c9O64WXvBcClpEsWik4IIYQo/yThsQCNuzvaOnUASDtw59la1dxlppYQQghR3CThsRCnlqZhrbtNT6/qKnU8QgghRHGThMdCHFsVbl8t6eERQgghip8kPBbi2KI5qNXoLl9GHxVVYDvp4RFCCCGKnyQ8FqJxccG+Xj3gzr08uT084cnh6I16i8QmhBBClHeS8FiQeXr6HRIeX0dfHGwcyFayuZpy1VKhCSGEEOWaJDwW5NQ6dwHCgguX1So1Ia4hgNTxCCGEEMVFEh4LcmzaFGxs0F+9iu7qtQLb5Q5rSR2PEEIIUTwk4bEgtZMTDg0aAHeu48ktXD4Tf8YicQkhhBDlnSQ8Fmaenn6HbSZaBphqfXZe20mWIcsicQkhhBDlmSQ8FuZkLlw+gKIo+bZp5NMIP0c/0vRp7L6225LhCSGEEOWSJDwW5tCkCdjakn39Ovrw8HzbqFVquoV0A2DdpXWWDE8IIYQolyThsTC1gwMOjRoCd56enpvwbLuyjYzsDEuEJoQQQpRbkvBYgVPL3G0mCp6eHuodSpBzEBnZGey8utNSoQkhhBDlkiQ8VuDY2pTwpB3YX2Adj0qlomtIVwDWX1pvsdiEEEKI8kgSHitwaNwYlVaLISYWXVjBa+3kDmvtuLqDdH26pcITQgghyh1JeKxAbWdnKl4G0vbtK7BdPc96BLsEk2nIZPvV7ZYKTwghhCh3JOGxktzp6Xeq41GpVHQP6Q7IsJYQQghxPyThsZIbCxAeQDEaC2yXO6y18+pOUnWpFolNCCGEKG8k4bEShwYNUDk4YEhIIOvc+QLb1fKoRYhrCDqjjq1XtlowQiGEEKL8kITHSlR2dqbNRLnzvloqlYruVWVYSwghhLgfkvBYUe6wVtod9tUCzHU8uyN2k6xLLvG4hBBCiPJGEh4rMhcuHzx0xzqe6u7VqeFeg2xjNlvCt1gqPCGEEKLckITHiuzr10ft5IQxKYms06fv2Fb21hJCCCHunSQ8VqSyscGxeXMA0vYVblhrf8R+EjMTSzo0IYQQolyRhMfKzNPT71C4DBDiFkIdzzpkK9lsDt9sidCEEEKIckMSHitzzK3jOXQIJTv7jm1lWEsIIYS4N5LwWJl9nTqoXV0xpqWR+d9/d2ybm/AcuH6AuIw4S4QnhBBClAuS8FiZSqPBsUULANLuMqwV7BJMfa/6GBUjmy5vskR4QgghRLkgCU8pUJh9tXKZ99a6LIsQCiGEEIUlCU8pYC5cPnIERa+/Y9uuIV0BOHT9EDHpMSUemxBCCFEeSMJTCmhr1kTj7o6Snk7GiZN3bBvoHEhDn4YoKGy4vMFCEQohhBBlmyQ8pYBKrb5p9/Q71/HAjWGtDZck4RFCCCEKQxKeUiJ3evrdFiAE6FrFNKx1JPoI19Oul2hcQgghRHkgCU8p4ZTTw5Nx9ChGne6Obf2c/Gjqa9ppXXp5hBBCiLuThKeUsKtWDY2PN0pWFhnHjt21fe6aPOsvyWwtIYQQ4m4k4SklVCoVTi0KPz29a0hX1Co1/8T+w7XUayUdnhBCCFGmScJTihR2Xy0AbwdvmvuZNh6VYS0hhBDiziThKUVyFyDMOH4cY2bmXdvL3lpCCCFE4UjCU4rYVqmCjZ8fil5PxtGjd23fpUoXNCoN/8X9R3hyuAUiFEIIIcomSXhKEZVKdWN6eiGGtTztPWnpb2ovixAKIYQQBbunhCc7O5tNmzbx3XffkZKSAkBERASpqanFGlxF5NSqNQDphViPB6B7VdMihOvCZFhLCCGEKEiRE57Lly8TGhpKnz59GD9+PDExpv2cPvroI6ZMmVLsAVY0uYXLGSdPYkxLu2v7zpU7Y6Oy4UzCGcKSwko6PCGEEKJMKnLC8/zzz9O8eXMSEhJwcHAwH+/Xrx+bN28u1uAqIrtKQdgGBUF2NulHjty1vZvWjdaBpl4hKV4WQggh8lfkhGfnzp28/vrr2NnZ5TkeEhLCtWuyHkxxyO3lSdu7r1DtZW8tIYQQ4s6KnPAYjUYMBsNtx69evYqLi0uxBFXROXfoAEDSb78ValirU+VO2KptOZ94nvMJ50s6PCGEEKLMKXLC07VrV2bPnm1+rVKpSE1N5a233uKRRx4pztgqLJcunbGrUgVDYiIJS5fdtb2rnSvtAtsBMqwlhBBC5KfICc+nn37K7t27qVevHpmZmTz++OPm4ayPPvqoJGKscFQaDV5PPw1A3IIFhVuEsOqNvbUURSnR+IQQQoiypsgJT6VKlTh+/DivvfYaL7zwAk2aNOHDDz/k6NGj+Pr6lkSMFZJb717YBgVhiI0lccWvd23fKbgTdmo7LiVf4mzCWQtEKIQQQpQdNvd0ko0Nw4YNK+5YxE1UtrZ4jR3L9RkziPvxR9wHD0J9S6H4zZxsnXiw0oNsDt/MukvrqO1Z24LRCiGEEKVbkROeRYsW3fH94cOH33MwIi+3x/oRO3cu2VFRJP22Co8hg+/YvntId1PCE7aOSU0moVKpLBSpEEIIUbqplCIWfHh4eOR5rdfrSU9Px87ODkdHR+Lj44s1wOKWnJyMm5sbSUlJuLq6Wjucu4pf9BNR77+PbVAQ1df9jcrWtsC26fp0Oi7vSEZ2Bkt7LaW+V30LRiqEEEKUnPv9/V3kGp6EhIQ8j9TUVM6cOcMDDzzAkiVLihyAuDP3gQPQeHmhv3aNpDV/3rGto60j7Su1B2B92HpLhCeEEEKUCcWyeWjNmjX58MMPef7554vjcuImagcHvEY9BUDcd9+h5LMG0s26hchsLSGEEOJWxbZbuo2NDREREcV1OXET98FD0Li5obt8meS/77zOzoNBD+Jo40hEWgT/xP5joQiFEEKI0q3IRct//PFHnteKohAZGcmcOXNo165dsQUmbtA4O+E5cgQxX3xJ3Hff4vpID1Tq/HNVext7OgZ35K+wv1h/aT2NfBpZOFohhBCi9Cly0bL6ll+0KpUKHx8fHnroIT799FMCAgKKNcDiVtaKlnMZUlI4/1BnjCkpBH35Ba5duxbYdmv4ViZtnYSvoy8bB2xErSq2jjwhhBDCKixetGw0GvM8DAYD169fZ/HixaU+2SnLNC4ueAx7AoDYb7+9Y31Ou6B2ONs6E50ezbHoYxaKUAghhCi95E//MsRz+HBUjo5k/XeK1O3bC2xnp7HjocoPAabiZSGEEKKiK1QNz4svvljoC3722Wf3HIy4MxsPDzyGDiF+3nxi587FuUOHAhcX7BbSjT8u/MGGyxt4pcUraNQaC0crhBBClB6FSniOHj1aqIvJyr4lz+upp0j4+Rcyj/9D2p49OBdQKN4moA2udq7EZsRyJPoILfxbWDhSIYQQovQoVMKzdevWko5DFJKNtzfugwaR8NNPxM39tsCEx1ZjS+fKnVl1fhXrwtZJwiOEEKJCkxqeMshrzGhUtrakHzpE+sGDBbbrHtIdgE3hm8g2ZlsqPCGEEKLUuafd0g8dOsTy5csJDw9Hp9Plee+3334rlsBEwWz9/HDr/xiJS5cRO/dbKrfIv/emZUBL3LXuxGfGc+D6AdoGtrVwpEIIIUTpUOQenqVLl9K2bVtOnTrFqlWr0Ov1/Pvvv2zZsgU3N7ciXWvHjh307t2bwMBAVCoVq1evvus527Zto2nTpmi1WmrUqMHChQuL+hHKBa8xY8HGhrQ9e8g4fjzfNjZqG/NWE4v+u/Mu90IIIUR5VuSE5/333+fzzz9nzZo12NnZ8cUXX3D69GkGDRpE5cqVi3SttLQ0GjVqxNdff12o9mFhYfTs2ZNOnTpx7NgxJk+ezJgxY1i/vuJNvbarFITbo48CEPvN3ALbjag3Ao1Kw+5ruzkRc8JS4QkhhBClSpFXWnZycuLff/8lJCQELy8vtm3bRmhoKKdOneKhhx4iMjLy3gJRqVi1ahV9+/YtsM3UqVNZu3YtJ0+eNB8bMmQIiYmJrFt35z2mcpXVlZbzo7t0iQuP9ASjkaq/rcS+Xr18203fNZ0/LvxBh0odmNN5joWjFEIIIe7f/f7+LnINj4eHBykpKQAEBQVx8uRJQkNDSUxMJD09vcgBFMXevXvp0qVLnmPdunVj8uTJBZ6TlZVFVlaW+XVycnJJhWdxdiEhuD7yCMl//kns3G+p9NWX+bYb13Acf178k+1Xt/Nf3H/U88o/MRJCCEtSFIWUrGziUnXEp2URm6ojLlVHui4bo6JgMJLz1fQwP1cUjMZb3lcUFHPbG8eNioICoICCgqKY3lMUUAAl503z8ZxjSk58YDouiqamrwszHq1v7TDyKHTCc/LkSRo0aED79u3ZuHEjoaGhDBw4kOeff54tW7awceNGOnfuXJKxcv36dfz8/PIc8/PzIzk5mYyMDBwcHG4754MPPmDmzJklGpc1eT89juQ//yRl40ayzp1DW7PmbW2quFbhkaqP8OfFP/nu+Hd88dAXVohUCFERpOtMCUxcmo641Kycr6bn8Wk6YnOPp+qIT9OhMxitHbIoARk6g7VDuE2hE56GDRvSokUL+vbty8CBAwGYPn06tra27Nmzh/79+/P666+XWKD3atq0aXlWik5OTiY4ONiKERUvbc2auHTtSsqGDcR++x1Bn36Sb7uxDcey9uJatlzZwpn4M9T2rG3hSIUQpUGm3kB0chYxqZnEperIzDaiyzaSlW1Al/Pc9NqIznDT85vb3HJcl20kLSfRydAX/Redk50GL2ctXs52eDnZ4aS1QaNSoVarbnxVk+eYRp33fbXqpvdvOa7CVDahynmOKvf4jWOqnNfc1F6tunFc1tUtGg9HO2uHcJtCJzzbt29nwYIFfPDBB7z33nv079+fMWPG8Oqrr5ZkfHn4+/sTFRWV51hUVBSurq759u4AaLVatFqtJcKzGu9nnyFlwwaS//4b7wnj0Vatelubam7V6B7Snb8v/c13/3zHZx1lCxAhygtFUUjOzCYmJZPo5CyiU7KIznkek5qVcyyT6JQsUjJLfk0urY0a75wExtPJDi8nLd65z29KbLyctXg52WFvK1vfiJJX6ITnwQcf5MEHH+Srr75i+fLlLFy4kA4dOlCjRg1Gjx7NiBEj8Pf3L8lYadOmDX/99VeeYxs3bqRNmzYlet/Szr5uXZw7diR12zbivv+BwA/ez7fduIbj+PvS32y8vJFzCeeo6XH78JcQonTJNhi5npzJtYQMIpIyiEjMJCo5M08SE5OSRVZ24YeGtDZqfF21eDtrsbfRoLVVY6dRY2djemhtNGhznttp1Dee3/T+re852GnwdjIlM452GtlqSJQ6RZ6ldbPz58+zYMECfvrpJ65fv0737t35448/Cn1+amoq58+fB6BJkyZ89tlndOrUCU9PTypXrsy0adO4du0aixaZ1pAJCwujQYMGjB8/nlGjRrFlyxYmTZrE2rVr6datW6HuWZ5mad0s4/hxLg0eAhoN1devw65SpXzbvbjtRTZe3kj3kO7M6jDLwlEKIW6VrssmIjGDqwkZXEvMMCU2iTeeX0/OxFjIf6Vd7G3wddHi62KPr6s2z3OfnOc+Llpc7W0kIRFlzv3+/r6vhAdMa+n88ssvTJs2jcTERAyGwo/fbtu2jU6dOt12fMSIESxcuJCRI0dy6dIltm3bluecF154gf/++49KlSrxxhtvMHLkyELfs7wmPADho0aTtmcP7oMHEzBzRr5tzsSfYcCaAahQsbrPaqq5V7NskELcB6NRITY1i8ikTCKTMnK+ZhKRmMH1nOeJ6TrsbNTY22qwtzX1VGhtNdjnHNOa3zP1VNjb5j2uvem5nUYFeeo8VKgAtbqAeg9urhMxvVbn5BXxaTpTEpOb1CSZviak6+/6uW01KgLcHAhydyDQ3QF/txvJy81JjQwNifLMagnPjh07mD9/PitXrkStVjNo0CBGjx5N69at7+VyFlOeE570Q4e4POxJVLa2VN+4AdsChhgnb53M5vDN9KzWkw8f/NDCUQqRP6NRIS5NdyORScwgMjmTyMQbyU1UciZ6Q/mbIuyitSHIw5TMBLk75HleycMBH2ctarX0yIiKzaLr8ERERLBw4UIWLlzI+fPnadu2LV9++SWDBg3CycmpyDcXxcuxeXMcmzcn/dAh4n6ch//r0/Nt93TDp9kcvpm/w/7mmYbPEOIWYtlARYVkNCpEp2RxJSGdqwnpXInPMH+9ltNDU5gpymoV+LrYE+BuT4CbPQFuDje+utvj4WiH3mAkU28gU2+aWZSpN73Oys49bnqepTeQmXMsS28kM9uQp53eYFrb5ea1WcjzWsFozLtmi3LTei+5xxUFXB1sCfJwoJL77YmNm4NtyX3jhRBAEXp4evTowaZNm/D29mb48OGMGjWK2rXL3tTm8tzDA5C2Zw/ho0aj0mqpsWkjNj4++babuHki265u49Hqj/LeA+9ZOEpRHimKQkxqFlcTMrgSn87VBFNCk/s6IvHuCY1KBT7OWgLcHQhwNSU1gW4O+LvZE+huSmp8XbTYaIq8K44QooyzWA+Pra0tv/76K7169UKjkXHi0sqxTRscGjUi4/hx4hYsxO+Vl/Nt93Sjp9l2dRtrL67l6YZPU9m1aPugiYolU2+4sZBcqo7YVNOquNcSb/TUXE3IuOtMIY1aRaC7PZXcHank4UCwp+lrJQ9HAt3t8XWxx85GkhkhRPG776Llsqa89/AApGzbxtVnnkXl6EiNzZuw8fDIt92zm55l17Vd9KvRj7fbvW3hKIU1GYwKCek3VsC9efXbOPMS/zdWyU3NKtzaLWoVpuJaD1PtSbBH3sTG39VeemeEEPfE4ntpidLPuUMHtPXqkvXfKeL/9z98C9hr7JlGz7Dr2i7WXFjDuIbjqOSS/1R2UTbk7kuUuz5LTM76LDEpWea1WqJTTKvrxqfrKOqfOnYaNd7ONxaO83SyMxfVVvJwJNjDEX836aERQpROkvCUQyqVCu9nnuHapOdJ+PkXvEaNQpNPNtzIpxFtA9uyJ2IP807O4602b1khWnE3hpyp2DE3r557SxKTu5puURafU6lMy7+bVrw1JTLeOavf5q6S6+1sWiXXy9kOZ62s3SKEKLsk4SmnXLp0QVuzBlnnzhP/88/4PPdcvu2eafQMeyL2sPr8asaFjiPAOcDCkQpFUUhI13MlPp3w+HSu3DSDKTw+nYjEjCJNxXaxt8mzPkvu89yF50yJjBYPR1sZXhLli0EPujTQp5u+6tJAMWBaFEmV81V90/ObvqrUtx+DW9qrQa3JOaYGlcb03m3H1De1LeQfCYqS8zCaYlaMpofxpuc3P3KPA6htQGNr+mp+bmtaMEqYScJTTqnUaryefoaIKVNI+N8iPIePQON8+9IBTXyb0Mq/Ffuv72feyXm83rr0bQBbHmToDDmJTE5SE59hfn0lPp20u+wsrFaBt7PWtGKu802JjGveZMbbWYuDnUwqEGWQPgMSLpkeabE5iUtO0qJLB13q7cmM+XXOewadtT9F/m5NhFTq2xMbpSR2jVfdlAjZgsYm/+dqG9NrVEBO4nXr1/yOkZug5fNeQCMY/FMJfKZ7JwlPOebaozuxc+agu3SJ62/PJPDDD1Hlk/E/3ehp9l/fz2/nfmNM6Bj8nUp2T7TyzGhUOHU9mX0X4/nnaqI5uYlNzbrruX6uWoI9HAn2zHnkFPsGezri72qPRhaeE2WZokB6PCSEQXzYTV8vmZ6nRBbfvVQasHMGO0fT8wJ/iRsLeI/825iTk5t6Vwr12YszoVHl7UFSFDBm5/Rk3XZjUxJojUTQ2c/y97wLSXjKMZVGg9/rr3Pl6adJ/mMNGjd3/F6bdlsdRgv/FjTza8bhqMMsOLmAaa2mWSnissdoVDh9PYV9F+PYdzGO/WHxJGXkv1WAi70NlT0dc5IaByp7OlIp53UlDwfZFkCUfYZsSL56I6FJuHTT88uQlXzn87Wu4BECLv5g55TzcAZbx5teO+W8zklo7JzA1inv+xq7wg8l3Q9FuWXI6dahqDsMUZmHwfIZAsv3eG7vUAGfy5hzH4MejHrTfQx6UzJk1Jv+25if57xvfp7znqIUMNyXz7G7DQ/aOZf897+IZFp6BZC0Zg0RL78CgPfECfiMH39bm32R+xi7YSx2ajvW9V+Hj2P+CxZWdEajwpmovAlO4i17ITnZaWhR1ZMWIZ5U9XYyJzlujrKabokz5Eyf15TTv+WMRrh6AHzqgIO7taMxSbwCe76Ecxsh6YrpF+eduAaZkhqPquCZ89WjKnhWBQcPyyQqokySaenirtx698aQmETUe+8R+9UcNK5ueD45LE+bVv6taOLbhKPRR1nw7wJeafGKlaItXYxGhbPRKey7EMe+i/HsD4u7bbNHRzsNLUI8aV3NizbVvWgQ6Fo6i4Fz/wJU25SeXypGIyRehviLpjoMfUZOXUZGziPtlmPpOY8MU12H/qaHLt30F6uNPTQcBK2eBb961v6ExSdsB6yfDtf/Mf313HQEtH4W3IOtE0/cBdj1GRxfmjfJ0WhzEpoQUxLjUfXGc/cqYGtvnXhFhSc9PBVIzJyviZ0zB4DAWR/j1rt3nvf3XNvD05uexl5jz9/9/8bbwdsaYVqV0ahwLjo1Tw9OfFre8W9HOw3NQzxpXc2TNtW8aBDkhm1xJji6dIg9a3rEnIaYM5AaldPtnNMdnvs8d+zeaLj7a3L+V7dzAa/q4F0LvGuCVw3Tc6/qYOtQfJ/jZkYjJIVD9GmIOWX6TNGnTJ9Rn14y9wSo1glaPwc1upTdGSux52Djm3DmL9NrleZGvYZKAw36Q9uJENDQMvFEn4Kdn8LJlTfqUqp2gDbjwa8BuASU3e+1KNWstlt6WVWREx5FUYh6730Sfv4ZNBoqzfkKl06d8rw/7K9h/BP7DyPrj+Sl5i9ZMVrLyDYYORWZwoFL8RwIi+PgpYTbEhwHWw3NQzzMPTihxZXgZCZBTE5SE3vGlATEnIHEcMzJiUWpTL0FXjVNiZB3zRvPXQIK1ytkNJqGNWJOmx7mBOesqbcmPxo78KxuGqKxdTDVZ9g6mp7bOeUcczDVadz1mKPpvvvmwuk/b/xC9qoBrZ6Bxo+b2pYF6fGw7UM4NM+UuKo00GI0dJgKEcdgzxemXp9c1TpC20lQ/aGS6cGLOAY7P4FTa24cq9kN2k+B4JbFfz8hbiEJTxFV5IQHQDEaiXj1VZL/WINKq6Xyjz/g2KKF+f0dV3cwfvN4HGwcWNd/HZ72nlaMtvhl6g0cv5LIwUvxHLiUwOFL8eYp4UHEMMhmG1o1eHq4E+DtRbC/N5V8fbBxcCm4cNLG7s43TYu7kQDc3Gtzp1kpjl6mOg2f2uBdG9wqmaaXqjSmv57VNjnPbUwFjWpN3tcqzY3jN7dVqSA1GuLO5fQinb/xPDOp4HjsnHN6gmrm9AbVAM9qkBZj+os/5nTO1zN3Tmy8aoJvHfCpa/psvnVNQx4lUXOTcAkO/ABHFt0olrV3g2YjoeU40/e0NMrOggPfw45ZN/6b1OoBD78NPrXyto04Bnu+gn9X3ej18Qs19fg0eMz0M3O/wvebYjm/MeeACuo9Cg++ZJp6LISFSMJTRBU94QFQ9HquTnqe1K1bUTs7U2XR/7CvZ6p1UBSFIWuH8F/cf4xuMJrJzSZbN9j7lJKp5/DlBA6ExXPwUjzHryTdtmO3i72G570O8WTiXLSG1KLfRG2bM1vkltkkitGUSKTHFXyuS4DpF79PHVMikZvkOFl4OFFRTGufmBOhcxB33vQ84VLRptSqbU2JkU8dU0LjU9uU4HhWs04xcVYKHFts6vVJCDMdU2mgXh/TcFdwizufbymKAv/9DpveMn3PwZS8dHvX1HtzJwmXTZ/vyKIbCadrJVONT7MRoHUpeixhO0yJzqWdpmMqNYQOhAdeNCWtQliYJDxFJAmPiTEzkytjxpJ+6BAaT0+q/PIz2qpVAdgavpVJWyfhaOPI+v7rcbd3t26wRRCbmsXBsPicIap4TkUmY7zlJ9zHRUvLEE9ahHjQxh9qHXwd1ek/TW8GNYdKzXMWMku/fWGz3AXQ9OlFW9vCvXLeHhufOqa/1u3diu/Dl5RsnSlRuDURig8DJ5/be2w8qxVPz0JxMxrg7HrY982NX+Jg+m/e+llTAmStuK8ehvWvwZV9ptfO/tD5DWg01NRLV1jp8XBoPuz/DtKiTce0btD8KdOQnutdVlJXFNNsqx2zTLPBwJTANh4K7Sab6ryEsBJJeIpIEp4bDCkpXB4xgqz/TmETGEDI4sXY+vujKAqD/hzE6fjTjGs4jolNJlo71AKlZmWz+VQUey/EceBSPBdjbh9OqeLlSIsQT1qGeNKyqidVvBxNaxGdWQd/TDT9YlDbQMdppn/UC9sLkbuMfZ6kKHcV2FRTr0juMFBZqRupKK6fgH3fwonlNxJX1yBoOdY0+8nRQkO5ieGw+W04scL02sYB2j1vGpLS3sc6JvpM+GeZabgr7pzpmNrWNHut7URTYnozo9FU87RjlmkWGJhmWzUbYaoLstZMMCFuIglPEUnCk1d2XByXnxiG7tIl7KpVo8ovP2Pj4cHmy5uZvG0yzrbOrOu/Djdt6emJ0BuM7Dgbw6qj19h0KopM/Y3hFpUKavu50DJnHZyWVT3xc71lGmxWiumv6SOLTK996sBj30s9QkWUGm3qETn4o6keCUxJR+Ohpmntt9bMFJfMZNOU7r3fgCELUJkKqh96HVwDi+8+RiOcXWdaJyd8743jNbuaEpnKbeDf30yzrmJOm96zdTIVR7eZAC6lb7VcUXFJwlNEkvDcTh8RwaXHnyD7+nXsGzSg8sKFqJwcGLBmAOcSzvFso2d5rnH+m49aiqIoHAlPYNXRa6z9JzLPWjjVfJx4uK4fLat60ryK550X+Lu8F1Y9bVr7BZVpKu1Db8jaIBVddpZpmvXebyDqxI3jQc1Ma8e4Bt70CDJ9dfYvek2SIRuOLoIt70F6rOlYyIPQ9V0IbFxsHydfVw6aEp9TazDPAtS6QVbSjeetnjYN71mqh0uIIpCEp4gk4clf1sWLXH5iGIaEBBxbtSL4++/YGLmNKdun4GLrwvoB63GxK2LhYzE4H53K78eusfrYNa7EZ5iPeztrebRRIP2aBNEgyPW27TJuk50FW9+H3V8ACrgFQ9+5UPXBkv0AomxRFLi0y1QAfOYv7rg8gEpt2i/IJSBvIuQaZKqVcQ0El8AbyfS5TbBh+o2eFK8a8PA7ULuHZReCjLsAe7+GY79AdiY4eJoS/5Zjy0ZNmaiwJOEpIkl4CpZx4iThI0ZgTE/HuUtnAj//jP5rB3Eh6QITGk/g6UZPWySO6ORM/jgewepj1zh57cbeO052Gro18Kdv4yDaVvcq/GrGUf/Cb+Mg6qTpdaPHoceH8o+7uLOESxBxFJIjbn+kRNx9C4Vcjl6mn7X4i6bXDh6merHmo6xb3J0Wa/p/olILqTETZYIkPEUkCc+dpe3bz5Vx41B0Otz69ePY6LZM3T0NVztXNgzYgJNtyfzDmJqVzbqT1/n92DV2n481z6yyUatoX8uHvk2CeLiuHw52RZixYjSY/pLd8o6pMNXRC3p/AXV73/1cIe7EaDQNSSVfuykRugbJkXmPZd/olURtaxoyaj/FlPQIIYpE9tISxcqpdSuCPv+Mq5OeJ2nVKpq6uhJSuwqXUi6z5PQSxoSOKbZ73an4uGlld/o2CaJnaABeztqiXzzhMqx+Fi7vNr2u1R16fylFmKJ4qNXg7Gt6BDbJv42iQGZiTo9QpKk4vrQudihEBSA9PCJfiatWEzltGgBxw7vzbNAmPLQerOu/Dkdbx/u6dlK6nhVr/uTE6VOcyPThiuKLHhuqeTvRt0kQfRoHUsXrHnuSFMVUm/D3q6BLMc046f4BNB1eejbMFEIIUWTSwyNKhHu/vhiTk4j64EO8Fq1j8KPeLKufwPIzyxnZYOQ9XdNoVPhj12Hst77JGCWn50ULRjToXYOx86uFSl8TLlaHpBqmok7XwMInKqkxsOZ5OLPW9Dq4NfSba1oITwghRIUmCY8okOeIERiSkoj9Zi6PrYnjikrFAvsFDKo9qMi9PMcvx3Jo+QcMSv0FF1UGBtSku9XEOf0qan0a2uRLkHwJzm3Ie6Kto2l1V68atz8c3G+0O/0XrJlkWktFbQudXjMt4FaUVWqFEEKUW5LwiDvynjgRQ2ISCYsXM3GNwkfaWObVmlfo1Zfj03Qs/205Hc99yGj1FVBBtGsoHoO+wqVSE9MQVEqkabuCuPOmKbNx501bGCRcMq1gfP2E6XErR29T4mPnBBc2m4751oN+30FAw+L7JgghhCjzpIZH3JViNBLxylSS//yTLBt48yktc8b+QWXXygWeYzAq/LbjCHbbZtKH7QCkaVwxPPQWrm1GmYo+78agNxUfm5Ohmx637TSugrYToNPrsoigEEKUQ1LDI0qcSq0m8IP3yY6Phz17eHpNFp+EfsiXXb/Jt/2hizHsX/Epw9L/h5sqHYDoWkPw7ftB0VZw1diCdw3T41ZZqRCf0xuUeAVCHjBt+imEEELkQ3p4RKHpo6M536sXJKew/AE1Hd/6hg7BHczvR6dk8stvq+h84SMaqsMAiHOpg9uAL7Gp0spaYQshhCgH7vf3dyGXqhUCbH19CZoxA4DH9hj5ZfXbZBmy0BuM/LTlKNs+eYLnLz5LQ3UYGWpn0h76AK8X9kiyI4QQwupkSEsUiesjj5Cwfh3p6zfSf1kE79X+ErejSYxMX4iXKgWA+BqP4dn3I9OibEIIIUQpID08osiCZsxE7+ZE5Vhw/mUBj+u+wUuVQqJzDYwj1uI5bIEkO0IIIUoVSXhEkWRlG1h4+BJhDbwB6LlfYaHOm4yOM3F/YR/qqg9YOUIhShdFpyPq41kkrl5t7VCEqNBkSEsU2p5zMWz59RvGZc7HNziRU9U8UV+0p9UmDcdGNqaNNXd+FqKUivvf/4ifPx+VrS3O7dtj41mEmYpCiGIjPTzirgxp8Wxe9C4uP3Xh9azP8FUlkuJUhZrvf0W6pyMBCfDvu6+iN+itHaoQpYo+MpLYb+YCoOj1JP32m5UjEqLikoRH5M9ogPObyFwyAuOsWnS+OItQ9SV0Ki1Z7V/D5YWD2DTuRfD7HwDQbm8Sfy5/38pBC1G6RH30MUpGBmoXFwASli5DMRqtHJUQFZMkPCKvuAuw+W2YHQo/98f+zGps0XNaqcyJBq9iN+U/tA9NBRstAL4du5LQwzTt3Hv2MqKiwqwZvRClRtqePaSsWwcaDZV//AG1qyv6q1dJ27XL2qEJUSFJwiNMqxYf/Rnm94CvmsLOTyH5GomKEwuzu/Kc8+fYPLeH0AHTwMn7ttNbvvMV8V52eCcp7H/tGSt8ACFKF0Wn4/o77wLg8fjjODRqhHu/vgAkLF5ixciEqLgk4amoFAUu74HVz8EnteD38RC+B0Wl5rh9C8brJtEq62tONnqdTyeNoIafS4GXsnF2we3t1zECNXeHc3TVj5b7HEKUQvGLFqELC0Pj7Y3PxAkAuA8eAkDq9u3orl6zZnhCVEiS8FQ0SddgxyxTT86CHnDsF9CngWd1rjZ9mUdtvqNP4gts1rTlnQHN+WRgIxzsNHe9bIPOAznbrTYA+ve/ICs+tqQ/iRClkv76dWJyCpV9p7yEJmcJfG21qji1bQOKQuLy5dYMUYgKSRKeikCfCSdXwk+Pwef1Ycu7EH8R7JyhyTCUp/7m+0bL6bCvKSdSnKjm48Tq8e0Y1Dy4SLfp8Pa3RHircUnJ5vBUGdoSFVPURx+hpKfj0KwZbn365HnPfYiplydx5UqMOp01whOiwpJ1eMozfSbs+Qr2zoHMxBvHqzwATZ6Auo+SaLBjyorjbDp1BoA+jQN5r18oztqi/2h4uvmTOnUUhld+xGPnv0T88SuBjw4opg8jROmXtmcPKX+vA7Ua/zdeR6VS5Xnf5aGHsPH1JTs6mpQNG3Hr1dNKkQpR8UgPT3l1dj180xq2vmtKdlwrQfuXYdJReGotNH6cY9HZ9PxyF5tORWNno+a9fg2YPbjxPSU7uXr1nMzOh3wAiH77HbJjZWhLVAyKTsf1d98DTIXK9nXq3NZGZWOD+6BBACQsleJlISxJEp7yJj4MFg+BxYMgIQxcAuCxH2HyP/DQ6+BZDUVRWLA7jIHf7uFaYgZVvBz57dm2PNGqym1/kRaVRq2h9WufcskXtKk6zr76AoqiFNOHE6L0il+0CN3Fi2i8vPCZNLHAdu4DB4JGQ8ahw2SeOWvBCPPKPHuWyBkz0F+/brUYhLAkSXjKC30GbH0fvm4FZ/8GtQ20nQQTDkLDgaA2FR4nZ+p57pcjzFzzH3qDQo8G/qyZ+AANgtyKLZQmQS048exDZKtBteuQ7CEkyr28hcpTzIXK+bH188Wlc2cAEpcttUh8t1IMBiKmvEzi0mVce2mKLIYoKgRJeMo6RYHTa+HrlrD9IzBkQdUO8Owe6PoOaG9MJz95LYleX+7i75PXsdWomNG7Ht880RRX++LfA+upPjNY3dG0OOG1d99GHxlZ7PcAMCQnk/T77+guXy6R6wtRGNEff2wqVG7aFLc+j961vcfjQwFIWv07htS0kg7vNkl/rCHrrKl3KePwYRJ++sniMQhhaZLwlGVxF+CXgbD0cUgMB9cgGLgQhv8OPrXNzRRF4ed9l3nsmz2Ex6cT5O7AimfaMrJd1fsewiqIj6MPlZ95nrOBoEnL5Mq0V4t1aCvr3Dki35rBuQ4diZj6KuGjx6DoZS8vYXlpe/eS/NffpkLlN99Apb77P6uOrVphV7UqxvR0kv9cY4EobzBmZhLz5ZcAODRuDED057PRXbpk0TiEsDRJeMoiXTpsfsdUlHx+I6ht4YEXYPwBqN8Pbkpi0rKyeX7pMV5ffRKdwUiXur6snfQAjYPdSzzMxxsM44+hIehsIGvfARKXLbuv6ykGAymbN3N55FNc7P0oicuWoWRkgEqF/upVGToTFpenUHno0HwLlfOjUqnwGGqaop6weIlF69wSfv6Z7MhIbAIDqLxwAY5tWqNkZhLx2nQUg8FicQhhaZLwlCWKAv/9bhq+2vkJGHRQ/SF4bi90mQFa5zzNM/UGnlpwkD+OR6BRq5j+SF1+GN4cd0c7i4Rrq7ZlbK+3+KWj6cfs+kcfoQsPL/J1DImJxM2bx4Wu3bg6fgLp+/aBWo1L165UXvQ//F6dCkDc3G9RZG0TYUHxP/2E7sIFNJ6e+Dw/qUjnuvXti8renqyzZ8k4erSEIszLkJhI7Pc/AOAzaRJqe3sC330XtaMjGUeOEC9DW6Ick4SnrIg9Bz/1g+XDIekKuAXD4J9h2G/gXfO25gajwvNLj3LgUjwu9jYsG9ease2rldgQVkFaB7TG8Fg3/q0MZGQSMe21Qv8VmXnmLJFvvMm5jp2InvUJ+mvX0Li54TV2LDU2baTSl1/g1LIl7oMHY+Pjgz4igsRVq0v08wiRS3/9OjFffwPcvVA5PxpXV1xz1uGx1P5asd99jzE5GW3t2rj17g2AbVAQvq+8AkDM57PJCpMNgEX5JAlPaZeVChvfgm/awMWtoLEzracz/gDU7Z1n+CqXoii89cdJ1v8bhZ2Nmh+GN6d5iKcVgjeZ0vJl5j/qRIadqUAyflHBf0Uq2dkkb9jA5eEjCOvTh8QVK1AyM9HWqUPAe+9SY/s2fF96EdvAQPM5ant7vMaOBSD2O+nlEZZhLlRu0gS3vn3ufkI+PIaYipdT1q8nOy6uOMO7je7qNRJ+/hkwJWgqzY0tY9wHD8KpbRuUrCwiZWhLlFOS8JRWigInf4M5LWD3bDDqoWY3eG6faT0dO8cCT/1663l+3heOSgVfDG5M62pelos7HwHOAfRr/zSLHjL9uEV//jlZFy7kaZOdkEDsDz9wvmtXrk16nvQDB0CjwaV7d6r8/BNVV/2Ge//+qO3t872H++BB2Pj4kB0RSeJvq0r8M4mKLW3fviIXKufHoUF97Bs2RNHrSVz5WzFHmVfMl1+g6PU4tmmN0wPt8rynUqkIePdd1E5OZBw9esc/SoQoqyThKY1So2HRo/DrU5ASAe5VYOhSeGI5eFW/46nLD17hkw2m6aYzetenR2iAJSK+qxH1R3DuwSocq6oCnY6Iqa+iZGeTeeoUEdOnc75jJ2I+/YzsiEg0Hh54Pf20adhq9uc4Nm9+16E4tVaL17hxAMR+953sUyRKjKLTcf2ddwHwGDIE+7p17+t6Hrn7ay1bVmI9K5mnTpG85k8AfF+aku//T7aBgfhOzRnamj2brIsytCXKF0l4ShujAVaOhrAdYGMPHV+D8fuhdo+7nrr5VBTTVp0AYHyn6oxoG1LCwRaencaOqa1eZW5PNWn2kHnyJBce6UlYv8dIWvkbSlYW2np1CXj/fWps24rvC5OxDShasuY+aCA2fn5kR0aStHJlCX0SUdHF//TzPRcq58f1kR6o3dzQX7tG6s6dxRDh7aI/+RQUBdeePXFoUL/Adu4DB+LUrl3O0Fbh6+2EKAsk4Sltds82JTu2jjB2K3ScCrYOdz3tSHgC4xcfwWBUGNCsElO61r7rOZbWvlJ7GtXtxPyHTT92+vBw0GhwfaQHVRb/QtWVK3F/rB9qrfaerm/q5cmt5fleenlEsdNHRRH79dcA+L70Ehq3+1+hXG1vj3u/fgAkLin+lZdTd+8mbfdusLXF54XJd2yrUqkIeOdt09DWsWPEL/xfsccjhLVIwlOaXDkIW0xrevDILPCrV6jTzkenMmrhQTL1RjrV9uGDx0ItPhursF5p8Qr7Q7Us6KImeXhPamzZTNBnn+HYtGmxxOw+cCA2/v5kX79O4ooVxRCxEDdEf/QxxvR0HBo3xq1f32K7rseQwQCk7tiB7urVYruuYjQS/emnAHg+PhS7SpXueo5tYCC+OUs9xHzxBVkXLxZbPEJYkyQ8pUVmEqwcBYoBGgyAxk8U6rSo5ExGzD9AYrqeRsHufP1EU2w1pfc/a7BrME+FjuLvFmpeq3mUOOfiXXBNbWeH99OmWp64777HmJVVrNcXFVfavv0k//XXfRcq58cuJASntm1BUe57gc6bJa9dS9Z/p1A7O+P1zDOFPs99wACcHngARacjsghLSQhRmpXe34wViaLAmsmm7SHcq0Cvz/Kdbn6r5Ew9I+Yf4FpiBtW8nVgwsgWOdjYlH+99Gh06mhDXEKLToxm9fjQx6THFen23/v2xCQggOzqaxOXSyyPun6LXc/3ddwBTb4x9vcL1vhZF7v5aib+uLJbhWGNWFjGfzwbAa+xYbDw8Cn2ueWjL2ZmM48eJX7jwvuMRwtok4SkNjv4M//5m2uF8wHywv3tdQFa2gXGLDnH6ego+Llr+N6olnk6WWUH5fjnYOPBD1x8Icg4iPCWcsRvGEp8ZX2zXz9PL87308oj7F//Tz+jOX0Dj4YHP88+XyD2cO3bExt8fQ0ICKevX3/f1EhYvQR8RgY2fH57Dnyzy+bYBAeZVzGO++PK2pSSEKGsk4bG2mLPwt2kqKJ2mQ6Xmdz3FaFR4cdlx9l2Mx1lrw8KnWhDsWfC6PKWRv5M/P3b9EV9HXy4kXWDchnEkZSUV2/XdH3sMm8AAsmNiSFy2vNiuKyoefVQ0sXPmAOA7pXgKlfOjsrHBfdBAABLus3jZkJxM3LffAuAzaSJqh7tPfMiPW//+OD34IIpOR4TM2hJlnCQ81qTPhF9HgT4dqnaAdpPveoqiKLz953+sPRGJrUbF9082o35gyfwDXNIquVRiXtd5eNl7cSbhDM9sfIZUXWqxXFtlZ4f306aahdgfvseYmVks1xUVT/THOYXKjRrhljObqqS4DxgANjZkHDlC5pkz93yduB9+wJCUhLZmDdz69r3n65iHtlxcyDz+D/ELFtzztYSwNkl4rGnTWxB1Ahy94LHvoRBFkN9uv8jCPZcA+HRQY9rW8C7hIEtWiFsIP3T9AXetOyfjTjJ+83jS9enFcm33fn2xDQzEEBNbrIWgouJI23+A5LVrQaXCr5gLlfNj6+uLS5cuACQsubf9tfSRkcT/bxEAPi++mGcLiXuKyd8fv1dfBSDmy69kaEuUWZLwWMuZv2G/qcuZvt+Ci/9dT/n18FU+WncagDd61ePRRoF3OaNsqOlRk+8f/h4XWxeORB9h0pZJZGbff4+Mys4Or2dze3l+xJiRcd/XFBWHotdz/Z23AXAfMhiH+gUv2FecPIaaipeT/liDIbXoPZ4xX36FotPh2KIFzh07FktMbo/1w6lDe9PQ1rTXULKzi+W6QliSJDzWkBwJq58zPW/9HNTqetdTtp6JZurKfwB4un01Rj9QtSQjtLi6XnWZ+/BcHG0c2X99Py9sewGd4f5nqrj37YttUBCG2FgSlkovjyi8+J9/MRcq+5ZQoXJ+HFu2wK56dZT0dJL++KNI52aeOUvS6tUA+L6c/xYS90KlUhHwds7Q1j//ECdDW6IAxqwsdFeukBVW+rYmkYTH0owG+G0sZMSDf0PoMuOupxy7kshzP5tWUe7XJIip3euUfJxW0MinEV93/hp7jT27ru3ilR2voDfq7+uaKltbvHN6eeJ+lF4eUTjpR44S88UXAPi+9CIad3eL3VulUt3YX2vJEhSl8GtVRX/6CSgKLt2749CwYbHGZevnh9+0aQDEfvkVWefPF+v1RemmGAzoo6PJOHGSlC1bSFiyhOgvviDitemEjxnLxd6PcrZVa840asyFh7tyfebb1g75NiqlKP83lQPJycm4ubmRlJSEq6ur5QPY8QlseQdsneDpHeBd447Nw2LT6D93D/FpOh6s6c28ES2wsynfeereiL1M2DwBnVFHj5AefPDgB2jU916HoOj1XHikJ/orV/B95RW8Rj1VjNGK8ibr3DkuDXsSY1ISTh3aEzx3bonX7tzKkJLCufYdUDIyqPLzTzg2v/vszbR9+wkfORJsbKi+9k/sqlQp9rgUReHqM8+Sun079qGhhCxZjMqm9K/9JQqm6PUYEhPJjk8gOzaG7KhosqOjyY6OQh8dfeN1bCwUcpaeSqvFsXlzKs/7sVhjvd/f36XiJ/Xrr79m1qxZXL9+nUaNGvHVV1/RsmXLfNsuXLiQp57K+wtLq9WSWRZm4Vw5AFvfNz1/ZNZdk53olEyGz99PfJqO0CA35g5rVu6THYA2gW34vNPnPL/1ef6+9Dd2Gjvebvc2atW9fXaVrS3ezzxD5PTpxP34Ix5DBqN2LFvT+IVl6CMiCB8zFmNSEg6NGlHp888tnuwAaFxccOvVi8QVK0hYvOSuCY9iNBL9yScAeAweXCLJDph6n/zfnsnFXr3JPHGCuHnzzWteCetTFAUlPZ3shAQMCQkY4uPJjs95nhBvOh5vOm5ISCA7IQFjcnLhb6BWY+PtjY2fHza+vtj6+WLj64uNb97XalfXUrm9kdUTnmXLlvHiiy/y7bff0qpVK2bPnk23bt04c+YMvr6++Z7j6urKmZumbJbGb+xtMhLh19E3bR3x+B2bp2TqeWrBQa7EZ1DFy5H5I1vgrLX6fy6LaV+pPR+3/5iXt7/M7xd+x97Gnumtpt/zf2u3Po8S+9136MPDSViyBK/Ro4s5YlHWZSckED5mLNlRUdhVr06lb+daNTH2GDqExBUrSN64Eb/YWGy8C56RmbJuHZknT6J2dMT7uWdLNC5bPz/8XnuNyGnTiJ0zB+dOHbGvVatE71nRKTod2bGx6KOiyI6OMffAZEdHkx0TS3bijURGuZdVulUqNO7u2Hh7mZIXPz9sfH2wzUlschMaG2+v+571Z01WH9Jq1aoVLVq0YE7Owl5Go5Hg4GAmTpzIqzlTIW+2cOFCJk+eTGJi4j3dzypDWopiWm/n399MW0c8s/OOqynrso2MWniQXedj8Xa2Y+Wzbani5WSZWEuZtRfXMm3nNBQUnqz3JC83f/mek57EVauJnDYNjYcHNTZtRO1UMb+n4nbG9HQuP/UUmcf/wcbfn5Ali7ENCLB2WFwaPISM48fxmTwZ72eezreNotNxoWcv9Feu4D1pIj7PPVficeUZ2mrQgJClS2Ro6x4oRqOpFyY6+rZkRh8dbXodFYUhvmgr0au0WjSenth4eKDx8EDj6YnGwx0bT080Hjc/z3nP1bVMJDJlekhLp9Nx+PBhpuUUwgGo1Wq6dOnC3r17CzwvNTWVKlWqYDQaadq0Ke+//z71C5gympWVRdZNWwskF6X7rrgc/alIW0fM2xXGrvOxONppWDCyZYVNdgB6VuuJzqDjzT1v8tN/P2GvsWdS00n3dC233r2I/XYu+svhxC9ejPfYscUcrSiLFL2eq5Mnk3n8HzRublT+8YdSkewAuA81JTwJy5fhNXZMvr+UEpYuQ3/lChofb7xGjrRIXKahrbe52Ls3mSdPEvfjvAITsopOURSyY2LIOnuOrLNnyTp7Fl1YmCmhiYmBwk7xt7XF1sfH1NNy05CSxtv7pkTGAxtPD1QODmVj5MPCrJrwxMbGYjAY8PPzy3Pcz8+P06dP53tO7dq1mT9/Pg0bNiQpKYlPPvmEtm3b8u+//1KpUqXb2n/wwQfMnDmzROIvlJgz8LdpPxoeev2uW0dk6g3M23URgBmP1ie0UtlcRbk49avZj0xDJu/vf58fTvyAvY094xoWvW5AZWOD97PPEvnqNOLnzcdj6ONonCtuMilMf2FHTJ9O2o6dqOztqfTtXLQ17lxbZ0muPXoQ/cGHZEdEkrp9By4PdcrzviElhdi5cwHwmTDRokNwtn6++E9/jYiprxLz9dc4P9Spwg9tGdPSyDp/nsyzZ28kOGfOYLjTiIRKhcbbC1sf35uSGZ+chCZ3SMkXjbu7VerJypMy1wfZpk0b2rRpY37dtm1b6taty3fffcc777xzW/tp06bx4osvml8nJycTHBxskVhNW0eMNm0dUa0jtL37Wh4rDl8lNlVHkLsD/ZoElXyMZcTQOkPJys7i08Of8tXRr9BqtIyoP6LI13Hr1Yu4ud+iu3yZhMWL8R4nvTwVWfSsT0j+Yw1oNATN/hzHJk2sHVIeaq0Wt/79iZ8/n4SlS25LeOJ+nIchIQG7atVw7/+YxeNzffRRktetJ3XrViJefZWAd97Bvl69ct+7oGRnowsPN/fYZJ49S9aZs+ivXMn/BLUau8qV0daqZXrUqIFtgL8pufHyQmVra9kPUEFZNeHx9vZGo9EQFRWV53hUVBT+/ndfeRjA1taWJk2acL6ANSG0Wi1arfa+Y70nN28d0e+7u24dkW0w8v0O07Lt49pXw1Yj2fzNRjYYSaYhk6+Pfc0nhz5Bq9EypM6QIl1DZWOD9/jniHhlKvHz5uHxuPTyVFRx8+ab94YKeO9dXIppVeLi5jFkMPHz55O2cxe6K1ewy/mDTR8VRfz//geA74svWKWGRqVS4T9zBhePHCHrv1Nc6j8A2+BgXLt1xaVbd+wb1C/TyY+iKGRHx5gSm3PnyDpzhsxzZ9Gdv1BgcbDGxxv7mrVuJDe1aqGtUR21vb2Foxe3smrCY2dnR7Nmzdi8eTN9cza4MxqNbN68mQkTJhTqGgaDgRMnTvDII4+UYKT34B62jvjzn0iuxGfg5WTHoOYW6oUqY55u+DRZhix+PPEj7+1/D61GS7+aRdvQ0bVnT2LnfosuLIyEn3+W2oMKKHH1aqJnzQLA9+WXcb+PDTZLml3lyjg98ABpu3aRuGwZvlOmABA7Zw5KZiYOTZvi3Lmz1eKz9fWl8rx5xH3/Pak7dqC/coW4H+cR9+M8bAMDcenWDdduXbFv1KhUJz+G5GSyzp8399pknT1H1rlzGJKS8m2vcnBAW7Mm2lo1sb8pubHx9LRw5KKwrD5La9myZYwYMYLvvvuOli1bMnv2bJYvX87p06fx8/Nj+PDhBAUF8cEHHwDw9ttv07p1a2rUqEFiYiKzZs1i9erVHD58mHr16t31fhaZpZUcAXPbmVZTbv0cdP/grqcoikL32Ts5E5XClK61mPBQzZKJrRxQFIWPD37Mz6d+RoWKDx/8kEeqFS3hTVrzJxEvv4zazY0amzehcXYuoWhFaZOybRtXx08AgwHPp57Cb+or1g7prlK2bOHqc+PRuLtTY/s29FeucPHRPmA0UmXxYhyblo6hOGNaGqk7d5K8fj2p27aj3LSyuU1AAK5dH8alWzccGje2Wj2KMSsL3cWL5l6bzLNnyTp3nuzIyPxPUKuxCwm5kdzUro22Vi1sK1WSmhoLK9OztAAGDx5MTEwMb775JtevX6dx48asW7fOXMgcHh6O+qYfqoSEBMaOHcv169fx8PCgWbNm7Nmzp1DJjkUYDfDbuCJtHQGw5XQ0Z6JScNba8GSbkBINsaxTqVS80uIVsgxZrDi7gtd2vYZBMdC7eu9CX8P1kR7Ezp2L7uJFEn76Ce9nS3btkvLIkJqK2tGxTP2jn370KNcmvwAGA259HsX35SnWDqlQnDt0wCYggOzISFLWryf573VgNOLycJdSk+wAqJ2ccO3eHdfu3TFmZJC6cycp6zeQunUr2Tm7uMf/bxE2vr64dO2Ka7euODRtWuxTohVFwZiaSnZ0NFkXLpiGo3J6bHSXLxe4YrBNQADamjVMPTY1a6KtVQu7atVQW6ssQhQrq/fwWFqJ9/AUceuIXAPm7uHQ5QSebl+NaY/ULf64yiGjYuSN3W/wxwXTBosPV3mY11q9hrdDwQu03Szpz7VETJmC2tXV1Mvj4lKS4ZYbxowMYubMIX7h/7ANDMRj6FDcH+tn0f2m7kXW+fNcemLYjS0j5swpU8Wisd9+S8zsL7Dx9yf7+nXQaKi2Zg3aaqV/I2FjVhZpu3aZen62bMV40y7wGh9vXB9+GJeu3XBs3uyOtUhKdjbZ8fFkx8SQHRODITY253ms+Vh2zjHlpuVIbqV2c8M+p8fm5kJijTW2GxKFdr+/vyXhKU7h+2FBD9Nqyn2+gSZPFOq0A2HxDPpuL3YaNbumdsLXVYrbCstgNDD3+FzmnZhHtpKNq50rr7R4hUerP3rXegHFYODio33QXbhgsQXbyrq0AweIfOMN9JfD8xxX2dvj1rsXHk88gX2d0re5rT4ykktDHyf7+nUcGjWi8oL5ZW57keyYGM51esi8bov7kMEEzJhh3aDugVGnI23PHlLWrSdly5Y8WxtoPD1xefhhtNWrmxKX3IQm56shPh6MxkLfS+3snHd2VE6vjY2vT6muJxL5k4SniEos4clIhG8fhKRw09YR/X+EQv4P9dSCA2w9E8PQlpX54LHQ4oupAjkTf4Y3dr/BqfhTALQLasdbrd8iwPnOC8gl//UX1158ydTLs2mj/IVXAENqKtGffELi0mUA2Pj54ff6dAyJiST8/AtZN2314tC8GZ5PPIFLly6logclOyGBy8OeRHfhAnbVq1Pl55+w8fCwdlj35NqLL5L819+oHB2psX4dNj4+1g7pvig6HWn795O8bh2pmzYXWCCch1qNjZcXGh9vbHx8THs7+fjkPM/56uONjbc3ageHkv8QwmIk4SmiEkt4ji+FVU/nbB2xC+wLd+3/IpJ55MudqFWwdUrHCr2q8v3KNmbzv3//xzfHvkFn1OFo48gLzV5gUO1BBW48qhiNhPXpQ9a583hPmIDPhPEWjrr0S92xg8i3ZpiLOt0HDcL35SnmIUBFUcg4coT4n38mZeMmcw+EjY8P7kMG4zFokNV+MRvT0wl/ahQZx4+Xqi0j7lXmmbNcmzQJz6eewmPIYGuHU6wUvZ60AwdI2bgRQ0LiLcnMjeRG4+lZJrZBEMVPEp4iKtEhrbPrwdEbKjUr9CkTlxxlzfEIejcK5Kuhpaf4sCwLSwpjxp4ZHIk+AkBT36bMbDuTELeQfNsnr1vHtckvoHZxMdXySC8PYOoZif7wQ5J+N9VI2QYHE/DOOzi1blXgOfqoKBKXLSdh+XIMsbGmg7a2uHbtiscTT+DQpLHFhhIUvZ4r48eTtmMnajc3Qn75uVStoiyEKBpJeIrIKpuHFuByXBqdPtmGUYG1kx6gfqBsI1FcjIqRZWeW8fnhz8nIzkCr0fJc4+cYXm84Nuq8RZGK0UhY335knT2L93PP4TNp4h2vrSgKxqSkGzUGsXFkx+YWUMaaj2M04NqzF+6DB5WpIRRFUUhZv57r77yLIS4O1Go8hw/H5/lJhR4iUHQ6kjdsJOGXX8g4etR83L5ePTyeeALXno+U6EJsitFI5LRpJP3+Byp7eyovmF/qVlEWQhSNJDxFVJoSntdWnWDx/nA61vZh4VMtrRpLeRWRGsHMvTPZE7EHgHpe9Xi77dvU9qydp13y+g1ce/551M7OVJrzFYakZLLjYm9LYrJjTccUvb7QMai0Wtz69MFzxHC01asX6+crbvroaKLeecc0NAXY1ahO4Hvv4dCo0T1fM+Pff0n4ZTHJf/5pXp1W4+aG+8ABuA8Zil2l4t9CJerjWcTPnw8aDZW+nlNqV1EWQhSeJDxFVFoSnujkTB74aCs6g5Fl41rTqpqX1WIp7xRF4fcLv/PxwY9J0aVgo7JhdOhoxjUch53GztTGaCSs32N5im/vRu3mZqoxuPnh423avdjLm+zYWBJ++onM//4zn+P0wAN4jhiB0wPtStUsEUVRSPptFVEffWSaNWNjg/e4sXg98wxqO7tiuUd2QgJJK1eSsHgJ+ogI00GVCudOnfAYMhjboCBUdnamh61t3udF+F7FzZtvXkU54MMPSvUqykKIwpOEp4hKS8Lzwd+n+G77RZpV8eDXZ9qUql9+5VVMegzv7X+PzeGbAajuVp23271NQ5+GAKTt20/EK6+g0mrzTWByZ37YeJuOFSYRUBSFjEOHiF+0iJRNmyHnfze76tXxHD4ctz6PWn2PHd3Va1x/6y3Sdu8GwL5+fQLefw/72rXvcua9UQwGUrdvJ+HnX0jbs6dwJ9naos5Ngm5Nhm5+rlGTtmcvAL4vT8Fr9OgS+QxCCMuThKeISkPCk5Shp92HW0jNymbeiOZ0rutnlTgqIkVR2HB5A+/vf5/4zHhUqBhWbxgTm0zEwaZkp7Dqrlwh/qefSPp1Jcb0dAA07u64Dx6Mx+OPY+vnW6L3v5ViNJLwy2KiP/8cJT0dlVaLz8QJeI4cabGNKLMuXiRh8RJSNm/GmJ6Ootebhr1yZnrdq7KyZYQQovAk4Smi0pDwfL31PLPWn6G2nwt/P/8garX07lhaYmYiHx/8mDUX1wBQybkSM9vOpGVAyddSGVJSSFy5koSffkZ/7ZrpoI0Nrj164DliBA4N6pd4DFkXw4h8/XUyjphmsjk0b0bAO++grVo6Vu1VjEZz8qPodHd8bsxzXI+Nrw9ObdqUqS0vhBB3JwlPEVk74cnQGXjgoy3EpemYPbgxfZsUf8GmKLwdV3fw9t63iUqPAmBArQG81OwlnO1KfjNRxWAgZfNm4v+3iIzDh83HHZo3w3P4cFw6dy7+PYb0euLmLyD2669RdDrUjo74THkJjyFDJEEQQpRqkvAUkbUTnkV7L/Hm7/9SycOBbVM6YqORXzLWlqpLZfaR2Sw7Y1pFOMQ1hM87fk4ND8ut2ZJx4iTxixaR/Pff5uEc26AgPJ4chvuAAfnu5p67QaIhKRljchKG5GQMiUkYkpMwJidjSEo2HUtOwpiUjCEpiezoaLJjYgBTAXXAzBnYBknSLYQo/SThKSJrJjx6g5GOs7ZxLTGDd/rUl13RS5mD1w/y2q7XuJ52HQcbB2a0mcEj1R6xaAz6qGgSFi8mcelS8zL7aicnnNq2wZieYUpgkpIwJiVhSEkp0r5CudRubvhNexW3Pn2kWF4IUWZIwlNE1kx4fjtylReXH8fb2Y5dUx/C3laWRy9tEjITmLpjKnsjTTN9Hq/zOFOaT8FWY9k9oYwZGST9sYb4RYvQXbhwx7YqrRaNqytqN1c0rm5oXF3RuLnd8toVtZsbGlc3tLVq5ttjJIQQpZkkPEVkrYTHaFTo/sUOzkal8nK32ozvJEvcl1YGo4Fvjn/D9/98D0Ajn0Z80uET/J38LR6LYjSStncvugsXULvmJDBurqYEJ+e5tae1CyGEJUjCU0TWSng2/hfF2EWHcNHasHvaQ7jaW38XaXFn269sZ9quaaToUvC092RW+1kWmcUlhBDidvf7+1sqZi1AURS+2XYegCdaV5Fkp4zoENyBZb2WUdujNvGZ8YzdOJZ5J+ZRwf5GEEKIckESHgvYHxbP0fBE7GzUjHogxNrhiCIIdgnm50d+pk/1PhgVI7OPzGby1smk6FKsHZoQQogikITHAr7ZZio6HdS8Er4uUm9R1tjb2PNOu3d4s82b2Kpt2XJlC0P+HMLZhLPWDk0IIUQhScJTwk5eS2LH2RjUKhj3YOneKVsUTKVSMbDWQBb1WESAUwDhKeE8sfYJ1lxYY+3QhBBCFIIkPCVs7nZT707vRoFU9nK0cjTifjXwbsCyXstoG9iWTEMmr+16jXf3vYveoLd2aEIIIe5AEp4SFBabxt8nIgF4poP07pQXHvYefNP5G55p9AwAy84sY+S6kVxPu27lyIQQQhREEp4S9P2OCxgVeKiOL3UDrLNRqSgZGrWG8Y3H83Xnr3Gxc+Gf2H8YtGYQ+yL3WTs0IYQQ+ZCEp4REJWey8rBpJ+xnO0rvTnnVvlJ7lvdaTl3PuiRkJfD0xqf58cSPGJWib/kghBCi5EjCU0Lm7QpDZzDSIsSDFiGe1g5HlKBKLpVY1GMR/Wr0w6gY+eLIFzy/9XmSdcnWDk0IIUQOSXhKQFK6nl/2XQbguY6yhURFYG9jz9vt3mZGmxnYqe3YdmUbg9YM4ssjX7Lr2i5SdanWDlEIISo0G2sHUB4t2nuJNJ2BOv4udKztY+1whAX1r9WfOl51eHHri1xLvcYPJ36AE6BWqantUZumfk1p6tuUpn5N8Xbwtna4QghRYcheWsUsQ2eg3UdbiE/T8cWQxvRpHFTs9xClX4ouhY2XN3I46jBHoo5wNfXqbW2quFYxJz/NfJtRyaUSKpXKCtEKIUTpJ5uHFlFJJzwLd4cxY81/VPZ0ZMtLHbDRyKihgOj0aI5EHTElQNFHOJdwDoW8/+v5OPiYe4Ca+TWjpkdN1Cr5+RFCCJCEp8hKMuHRG4x0nLWNa4kZvNu3AcNaVynW64vyIykrieMxx809QCfjTpJtzM7TxsXWhca+jWnq15Q2gW2o51lPeoCEEBWWJDxFVJIJz6+HrzJlxXG8nbXsmtoJe1tNsV5flF+Z2ZmciD3BkagjHIk+wrHoY6Rnp+dpU8+rHkNqD6FH1R7Y28iebEKIikUSniIqqYTHaFToOnsH56NTmdq9jqy9I+5LtjGbMwlnOHz9MIejDrPr2i50Rh0Ablo3HqvxGINqD6KSSyUrRyqEEJYhCU8RlVTCs/7f6zz902Fc7G3Y8+pDuNjbFtu1hUjITGDV+VUsO72MiLQIAFSoeLDSgwypPYR2Qe2k3kcIUa5JwlNEJZXwRCdn8uOuMFztbZjwUM1iu64QNzMYDey8tpOlp5eyO2K3+Xhll8oMqj2IvjX64qZ1s2KEQghRMiThKaKSnqUlhKVcSrrEsjPL+P3876ToUwCw19jTs1pPhtQZQh3POlaOUAghio8kPEUkCY8ob9L16awNW8vS00s5m3DWfLyxT2OG1hnKw1UexlYjQ6xCiLJNEp4ikoRHlFeKonA0+ihLTy9l4+WNZCumae5e9l70r9WfgbUG4u/kb+UohRDi3kjCU0SS8IiKICY9hl/P/cqKMyuIyYgBQKPS8FDlh+hcuTNBzkEEOAXg7eCNRi3LJwghSj9JeIpIEh5RkeiNeraEb2Hp6aUcijp02/s2ahv8HP0IdA4kwCmAQOdAAp0C8XfyNx+z09hZIXIhhMhLEp4ikoRHVFTnEs7x69lfOZNwhsjUSKLSozAohrue5+3gTaBTIAHOAQQ4BdxIjJwDqeZWDRu17EEshCh5kvAUkSQ8QphkG7OJzYglIjWCiLQIIlMjzV8j00yPjOyMO17D18GXfjX78VjNxwh0DrRQ5EKIikgSniKShEeIwlEUhcSsxDxJUERqhPnrlZQrpOpTAdMiiO2C2jGw1kDaV2ovvT5CiGInCU8RScIjRPHQGXRsubKFX8/8yv7r+83HfR186VuzL/1r9pdeHyFEsZGEp4gk4RGi+F1OvszKcyv5/fzvxGfGAzd6fQbUGkD7Su2xVctaQEKIeycJTxFJwiNEydEb9Gy+splfz/7K/sgbvT4+Dj70rdGX/rX6E+QcZMUIC0dRFM4knCFVl0ojn0aycKMQpYAkPEUkCY8QlhGeHM6v5369rdenbVBbBtYcSPvg0tfrk5iZyNqwtfx27jfzqtVOtk60DWxL+0rteSDoAbwdvK0cpRAVkyQ8RSQJjxCWpTfoTbU+Z39lX+Q+8/HS0utjVIzsi9zHqnOr2By+Gb1RD4Cd2g5nO2dzsgamhK2BdwPaV2pP+0rtqetZF5VKZa3QhahQJOEpIkl4hLCe8ORwVp5byerzq//f3t0HRXHffwB/Hwd3HnggD94DjyIgkig45UkiEC00oKlT0E5N6zQkzcQxQceESR9MY9CZdpgk09Zp6uhkpk3/aDQpHSWpnSQjhAcxqBVjjI0yys8EEA5EI9yBPN739wdhZQUqVx4WlvfLubm9735397Pf2Qzv7O7dys76pASmID04HQnmBEQuipyRX39udjSj5FoJSq6VoKWrRWqP8YtBblQuNoRvgFFnxJe3vkRlUyWqmqrw5a0vZeswGUxIC05DenA6VltXw9PDc9rrJpqvGHhcxMBDpLzxzvoAgFFnxHdM30G8OR7x5njE+MdM2aWvvsE+fNLwCY5ePYrTLachIKRtPh7+ODZFbUKMf8y4y7d1t+Fk00lUNVWhpqVG9jtFOjcdEq2JSA8aOvsTbAyekpqJaAgDj4sYeIhml8bORnz89cc413oOn7V+hu6Bbtl8g7sBcYvjEG+OR4I5ASsXr4Req3dpG3W363Ds2jEc/7/j6OjtkNqTLcnIjcpFRmgGFrgvcGmdfYN9OGc7h8qmSlQ2VeKG44ZsfoRPBNJD0pEelI5VplX8bSKiSWLgcREDD9HsNeAcQN3tOpxrPYfa1lqcbzsvCygA4OHmgZUBK6UAFGeKg5eH16h12fvs+PD6hzh69Sj+c+s/UrvJ04ScyBzkROYgxBgyJXULIXC947oUfi60XZA9tsNb543UoFSsC1mHNUFrYNQZp2S7RPMJA4+LGHiI5g6ncKL+Tj1qW2ulENR+t13WR6vRIsYvZigAWRJgcDfg/Wvv48TXJ9Az2ANg6CGp60LWITcyF48EPjLt9wh19Hbg0+ZPUdVUhZM3TspCm7ubOxLNiVgXug5rg9fCutA6rbUQqQUDj4sYeIjmLiEEGuwNqG2tlV73X0oaKcInArlRudgYsRF+C/xmsNJ7Bp2DuNh+EeWN5ShvKMdXnV/J5sf4xWBtyFqsC1mH5X7L+a0vonEw8LiIgYdIXVocLahtGwo/52zn8E3vN8gMzURuVC5iA2JnXYC43nEdFY0VqGiswGdtn0k3TgOAxcuCtcFD4SfRksgfPCQagYHHRQw8RDRb3O65jaqmKpQ3lI/61peXh5d0309qUCp89D4KVkqkPAYeFzHwENFs1DPQgzMtZ1DeWI6Kxgrc6rklzXPXuCPeHD906St03Zx4PAfRVGPgcREDDxHNdk7hxKX2S1L4uXbnmmx+tG80MsMykRmaiYhFEbPush3RdGDgcREDDxHNNY2djUM3PTeW43zbeTiFU5q3xHuJFH4e8n+I4YdUi4HHRQw8RDSXfdPzDSoaK1DaUIqa5hrp2V8AYPWyIiM0A98L+x7iFsfNyCM6iGYKA4+LGHiISC0cfQ5UNVWhtKEU1TeqZTc9+y/wR0ZoBjLCMoa+8TXLnkxP5CoGHhcx8BCRGvUM9OBU8ymUfV2GisYK2Pvt0jxvnTfWhqxFZmgmUgJTXH6MBtFswMDjIgYeIlK7/sF+nLWdxYmvT6C8sVx6Mj0w9Gyy9OB0ZIZmIi04bczHchDNRgw8LmLgIaL5ZNA5iPNt51HWUIbSr0vR2t0qzdNqtFjsuRgmgwkmT9PQtOe304bFMHuasdhzMRZ6LOTN0KQ4Bh4XMfAQ0XwlhMCl9ksobShF6delaLA3TGg5g7tBCkEjA5HJyySFJZOnCTqtbpr3gOYzBh4XMfAQEQ2Fn7buNrR2t+Jm90203W1DW/e913Cbvc/+4JUB0LnpkGBJQGpQKlKDUrHEewnPCtGUYuBxEQMPEdHEdfd3o/1u+70gdPfmvZA0oq13sFe2XPDCYKQGpSItOA2JlkQY3A0K7QGpBQOPixh4iIimlhAC1zuu4+SNk6i+UY1zrecw4ByQ5uu1eiRYEpAWlIa0oDSEeocqWC3NVQw8LmLgISKaXt393TjTckYKQC1dLbL5ocZQpAWnITUoFQnmBH5NniZEFYHnwIEDeOONN2Cz2RAXF4c333wTSUlJ4/YvLi7Gnj178NVXXyEqKgqvvfYaNmzYMKFtMfAQEc0cIQTq79Sj+kY1qm9Uo7atVnb2Z4F2ARItidLlrxBjiILV0mw25wPPe++9hyeffBKHDh1CcnIy9u/fj+LiYtTV1cFkMo3q/+mnnyI9PR1FRUX4/ve/j8OHD+O1117D+fPnsWLFigduj4GHiEg5Xf1dON1yGiebhs7+jPyaPDD0bLAVAStg1Bmx0GPh0Ltu6N3o8e30t+8LPRbC4G7gzdHzxJwPPMnJyUhMTMSf/vQnAIDT6URISAh27tyJX/3qV6P6b9myBV1dXTh+/LjUtnr1aqxatQqHDh164PYYeIiIZgchBK7euYrqG9U42XQSF9ouYEAMPHjBEdw17vDSeWGhx0J467ylIDQcmPRaPdzd3KF108Jdc+9danNzl7WPbBvuo9VoZY/m0Gg0GP438vPQB9xrh0YKYyP7jvw8alozdjvuy3TjLX//OsbrM2bbGLlxzOUmsH6dVocAQ8DoFU7CZP9+u09pNS7q6+tDbW0tdu/eLbW5ubkhMzMTNTU1Yy5TU1ODgoICWVtWVhZKSkrG7N/b24ve3nvfHujs7Jx84URENGkajQbLfJdhme8y/GzFz2Dvs+NMyxk02hth77PD3meHo98BR58D9n47HH0OOPodUrtTODEgBtDR24GO3g7cwA2ld4m+Fbc4Dn/b8Dely5BRNPC0t7djcHAQZrNZ1m42m3HlypUxl7HZbGP2t9lsY/YvKirCvn37pqZgIiKaNkadEZlhmRPqK4TA3YG7smB0/7ujz4G+wT4MikH0O/sxKAYx4BzAoHMQA2JANj3oHJo3cvr+5Ya3KyBkdQx/FhAYvmgiIDDcTQz/GzlvjP2RpjF6erz5969qzHU/YHvj9ZmI8S4SzcYfoVQ08MyE3bt3y84IdXZ2IiSEN8UREc1lGo0Gnh6e8PTwhNnL/OAFaN5TNPAEBARAq9WitVV+01prayssFsuYy1gsFpf66/V66PX6qSmYiIiI5iQ3JTeu0+kQHx+PsrIyqc3pdKKsrAwpKSljLpOSkiLrDwAnTpwYtz8RERGR4pe0CgoKkJeXh4SEBCQlJWH//v3o6urC008/DQB48sknERQUhKKiIgDArl278Oijj+J3v/sdHn/8cbz77rs4d+4c3nrrLSV3g4iIiGYxxQPPli1bcPPmTbz66quw2WxYtWoVPvroI+nG5IaGBri53TsR9cgjj+Dw4cN45ZVX8PLLLyMqKgolJSUT+g0eIiIimp8U/x2emcbf4SEiIpp7Jvv3W9F7eIiIiIhmAgMPERERqR4DDxEREakeAw8RERGpHgMPERERqR4DDxEREakeAw8RERGpHgMPERERqR4DDxEREame4o+WmGnDPyzd2dmpcCVEREQ0UcN/t//XB0TMu8Bjt9sBACEhIQpXQkRERK6y2+3w8fFxebl59ywtp9OJ5uZmGI1GaDSaKV13Z2cnQkJC0NjYyOd0zSCOuzI47srguCuD466MkeNuNBpht9sRGBgoe6j4RM27Mzxubm4IDg6e1m14e3vzPwgFcNyVwXFXBsddGRx3ZQyP+/9yZmcYb1omIiIi1WPgISIiItVj4JlCer0ehYWF0Ov1Spcyr3DclcFxVwbHXRkcd2VM5bjPu5uWiYiIaP7hGR4iIiJSPQYeIiIiUj0GHiIiIlI9Bh4iIiJSPQaeKXLgwAEsWbIECxYsQHJyMs6ePat0Saq2d+9eaDQa2Wv58uVKl6U6VVVV2LhxIwIDA6HRaFBSUiKbL4TAq6++CqvVCoPBgMzMTFy9elWZYlXkQeP+1FNPjTr+s7OzlSlWRYqKipCYmAij0QiTyYScnBzU1dXJ+vT09CA/Px/+/v5YuHAhNm/ejNbWVoUqVoeJjPvatWtHHfPbt293aTsMPFPgvffeQ0FBAQoLC3H+/HnExcUhKysLbW1tSpemag8//DBaWlqkV3V1tdIlqU5XVxfi4uJw4MCBMee//vrr+OMf/4hDhw7hzJkz8PLyQlZWFnp6ema4UnV50LgDQHZ2tuz4P3LkyAxWqE6VlZXIz8/H6dOnceLECfT39+Oxxx5DV1eX1OfFF1/EP//5TxQXF6OyshLNzc3YtGmTglXPfRMZdwB49tlnZcf866+/7tqGBE1aUlKSyM/Plz4PDg6KwMBAUVRUpGBV6lZYWCji4uKULmNeASCOHTsmfXY6ncJisYg33nhDartz547Q6/XiyJEjClSoTvePuxBC5OXliR/84AeK1DOftLW1CQCisrJSCDF0fHt4eIji4mKpz+XLlwUAUVNTo1SZqnP/uAshxKOPPip27do1qfXyDM8k9fX1oba2FpmZmVKbm5sbMjMzUVNTo2Bl6nf16lUEBgZi6dKl2Lp1KxoaGpQuaV65fv06bDab7Nj38fFBcnIyj/0ZUFFRAZPJhOjoaDz33HO4deuW0iWpTkdHBwDAz88PAFBbW4v+/n7ZMb98+XKEhobymJ9C94/7sHfeeQcBAQFYsWIFdu/eje7ubpfWO+8eHjrV2tvbMTg4CLPZLGs3m824cuWKQlWpX3JyMv76178iOjoaLS0t2LdvH9LS0nDp0iUYjUaly5sXbDYbAIx57A/Po+mRnZ2NTZs2ITw8HPX19Xj55Zexfv161NTUQKvVKl2eKjidTrzwwgtYs2YNVqxYAWDomNfpdFi0aJGsL4/5qTPWuAPAT37yE4SFhSEwMBAXL17EL3/5S9TV1eHo0aMTXjcDD81J69evl6ZjY2ORnJyMsLAw/P3vf8czzzyjYGVE0++JJ56QpleuXInY2FhERESgoqICGRkZClamHvn5+bh06RLvDZxh4437tm3bpOmVK1fCarUiIyMD9fX1iIiImNC6eUlrkgICAqDVakfdpd/a2gqLxaJQVfPPokWLsGzZMly7dk3pUuaN4eObx77yli5dioCAAB7/U2THjh04fvw4ysvLERwcLLVbLBb09fXhzp07sv485qfGeOM+luTkZABw6Zhn4JkknU6H+Ph4lJWVSW1OpxNlZWVISUlRsLL5xeFwoL6+HlarVelS5o3w8HBYLBbZsd/Z2YkzZ87w2J9hTU1NuHXrFo//SRJCYMeOHTh27Bg++eQThIeHy+bHx8fDw8NDdszX1dWhoaGBx/wkPGjcx3LhwgUAcOmY5yWtKVBQUIC8vDwkJCQgKSkJ+/fvR1dXF55++mmlS1Otl156CRs3bkRYWBiam5tRWFgIrVaLH//4x0qXpioOh0P2f1DXr1/HhQsX4Ofnh9DQULzwwgv4zW9+g6ioKISHh2PPnj0IDAxETk6OckWrwH8bdz8/P+zbtw+bN2+GxWJBfX09fvGLXyAyMhJZWVkKVj335efn4/Dhw3j//fdhNBql+3J8fHxgMBjg4+ODZ555BgUFBfDz84O3tzd27tyJlJQUrF69WuHq564HjXt9fT0OHz6MDRs2wN/fHxcvXsSLL76I9PR0xMbGTnxDk/qOF0nefPNNERoaKnQ6nUhKShKnT59WuiRV27Jli7BarUKn04mgoCCxZcsWce3aNaXLUp3y8nIBYNQrLy9PCDH01fQ9e/YIs9ks9Hq9yMjIEHV1dcoWrQL/bdy7u7vFY489JhYvXiw8PDxEWFiYePbZZ4XNZlO67DlvrDEHIN5++22pz927d8Xzzz8vfH19haenp8jNzRUtLS3KFa0CDxr3hoYGkZ6eLvz8/IRerxeRkZHi5z//uejo6HBpO5pvN0ZERESkWryHh4iIiFSPgYeIiIhUj4GHiIiIVI+Bh4iIiFSPgYeIiIhUj4GHiIiIVI+Bh4iIiFSPgYeI5j2NRoOSkhKlyyCiacTAQ0SKeuqpp6DRaEa9srOzlS6NiFSEz9IiIsVlZ2fj7bfflrXp9XqFqiEiNeIZHiJSnF6vh8Vikb18fX0BDF1uOnjwINavXw+DwYClS5fiH//4h2z5L774At/97ndhMBjg7++Pbdu2weFwyPr85S9/wcMPPwy9Xg+r1YodO3bI5re3tyM3Nxeenp6IiorCBx98ML07TUQzioGHiGa9PXv2YPPmzfj888+xdetWPPHEE7h8+TIAoKurC1lZWfD19cW///1vFBcXo7S0VBZoDh48iPz8fGzbtg1ffPEFPvjgA0RGRsq2sW/fPvzoRz/CxYsXsWHDBmzduhW3b9+e0f0komk05Y89JSJyQV5entBqtcLLy0v2+u1vfyuEGHqS8vbt22XLJCcni+eee04IIcRbb70lfH19hcPhkOb/61//Em5ubtITxAMDA8Wvf/3rcWsAIF555RXps8PhEADEhx9+OGX7SUTK4j08RKS4devW4eDBg7I2Pz8/aTolJUU2LyUlBRcuXAAAXL58GXFxcfDy8pLmr1mzBk6nE3V1ddBoNGhubkZGRsZ/rSE2Nlaa9vLygre3N9ra2v7XXSKiWYaBh4gU5+XlNeoS01QxGAwT6ufh4SH7rNFo4HQ6p6MkIlIA7+Eholnv9OnToz7HxMQAAGJiYvD555+jq6tLmn/q1Cm4ubkhOjoaRqMRS5YsQVlZ2YzWTESzC8/wEJHient7YbPZZG3u7u4ICAgAABQXFyMhIQGpqal45513cPbsWfz5z38GAGzduhWFhYXIy8vD3r17cfPmTezcuRM//elPYTabAQB79+7F9u3bYTKZsH79etjtdpw6dQo7d+6c2R0lIsUw8BCR4j766CNYrVZZW3R0NK5cuQJg6BtU7777Lp5//nlYrVYcOXIEDz30EADA09MTH3/8MXbt2oXExER4enpi8+bN+P3vfy+tKy8vDz09PfjDH/6Al156CQEBAfjhD384cztIRIrTCCGE0kUQEY1Ho9Hg2LFjyMnJUboUIprDeA8PERERqR4DDxEREake7+EholmNV92JaCrwDA8RERGpHgMPERERqR4DDxEREakeAw8RERGpHgMPERERqR4DDxEREakeAw8RERGpHgMPERERqR4DDxEREane/wMPLzGA7mBxeQAAAABJRU5ErkJggg==", - "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": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_1 (InputLayer) [(None, 224, 224, 3 0 [] \n", - " )] \n", - " \n", - " conv1_pad (ZeroPadding2D) (None, 230, 230, 3) 0 ['input_1[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 (Flatten) (None, 100352) 0 ['conv5_block3_out[0][0]'] \n", - " \n", - " dense (Dense) (None, 5) 501765 ['flatten[0][0]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 24,089,477\n", - "Trainable params: 501,765\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(5, activation='softmax')(x)\n", - "\n", - "# create a model object\n", - "model = Model(inputs=resnet.input, outputs=prediction)\n", - "\n", - "# view the structure of the model\n", - "model.summary()\n", - "\n", - "# tell the model what cost and optimization method to use\n", - "model.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": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/_h/ljwht4gd7lb99rm1hm78h7_00000gn/T/ipykernel_38631/4078056843.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.fit_generator(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/25\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-01-07 20:27:50.806255: W tensorflow/tsl/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n", - "2023-01-07 20:27:53.343322: W tensorflow/core/framework/op_kernel.cc:1830] OP_REQUIRES failed at sparse_xent_op.cc:103 : INVALID_ARGUMENT: Received a label value of 11 which is outside the valid range of [0, 5). Label values: 5 8 9 11 4 7 4 11 1 11 5 3 4 3 9 4 3 5 7 9 3 3 5 1 2 1 6 3 3 5 0 9\n" - ] - }, - { - "ename": "InvalidArgumentError", - "evalue": "Graph execution error:\n\nDetected at node 'sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWithLogits/SparseSoftmaxCrossEntropyWithLogits' defined at (most recent call last):\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n return _run_code(code, main_globals, None,\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/runpy.py\", line 86, in _run_code\n exec(code, run_globals)\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel_launcher.py\", line 17, in \n app.launch_new_instance()\n File \"/opt/homebrew/lib/python3.10/site-packages/traitlets/config/application.py\", line 982, in launch_instance\n app.start()\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelapp.py\", line 712, in start\n self.io_loop.start()\n File \"/opt/homebrew/lib/python3.10/site-packages/tornado/platform/asyncio.py\", line 215, in start\n self.asyncio_loop.run_forever()\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n self._run_once()\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/asyncio/base_events.py\", line 1906, in _run_once\n handle._run()\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/asyncio/events.py\", line 80, in _run\n self._context.run(self._callback, *self._args)\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 510, in dispatch_queue\n await self.process_one()\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 499, in process_one\n await dispatch(*args)\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 406, in dispatch_shell\n await result\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 730, in execute_request\n reply_content = await reply_content\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/ipkernel.py\", line 383, in do_execute\n res = shell.run_cell(\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/zmqshell.py\", line 528, in run_cell\n return super().run_cell(*args, **kwargs)\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 2885, in run_cell\n result = self._run_cell(\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 2940, in _run_cell\n return runner(coro)\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/async_helpers.py\", line 129, in _pseudo_sync_runner\n coro.send(None)\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3139, in run_cell_async\n has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3318, in run_ast_nodes\n if await self.run_code(code, result, async_=asy):\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3378, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/_h/ljwht4gd7lb99rm1hm78h7_00000gn/T/ipykernel_38631/4078056843.py\", line 1, in \n r = model.fit_generator(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 2604, in fit_generator\n return self.fit(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/utils/traceback_utils.py\", line 65, in error_handler\n return fn(*args, **kwargs)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1650, in fit\n tmp_logs = self.train_function(iterator)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1249, in train_function\n return step_function(self, iterator)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1233, in step_function\n outputs = model.distribute_strategy.run(run_step, args=(data,))\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1222, in run_step\n outputs = model.train_step(data)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1024, in train_step\n loss = self.compute_loss(x, y, y_pred, sample_weight)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1082, in compute_loss\n return self.compiled_loss(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/compile_utils.py\", line 265, in __call__\n loss_value = loss_obj(y_t, y_p, sample_weight=sw)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/losses.py\", line 152, in __call__\n losses = call_fn(y_true, y_pred)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/losses.py\", line 284, in call\n return ag_fn(y_true, y_pred, **self._fn_kwargs)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/losses.py\", line 2098, in sparse_categorical_crossentropy\n return backend.sparse_categorical_crossentropy(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/backend.py\", line 5633, in sparse_categorical_crossentropy\n res = tf.nn.sparse_softmax_cross_entropy_with_logits(\nNode: 'sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWithLogits/SparseSoftmaxCrossEntropyWithLogits'\nReceived a label value of 11 which is outside the valid range of [0, 5). Label values: 5 8 9 11 4 7 4 11 1 11 5 3 4 3 9 4 3 5 7 9 3 3 5 1 2 1 6 3 3 5 0 9\n\t [[{{node sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWithLogits/SparseSoftmaxCrossEntropyWithLogits}}]] [Op:__inference_train_function_8562]", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mInvalidArgumentError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [7], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m r \u001b[39m=\u001b[39m model\u001b[39m.\u001b[39;49mfit_generator(\n\u001b[1;32m 2\u001b[0m train_ds_r,\n\u001b[1;32m 3\u001b[0m validation_data\u001b[39m=\u001b[39;49mval_ds_r,\n\u001b[1;32m 4\u001b[0m epochs\u001b[39m=\u001b[39;49m\u001b[39m25\u001b[39;49m,\n\u001b[1;32m 5\u001b[0m steps_per_epoch\u001b[39m=\u001b[39;49m\u001b[39mlen\u001b[39;49m(train_ds_r),\n\u001b[1;32m 6\u001b[0m validation_steps\u001b[39m=\u001b[39;49m\u001b[39mlen\u001b[39;49m(val_ds_r)\n\u001b[1;32m 7\u001b[0m )\n", - "File \u001b[0;32m/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py:2604\u001b[0m, in \u001b[0;36mModel.fit_generator\u001b[0;34m(self, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, validation_freq, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[1;32m 2592\u001b[0m \u001b[39m\"\"\"Fits the model on data yielded batch-by-batch by a Python generator.\u001b[39;00m\n\u001b[1;32m 2593\u001b[0m \n\u001b[1;32m 2594\u001b[0m \u001b[39mDEPRECATED:\u001b[39;00m\n\u001b[1;32m 2595\u001b[0m \u001b[39m `Model.fit` now supports generators, so there is no longer any need to\u001b[39;00m\n\u001b[1;32m 2596\u001b[0m \u001b[39m use this endpoint.\u001b[39;00m\n\u001b[1;32m 2597\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 2598\u001b[0m warnings\u001b[39m.\u001b[39mwarn(\n\u001b[1;32m 2599\u001b[0m \u001b[39m\"\u001b[39m\u001b[39m`Model.fit_generator` is deprecated and \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 2600\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mwill be removed in a future version. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 2601\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mPlease use `Model.fit`, which supports generators.\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 2602\u001b[0m stacklevel\u001b[39m=\u001b[39m\u001b[39m2\u001b[39m,\n\u001b[1;32m 2603\u001b[0m )\n\u001b[0;32m-> 2604\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(\n\u001b[1;32m 2605\u001b[0m generator,\n\u001b[1;32m 2606\u001b[0m steps_per_epoch\u001b[39m=\u001b[39;49msteps_per_epoch,\n\u001b[1;32m 2607\u001b[0m epochs\u001b[39m=\u001b[39;49mepochs,\n\u001b[1;32m 2608\u001b[0m verbose\u001b[39m=\u001b[39;49mverbose,\n\u001b[1;32m 2609\u001b[0m callbacks\u001b[39m=\u001b[39;49mcallbacks,\n\u001b[1;32m 2610\u001b[0m validation_data\u001b[39m=\u001b[39;49mvalidation_data,\n\u001b[1;32m 2611\u001b[0m validation_steps\u001b[39m=\u001b[39;49mvalidation_steps,\n\u001b[1;32m 2612\u001b[0m validation_freq\u001b[39m=\u001b[39;49mvalidation_freq,\n\u001b[1;32m 2613\u001b[0m class_weight\u001b[39m=\u001b[39;49mclass_weight,\n\u001b[1;32m 2614\u001b[0m max_queue_size\u001b[39m=\u001b[39;49mmax_queue_size,\n\u001b[1;32m 2615\u001b[0m workers\u001b[39m=\u001b[39;49mworkers,\n\u001b[1;32m 2616\u001b[0m use_multiprocessing\u001b[39m=\u001b[39;49muse_multiprocessing,\n\u001b[1;32m 2617\u001b[0m shuffle\u001b[39m=\u001b[39;49mshuffle,\n\u001b[1;32m 2618\u001b[0m initial_epoch\u001b[39m=\u001b[39;49minitial_epoch,\n\u001b[1;32m 2619\u001b[0m )\n", - "File \u001b[0;32m/opt/homebrew/lib/python3.10/site-packages/keras/utils/traceback_utils.py:70\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 67\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[1;32m 68\u001b[0m \u001b[39m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m 69\u001b[0m \u001b[39m# `tf.debugging.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[1;32m 71\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 72\u001b[0m \u001b[39mdel\u001b[39;00m filtered_tb\n", - "File \u001b[0;32m/opt/homebrew/lib/python3.10/site-packages/tensorflow/python/eager/execute.py:52\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 51\u001b[0m ctx\u001b[39m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 52\u001b[0m tensors \u001b[39m=\u001b[39m pywrap_tfe\u001b[39m.\u001b[39mTFE_Py_Execute(ctx\u001b[39m.\u001b[39m_handle, device_name, op_name,\n\u001b[1;32m 53\u001b[0m inputs, attrs, num_outputs)\n\u001b[1;32m 54\u001b[0m \u001b[39mexcept\u001b[39;00m core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 55\u001b[0m \u001b[39mif\u001b[39;00m name \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", - "\u001b[0;31mInvalidArgumentError\u001b[0m: Graph execution error:\n\nDetected at node 'sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWithLogits/SparseSoftmaxCrossEntropyWithLogits' defined at (most recent call last):\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n return _run_code(code, main_globals, None,\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/runpy.py\", line 86, in _run_code\n exec(code, run_globals)\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel_launcher.py\", line 17, in \n app.launch_new_instance()\n File \"/opt/homebrew/lib/python3.10/site-packages/traitlets/config/application.py\", line 982, in launch_instance\n app.start()\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelapp.py\", line 712, in start\n self.io_loop.start()\n File \"/opt/homebrew/lib/python3.10/site-packages/tornado/platform/asyncio.py\", line 215, in start\n self.asyncio_loop.run_forever()\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n self._run_once()\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/asyncio/base_events.py\", line 1906, in _run_once\n handle._run()\n File \"/opt/homebrew/Cellar/python@3.10/3.10.9/Frameworks/Python.framework/Versions/3.10/lib/python3.10/asyncio/events.py\", line 80, in _run\n self._context.run(self._callback, *self._args)\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 510, in dispatch_queue\n await self.process_one()\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 499, in process_one\n await dispatch(*args)\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 406, in dispatch_shell\n await result\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/kernelbase.py\", line 730, in execute_request\n reply_content = await reply_content\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/ipkernel.py\", line 383, in do_execute\n res = shell.run_cell(\n File \"/opt/homebrew/lib/python3.10/site-packages/ipykernel/zmqshell.py\", line 528, in run_cell\n return super().run_cell(*args, **kwargs)\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 2885, in run_cell\n result = self._run_cell(\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 2940, in _run_cell\n return runner(coro)\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/async_helpers.py\", line 129, in _pseudo_sync_runner\n coro.send(None)\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3139, in run_cell_async\n has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3318, in run_ast_nodes\n if await self.run_code(code, result, async_=asy):\n File \"/opt/homebrew/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3378, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/_h/ljwht4gd7lb99rm1hm78h7_00000gn/T/ipykernel_38631/4078056843.py\", line 1, in \n r = model.fit_generator(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 2604, in fit_generator\n return self.fit(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/utils/traceback_utils.py\", line 65, in error_handler\n return fn(*args, **kwargs)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1650, in fit\n tmp_logs = self.train_function(iterator)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1249, in train_function\n return step_function(self, iterator)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1233, in step_function\n outputs = model.distribute_strategy.run(run_step, args=(data,))\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1222, in run_step\n outputs = model.train_step(data)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1024, in train_step\n loss = self.compute_loss(x, y, y_pred, sample_weight)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/training.py\", line 1082, in compute_loss\n return self.compiled_loss(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/engine/compile_utils.py\", line 265, in __call__\n loss_value = loss_obj(y_t, y_p, sample_weight=sw)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/losses.py\", line 152, in __call__\n losses = call_fn(y_true, y_pred)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/losses.py\", line 284, in call\n return ag_fn(y_true, y_pred, **self._fn_kwargs)\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/losses.py\", line 2098, in sparse_categorical_crossentropy\n return backend.sparse_categorical_crossentropy(\n File \"/opt/homebrew/lib/python3.10/site-packages/keras/backend.py\", line 5633, in sparse_categorical_crossentropy\n res = tf.nn.sparse_softmax_cross_entropy_with_logits(\nNode: 'sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWithLogits/SparseSoftmaxCrossEntropyWithLogits'\nReceived a label value of 11 which is outside the valid range of [0, 5). Label values: 5 8 9 11 4 7 4 11 1 11 5 3 4 3 9 4 3 5 7 9 3 3 5 1 2 1 6 3 3 5 0 9\n\t [[{{node sparse_categorical_crossentropy/SparseSoftmaxCrossEntropyWithLogits/SparseSoftmaxCrossEntropyWithLogits}}]] [Op:__inference_train_function_8562]" - ] - } - ], - "source": [ - "r = model.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": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(r.history[\"accuracy\"])\n", - "plt.plot(r.history['val_accuracy'])\n", - "plt.plot(r.history['loss'])\n", - "plt.plot(r.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": null, - "metadata": {}, - "outputs": [], - "source": [ - "model.save('resnet_2.h5')\n", - "model.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 -}