diff --git "a/Sneakers_Transfer_Learning.ipynb" "b/Sneakers_Transfer_Learning.ipynb" new file mode 100644--- /dev/null +++ "b/Sneakers_Transfer_Learning.ipynb" @@ -0,0 +1,1202 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "authorship_tag": "ABX9TyMy6eJcO6tG5bz/ZoOCzLY4", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "gpuClass": "standard" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Becoming one with data" + ], + "metadata": { + "id": "s6TgLDGj0Tgs" + } + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "FJT3_4AWzvrS" + }, + "outputs": [], + "source": [ + "import zipfile\n", + "\n", + "# Unzip the downloaded file from github or kaggle \"https://www.kaggle.com/datasets/die9origephit/nike-adidas-and-converse-imaged?resource=download\"\n", + "zip_ref = zipfile.ZipFile(\"Sneakers_CNN.zip\", \"r\")\n", + "zip_ref.extractall()\n", + "zip_ref.close()" + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "\n", + "# Walk through directory and list number of files\n", + "print(\"TRAIN---\")\n", + "for dirpath, dirnames, filenames in os.walk(\"train\"):\n", + " print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")\n", + "print(\"TEST---\")\n", + "for dirpath, dirnames, filenames in os.walk(\"test\"):\n", + " print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L-BIxhaw0ATB", + "outputId": "b313a9a6-1ea9-49ca-81e1-8454f60a0da1" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "TRAIN---\n", + "There are 3 directories and 0 images in 'train'.\n", + "There are 0 directories and 237 images in 'train/nike'.\n", + "There are 0 directories and 237 images in 'train/converse'.\n", + "There are 0 directories and 237 images in 'train/adidas'.\n", + "TEST---\n", + "There are 3 directories and 0 images in 'test'.\n", + "There are 0 directories and 38 images in 'test/nike'.\n", + "There are 0 directories and 38 images in 'test/converse'.\n", + "There are 0 directories and 38 images in 'test/adidas'.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Preprocessing Data" + ], + "metadata": { + "id": "CNka9U0d1d1g" + } + }, + { + "cell_type": "code", + "source": [ + "# Setup data inputs\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n", + "\n", + "IMAGE_SHAPE = (224, 224)\n", + "BATCH_SIZE = 32\n", + "\n", + "train_dir = \"/content/train\"\n", + "test_dir = \"/content/test\"\n", + "\n", + "train_datagen = ImageDataGenerator(rescale=1/255.)\n", + "test_datagen = ImageDataGenerator(rescale=1/255.)\n", + "\n", + "print(\"Training images:\")\n", + "train_data_10_percent = train_datagen.flow_from_directory(train_dir,\n", + " target_size=IMAGE_SHAPE,\n", + " batch_size=BATCH_SIZE,\n", + " class_mode=\"categorical\")\n", + "\n", + "print(\"Testing images:\")\n", + "test_data = train_datagen.flow_from_directory(test_dir,\n", + " target_size=IMAGE_SHAPE,\n", + " batch_size=BATCH_SIZE,\n", + " class_mode=\"categorical\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cEymnz7a1l71", + "outputId": "3facc161-d4da-4665-afa2-0008318b41ac" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training images:\n", + "Found 711 images belonging to 3 classes.\n", + "Testing images:\n", + "Found 114 images belonging to 3 classes.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Setting Callbacks" + ], + "metadata": { + "id": "Tf84Dlox1v-U" + } + }, + { + "cell_type": "code", + "source": [ + "# Create tensorboard callback (functionized because need to create a new one for each model)\n", + "import datetime\n", + "def create_tensorboard_callback(dir_name, experiment_name):\n", + " log_dir = dir_name + \"/\" + experiment_name + \"/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + " tensorboard_callback = tf.keras.callbacks.TensorBoard(\n", + " log_dir=log_dir\n", + " )\n", + " print(f\"Saving TensorBoard log files to: {log_dir}\")\n", + " return tensorboard_callback\n", + " " + ], + "metadata": { + "id": "LhzWxCb112ee" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot the validation and training data separately\n", + "def plot_loss_curves(history):\n", + " \"\"\"\n", + " Returns separate loss curves for training and validation metrics.\n", + " \"\"\" \n", + " loss = history.history['loss']\n", + " val_loss = history.history['val_loss']\n", + "\n", + " accuracy = history.history['accuracy']\n", + " val_accuracy = history.history['val_accuracy']\n", + "\n", + " epochs = range(len(history.history['loss']))\n", + "\n", + " # Plot loss\n", + " plt.plot(epochs, loss, label='training_loss')\n", + " plt.plot(epochs, val_loss, label='val_loss')\n", + " plt.title('Loss')\n", + " plt.xlabel('Epochs')\n", + " plt.legend()\n", + "\n", + " # Plot accuracy\n", + " plt.figure()\n", + " plt.plot(epochs, accuracy, label='training_accuracy')\n", + " plt.plot(epochs, val_accuracy, label='val_accuracy')\n", + " plt.title('Accuracy')\n", + " plt.xlabel('Epochs')\n", + " plt.legend();" + ], + "metadata": { + "id": "k6gmZ13mpAo7" + }, + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Creating models using Tensorflow Hub" + ], + "metadata": { + "id": "X579fHUS15Fe" + } + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "import tensorflow_hub as hub\n", + "from tensorflow.keras import layers" + ], + "metadata": { + "id": "DeM4Iedx1_WM" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Models used :\n", + "* Resnet V2 50\n", + "* EfficientNet B0 (version 1)\n", + "* EfficientNet B0 (version 2)\n", + "* MobileNet V2" + ], + "metadata": { + "id": "WJaJre0q2CiA" + } + }, + { + "cell_type": "code", + "source": [ + "# Resnet 50 V2 feature vector\n", + "resnet_url = \"https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4\"\n", + "\n", + "# Original: EfficientNetB0 feature vector (version 1)\n", + "efficientnet_url = \"https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1\"\n", + "\n", + "# New: EfficientNetB0 feature vector (version 2)\n", + "efficientnet_2_url = \"https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_b0/feature_vector/2\"\n", + "\n", + "# MobileNet V2 feature vector\n", + "mobilenet_url=\"https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/5\"" + ], + "metadata": { + "id": "6xagt0Uj2epB" + }, + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def create_model(model_url, num_classes=10):\n", + " \"\"\"Takes a TensorFlow Hub URL and creates a Keras Sequential model with it.\n", + " \n", + " Args:\n", + " model_url (str): A TensorFlow Hub feature extraction URL.\n", + " num_classes (int): Number of output neurons in output layer,\n", + " should be equal to number of target classes, default 10.\n", + "\n", + " Returns:\n", + " An uncompiled Keras Sequential model with model_url as feature\n", + " extractor layer and Dense output layer with num_classes outputs.\n", + " \"\"\"\n", + " # Download the pretrained model and save it as a Keras layer\n", + " feature_extractor_layer = hub.KerasLayer(model_url,\n", + " trainable=False, # freeze the underlying patterns\n", + " name='feature_extraction_layer',\n", + " input_shape=IMAGE_SHAPE+(3,)) # define the input image shape\n", + " \n", + " # Create our own model\n", + " model = tf.keras.Sequential([\n", + " feature_extractor_layer, # use the feature extraction layer as the base\n", + " layers.Dense(num_classes, activation='softmax', name='output_layer') # create our own output layer \n", + " ])\n", + "\n", + " return model" + ], + "metadata": { + "id": "7RaajEUabHT9" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Resnet" + ], + "metadata": { + "id": "Zcywxx0sbQgw" + } + }, + { + "cell_type": "code", + "source": [ + "# Create model\n", + "resnet_model = create_model(resnet_url, num_classes=train_data_10_percent.num_classes)\n", + "\n", + "# Compile model\n", + "resnet_model.compile(loss='categorical_crossentropy',\n", + " optimizer=tf.keras.optimizers.Adam(),\n", + " metrics=['accuracy'])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6J6F8t5ebcnz", + "outputId": "881f05a0-5055-4bc0-941f-66c94e13848b" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:tensorflow:Please fix your imports. Module tensorflow.python.training.tracking.data_structures has been moved to tensorflow.python.trackable.data_structures. The old module will be deleted in version 2.11.\n", + "WARNING:tensorflow:From /usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.\n", + "Instructions for updating:\n", + "Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Fit the model\n", + "resnet_history = resnet_model.fit(train_data_10_percent,\n", + " epochs=5,\n", + " steps_per_epoch=len(train_data_10_percent),\n", + " validation_data=test_data,\n", + " validation_steps=len(test_data),\n", + " # Add TensorBoard callback to model (callbacks parameter takes a list)\n", + " callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\", # save experiment logs here\n", + " experiment_name=\"resnet50V2\")]) # name of log files" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8rs8hNWObeWJ", + "outputId": "6756abd2-abcc-41b6-ab67-7859d812085e" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20230228-152728\n", + "Epoch 1/5\n", + "23/23 [==============================] - 19s 219ms/step - loss: 0.9993 - accuracy: 0.5091 - val_loss: 0.8047 - val_accuracy: 0.6491\n", + "Epoch 2/5\n", + "23/23 [==============================] - 2s 106ms/step - loss: 0.6376 - accuracy: 0.7356 - val_loss: 0.6863 - val_accuracy: 0.7018\n", + "Epoch 3/5\n", + "23/23 [==============================] - 3s 108ms/step - loss: 0.5183 - accuracy: 0.8115 - val_loss: 0.6317 - val_accuracy: 0.7018\n", + "Epoch 4/5\n", + "23/23 [==============================] - 2s 105ms/step - loss: 0.4382 - accuracy: 0.8664 - val_loss: 0.6110 - val_accuracy: 0.7368\n", + "Epoch 5/5\n", + "23/23 [==============================] - 3s 131ms/step - loss: 0.3842 - accuracy: 0.8790 - val_loss: 0.5968 - val_accuracy: 0.7456\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plot_loss_curves(resnet_history)" + ], + "metadata": { + "id": "TWetSQXzl6IJ", + "outputId": "d7b9d426-410f-40ed-d121-c63e7f109496", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 573 + } + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Resnet summary \n", + "resnet_model.summary()" + ], + "metadata": { + "id": "b8eAUnXkpFDm", + "outputId": "c7a2d7cd-0bfa-434f-ddd0-c0fd716a27be", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " feature_extraction_layer (K (None, 2048) 23564800 \n", + " erasLayer) \n", + " \n", + " output_layer (Dense) (None, 3) 6147 \n", + " \n", + "=================================================================\n", + "Total params: 23,570,947\n", + "Trainable params: 6,147\n", + "Non-trainable params: 23,564,800\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### EfficientNet (Version 1)" + ], + "metadata": { + "id": "2OazHC3LwYkF" + } + }, + { + "cell_type": "code", + "source": [ + "# Create model\n", + "efficientnet_model = create_model(model_url=efficientnet_url, # use EfficientNetB0 TensorFlow Hub URL\n", + " num_classes=train_data_10_percent.num_classes)\n", + "\n", + "# Compile EfficientNet model\n", + "efficientnet_model.compile(loss='categorical_crossentropy',\n", + " optimizer=tf.keras.optimizers.Adam(),\n", + " metrics=['accuracy'])\n", + "\n", + "# Fit EfficientNet model \n", + "efficientnet_history = efficientnet_model.fit(train_data_10_percent, # only use 10% of training data\n", + " epochs=5, # train for 5 epochs\n", + " steps_per_epoch=len(train_data_10_percent),\n", + " validation_data=test_data,\n", + " validation_steps=len(test_data),\n", + " callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\", \n", + " # Track logs under different experiment name\n", + " experiment_name=\"efficientnetB0\")])" + ], + "metadata": { + "id": "GXQLzkWbpR7P", + "outputId": "276e1312-04ad-4e28-d8f1-2b4a87995a0d", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving TensorBoard log files to: tensorflow_hub/efficientnetB0/20230228-153030\n", + "Epoch 1/5\n", + "23/23 [==============================] - 16s 229ms/step - loss: 1.0455 - accuracy: 0.4613 - val_loss: 0.8730 - val_accuracy: 0.6579\n", + "Epoch 2/5\n", + "23/23 [==============================] - 2s 96ms/step - loss: 0.7864 - accuracy: 0.7342 - val_loss: 0.7143 - val_accuracy: 0.7807\n", + "Epoch 3/5\n", + "23/23 [==============================] - 3s 126ms/step - loss: 0.6500 - accuracy: 0.8031 - val_loss: 0.6404 - val_accuracy: 0.7895\n", + "Epoch 4/5\n", + "23/23 [==============================] - 2s 96ms/step - loss: 0.5666 - accuracy: 0.8397 - val_loss: 0.5915 - val_accuracy: 0.7807\n", + "Epoch 5/5\n", + "23/23 [==============================] - 2s 94ms/step - loss: 0.5133 - accuracy: 0.8579 - val_loss: 0.5555 - val_accuracy: 0.7982\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plot_loss_curves(efficientnet_history)" + ], + "metadata": { + "id": "wvNKpur7pVxQ", + "outputId": "a2b0255f-7488-4884-8445-c97513b8bcc0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 573 + } + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "efficientnet_model.summary()" + ], + "metadata": { + "id": "8nEtrxpdpl7U", + "outputId": "74e387a8-5bbc-4cc7-e0d4-10dc5df741b6", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " feature_extraction_layer (K (None, 1280) 4049564 \n", + " erasLayer) \n", + " \n", + " output_layer (Dense) (None, 3) 3843 \n", + " \n", + "=================================================================\n", + "Total params: 4,053,407\n", + "Trainable params: 3,843\n", + "Non-trainable params: 4,049,564\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### EfficientNet (Version 2)" + ], + "metadata": { + "id": "uEIZDp0Dwhvg" + } + }, + { + "cell_type": "code", + "source": [ + "# Create model\n", + "efficientnet_2_model = create_model(model_url=efficientnet_2_url, # use EfficientNetB0 TensorFlow Hub URL\n", + " num_classes=train_data_10_percent.num_classes)\n", + "\n", + "# Compile EfficientNet model\n", + "efficientnet_2_model.compile(loss='categorical_crossentropy',\n", + " optimizer=tf.keras.optimizers.Adam(),\n", + " metrics=['accuracy'])\n", + "\n", + "# Fit EfficientNet model \n", + "efficientnet_2_history = efficientnet_2_model.fit(train_data_10_percent, # only use 10% of training data\n", + " epochs=5, # train for 5 epochs\n", + " steps_per_epoch=len(train_data_10_percent),\n", + " validation_data=test_data,\n", + " validation_steps=len(test_data),\n", + " callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\", \n", + " # Track logs under different experiment name\n", + " experiment_name=\"efficientnet_2_B0\")])" + ], + "metadata": { + "id": "bxAHX559poIQ", + "outputId": "1fc75907-3ffb-4a69-e623-c5f4b0d711c8", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving TensorBoard log files to: tensorflow_hub/efficientnet_2_B0/20230228-153311\n", + "Epoch 1/5\n", + "23/23 [==============================] - 11s 189ms/step - loss: 0.9831 - accuracy: 0.5331 - val_loss: 0.8473 - val_accuracy: 0.6754\n", + "Epoch 2/5\n", + "23/23 [==============================] - 2s 91ms/step - loss: 0.7809 - accuracy: 0.6835 - val_loss: 0.7389 - val_accuracy: 0.7368\n", + "Epoch 3/5\n", + "23/23 [==============================] - 2s 104ms/step - loss: 0.6627 - accuracy: 0.7834 - val_loss: 0.6592 - val_accuracy: 0.7895\n", + "Epoch 4/5\n", + "23/23 [==============================] - 2s 98ms/step - loss: 0.5887 - accuracy: 0.8298 - val_loss: 0.6130 - val_accuracy: 0.7807\n", + "Epoch 5/5\n", + "23/23 [==============================] - 3s 107ms/step - loss: 0.5372 - accuracy: 0.8467 - val_loss: 0.5777 - val_accuracy: 0.8246\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plot_loss_curves(efficientnet_2_history)" + ], + "metadata": { + "id": "aAHMXB_ap9vm", + "outputId": "87c667fa-f192-4a4b-c494-cf035cdc1f3d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 573 + } + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEWCAYAAABollyxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAA7Y0lEQVR4nO3dd3hUZfbA8e8hCQkJJZVeEpQmRUpAEAtiQ1FZC01FdAVExfpbd9F1bYsu6+q6uooKKAqKiCiKrqKoYAUlofcOCTUECISQfn5/3AGGkJAJTDKTyfk8Tx5mbpl7csOcufOe976vqCrGGGMCVzVfB2CMMaZ8WaI3xpgAZ4neGGMCnCV6Y4wJcJbojTEmwFmiN8aYAGeJ3hhjApwlehNQRGSeiOwXkVBfx2KMv7BEbwKGiMQDFwIKXFeBxw2uqGMZczos0ZtAchuwAHgHGHp0oYg0EZFPRCRNRNJF5FW3dcNFZLWIHBKRVSLS2bVcReRst+3eEZExrse9RCRVRP4iIruASSISJSJfuI6x3/W4sdv+0SIySUR2uNZ/6lq+QkSuddsuRET2ikin8jpJpuqxRG8CyW3A+66fK0WknogEAV8AW4F4oBEwDUBE+gNPufarjfMtIN3DY9UHooFmwAic99Ik1/OmwBHgVbftpwDhQFugLvCSa/lk4Fa37a4GdqrqYg/jMKZUYmPdmEAgIhcAc4EGqrpXRNYAb+Jc4c9yLc8vss/XwJeq+nIxr6dAC1Xd4Hr+DpCqqo+LSC/gG6C2qmaXEE9HYK6qRolIA2A7EKOq+4ts1xBYCzRS1YMiMgP4XVWfP81TYcxJ7IreBIqhwDequtf1fKprWRNga9Ek79IE2Hiax0tzT/IiEi4ib4rIVhE5CPwIRLq+UTQB9hVN8gCqugP4BbhRRCKBq3C+kRjjNVZEMpWeiNQABgBBrjZzgFAgEtgNNBWR4GKSfQpwVgkvm4XT1HJUfSDV7XnRr8L/B7QCzlPVXa4r+sWAuI4TLSKRqnqgmGO9CwzDeT/OV9XtJcRkzGmxK3oTCP4AFADnAB1dP22An1zrdgJjRSRCRMJEpKdrv4nAn0SkizjOFpFmrnVLgJtFJEhE+gAXlxJDLZx2+QMiEg08eXSFqu4EvgLGuYq2ISJykdu+nwKdgQdw2uyN8SpL9CYQDAUmqeo2Vd119AenGDoYuBY4G9iGc1U+EEBVPwKexWnmOYSTcKNdr/mAa78DwC2udafyH6AGsBenLjC7yPohQB6wBtgDPHh0haoeAT4GEoBPPP+1jfGMFWON8QMi8gTQUlVvLXVjY8rI2uiN8TFXU8+dOFf9xnidNd0Y40MiMhynWPuVqv7o63hMYLKmG2OMCXB2RW+MMQHO79roY2NjNT4+3tdhGGNMpZKcnLxXVeOKW+d3iT4+Pp6kpCRfh2GMMZWKiGwtaZ013RhjTICzRG+MMQHOEr0xxgQ4j9roXWN9vAwEARNVdWyR9U1xBmaKdG0zWlW/dM34sxpnGFaABao6sqxB5uXlkZqaSnZ2sSPCmgAUFhZG48aNCQkJ8XUoxlR6pSZ61zCrrwGX44wTslBEZqnqKrfNHgemq+rrInIO8CXOJA8AG1W145kEmZqaSq1atYiPj0dEzuSlTCWgqqSnp5OamkpCQoKvwzGm0vOk6aYbsEFVN6lqLs7sPP2KbKM4M/QA1AF2eC9EyM7OJiYmxpJ8FSEixMTE2Dc4Y7zEk0TfCOcW7aNSXcvcPQXcKiKpOFfz97mtSxCRxSLyg4hcWNwBRGSEiCSJSFJaWlqxQViSr1rs722M93irH/1g4B1VfVFEegBTRKQdzjjgTVU1XUS6AJ+KSFtVPei+s6qOB8YDJCYm2pgMxpgqITuvgNT9WWzZm8WW9MOEVw/m5vOaev04niT67ThToR3V2LXM3Z1AHwBVnS8iYUCsqu4BclzLk0VkI9ASsDuijDFVwuGcfLamZ7Ft32G2pGexNf0wW/Y6/+48mI37cGOdmkb6LNEvBFqISAJOgh8E3Fxkm23ApcA7ItIGCAPSRCQOZ67MAhFpDrQANnkt+gp04MABpk6dyj333FOm/a6++mqmTp1KZGRkids88cQTXHTRRVx22WVnGKUxxhcysvLYejSR73X+PZrY0w7lnLBtTER1msWE0715DM1iIoiPDadpdDjxMRFEhpdPL7NSE72q5ovIKOBrnK6Tb6vqShF5BkhS1Vk482VOEJGHcAqzt6uquqZLe0ZE8oBCYKSq7iuX36ScHThwgHHjxp2U6PPz8wkOLvk0fvnll6W+9jPPPHPG8flKab+/MYFAVUk/nHv8anyf68rcdYV+ICvvhO3r1w6jWUw4l7SKc5J5TATNYsJpFhNOrbCK7zLs0TtUVb/EKbK6L3vC7fEqoGcx+32MM0Wa1zz9+UpW7ThY+oZlcE7D2jx5bdtTbjN69Gg2btxIx44dCQkJISwsjKioKNasWcO6dev4wx/+QEpKCtnZ2TzwwAOMGDECOD52T2ZmJldddRUXXHABv/76K40aNeKzzz6jRo0a3H777VxzzTXcdNNNxMfHM3ToUD7//HPy8vL46KOPaN26NWlpadx8883s2LGDHj16MGfOHJKTk4mNjS023pLimT17No899hgFBQXExsby3XffkZmZyX333UdSUhIiwpNPPsmNN95IzZo1yczMBGDGjBl88cUXvPPOO9x+++2EhYWxePFievbsyaBBg3jggQfIzs6mRo0aTJo0iVatWlFQUMBf/vIXZs+eTbVq1Rg+fDht27bllVde4dNPPwVgzpw5jBs3jpkzZ3rpr2nM6SksVHYfymZr+olJfMveLLbtyyIz5/jc8tUEGkbWID4mgr7tGxAfE0HTGOeqvGl0ODWqB/nwNzmZXYp5aOzYsaxYsYIlS5Ywb948+vbty4oVK47183777beJjo7myJEjdO3alRtvvJGYmJgTXmP9+vV88MEHTJgwgQEDBvDxxx9z660nzxwXGxvLokWLGDduHC+88AITJ07k6aefpnfv3jz66KPMnj2bt95665TxFhdPYWEhw4cP58cffyQhIYF9+5wvV3//+9+pU6cOy5cvB2D//v2lno/U1FR+/fVXgoKCOHjwID/99BPBwcF8++23PPbYY3z88ceMHz+eLVu2sGTJEoKDg9m3bx9RUVHcc889pKWlERcXx6RJk/jjH//o0d/AmDOVX1DIzoxstrgS+Ta3hL41PYuc/MJj2wZXE5pGh9M0JpxuCdE0cyXyZjHhNI4Kp3pw5RlYoNIl+tKuvCtKt27dTriZ55VXXjl2VZqSksL69etPSvQJCQl07NgRgC5durBly5ZiX/uGG244ts0nnzhzRf/888/HXr9Pnz5ERUWdMr7i4klLS+Oiiy46Fnd0tDMP9rfffsu0adOO7VvaawP079+foCDnqiUjI4OhQ4eyfv16RIS8vLxjrzty5MhjTTtHjzdkyBDee+897rjjDubPn8/kyZNLPZ4xnsrNLyRl//HkvTXd6dGyNT2L1P1Z5BUcr36GBldzNalEcHFLp5nlaEJvUCeM4KDKk8xPpdIlen8RERFx7PG8efP49ttvmT9/PuHh4fTq1avYm31CQ0OPPQ4KCuLIkSPFvvbR7YKCgsjPzy92m1PxNJ7SuPdlL7q/++//t7/9jUsuuYSZM2eyZcsWevXqdcrXveOOO7j22msJCwujf//+1sZvyuxIbgHb9h1N4Eevzp3nOw4codCtJ0vN0GCaxYTTpkEt+rSrT7wrscfHRFC3VijVqgX+PRv2DvNQrVq1OHToULHrMjIyiIqKIjw8nDVr1rBgwQKvH79nz55Mnz6dv/zlL3zzzTenbF4pKZ7u3btzzz33sHnz5mNNN9HR0Vx++eW89tpr/Oc//wGcppuoqCjq1avH6tWradWqFTNnzqRWrVolHq9RI+ceunfeeefY8ssvv5w333yTSy655FjTTXR0NA0bNqRhw4aMGTOGb7/91jsnyAScg9l5x5J30Xbz3QdP7MkSGR5Cs5gIujSL4obOjWkWHU58rJPQYyKqV/kb8CzReygmJoaePXvSrl07atSoQb169Y6t69OnD2+88QZt2rShVatWdO/e3evHf/LJJxk8eDBTpkyhR48e1K9fv8TEW1I8cXFxjB8/nhtuuIHCwkLq1q3LnDlzePzxx7n33ntp164dQUFBPPnkk9xwww2MHTuWa665hri4OBITE48VZov685//zNChQxkzZgx9+/Y9tnzYsGGsW7eODh06EBISwvDhwxk1ahQAt9xyC2lpabRp08bLZ8pUFqrK/qy8Y00sW9z+3ZaeRfrh3BO2j6sVSnxMOBecHedclcdGOP9GR1CnnLolBgq/mxw8MTFRi84wtXr16iqfEHJycggKCiI4OJj58+dz9913s2TJEl+HddpGjRpFp06duPPOO0vcxv7ulZ+qknYohy3px5tZ3NvND2Ufb5oUgQa1w471LW8WE0Gz6PBj7eYRoXZdeioikqyqicWtszNXSWzbto0BAwZQWFhI9erVmTBhgq9DOm1dunQhIiKCF1980dehmHKQlZvPl8t38VFSCstSMziSV3BsXVA1oXFUDZrFRNCxSeSxwmd8rNOTJSzEv7olBgpL9JVEixYtWLx48QnL0tPTufTSS0/a9rvvvjupx48/SU5O9nUIxstUlcUpB5i+MIXPl+7gcG4BCbERDOrWhITYiGN3fjaKqkFIgPRkqUws0VdiMTExlbr5xlR+ezNzmLloOx8mpbBhTyY1QoLo26EBAxKb0DU+qsoXQf2FJXpjTJnkFxTyw7o0piel8N3qPeQXKp2bRjL2hvb07dDAJ7f4V3qH02HlJ1CQBz3KNp6WJyzRG2M8siktk4+SU/k4OZU9h3KIrVmdP16QQP8ujWlRr/geYOYU8rJh3WxY9iGs/wYK8yH+Qkv0xpiKdTgnny+X7+SjpFR+37KPoGrCJa3i6J/YhN6t61p7e1kVFkLKAlg6DVZ9CtkZULM+nDcSzh0E9duXy2Et0RtjTqCqLNp2gI+SjhdWm8dG8Jc+rbmhcyPq1Q7zdYiVz94NsGyac/V+YBuEhEOba6HDQGjeC6qVb28jS/TlxH3kR2Mqg7RDOcxcnMr0pNRjhdVrOjRgQNcmJDazwmqZHU6HFR87CX57Mkg1SLgYLvkrtL4GQmtWWCiW6AOcjRdvTiW/oJB5a53C6vdrjhdW/3lje/p2aEhNu0mpbPKyYd1XsPRD2DDHaXev1x6uGAPtboLaDXwSVuX7K341GnYt9+5r1m8PV4095SajR4+mSZMm3HvvvQA89dRTBAcHM3fuXPbv309eXh5jxoyhX79+pR4uMzOTfv36Fbvf5MmTeeGFFxAROnTowJQpU9i9ezcjR45k0yZncq7XX3+dhg0bcs0117BixQoAXnjhBTIzM3nqqafo1asXHTt25Oeff2bw4MG0bNmSMWPGkJubS0xMDO+//z716tUrdhz6jIwMli1bdmzcmwkTJrBq1Speeuml0z27xg9tSstkelIqHy9KJc2tsDogsTFn17XCapkUFsK2+c6V+8rPICcDajWA7ndDh0FQv52vI6yEid5HBg4cyIMPPngs0U+fPp2vv/6a+++/n9q1a7N37166d+/OddddV+pX3LCwMGbOnHnSfqtWrWLMmDH8+uuvxMbGHhsv/v777+fiiy9m5syZFBQUkJmZWeqY8bm5uRwdSmL//v0sWLAAEWHixIk8//zzvPjii8WOQx8SEsKzzz7Lv/71L0JCQpg0aRJvvvnmmZ4+4weOFlanJ6WwcMt+K6yeqb3rnaLqsumQsQ1CIpx293MHOk005dzuXhaVL9GXcuVdXjp16sSePXvYsWMHaWlpREVFUb9+fR566CF+/PFHqlWrxvbt29m9ezf169c/5WupKo899thJ+33//ff079//2KxRR8dv//7774+N2R4UFESdOnVKTfQDBw489jg1NZWBAweyc+dOcnNzj41HX9I49L179+aLL76gTZs25OXl0b59+fQEMOXvaGF1+sIUvlh2YmH1xs6NqGuF1bI5vNdpd186DXYsctrdm18Cl/4NWveF6hGlv4YPVL5E70P9+/dnxowZ7Nq1i4EDB/L++++TlpZGcnIyISEhxMfHezTu++nu5y44OJjCwuOz4ZxqvPj77ruPhx9+mOuuu4558+bx1FNPnfK1hw0bxnPPPUfr1q254447yhSX8Q9FC6vh1YPo294Kq6cl7wis/crpMbPh2xPb3dv3h1qnvrDzB5boy2DgwIEMHz6cvXv38sMPPzB9+nTq1q1LSEgIc+fOZevWrR69TkZGRrH79e7dm+uvv56HH36YmJiYY+O3X3rppbz++us8+OCDx5pu6tWrx549e0hPT6dmzZp88cUX9OnTp8TjHR0v/t133z22vKRx6M877zxSUlJYtGgRy5YtO4MzZirS0cLqh0kpzHUVVrs0i7LC6ukoLIRtv7r6u38GOQdd7e73OP3d6/nHTHeesr98GbRt25ZDhw7RqFEjGjRowC233MK1115L+/btSUxMpHXr1h69Tkn7tW3blr/+9a9cfPHFBAUF0alTJ9555x1efvllRowYwVtvvUVQUBCvv/46PXr04IknnqBbt240atTolMd+6qmn6N+/P1FRUfTu3ZvNmzcDlDgOPcCAAQNYsmSJR9MKGt/amJbJR0UKq3dekEB/K6yWXdo6V3/3j5x29+o1oc110GEAJFzkV+3uZWHj0ZtiXXPNNTz00EPFjo5ZUezvXrLDOfn8b/lOpi9MIWnr0cJqXQYkNuYSK6yWTWba8f7uOxYfb3c/d5Bft7sXZePRG48dOHCAbt26ce655/o0yZuTOYXV/UxfmHpCYXX0Va25oZMVVssk7wis/dLV3/1b0AKnm/UVz0L7mypFu3tZeJToRaQP8DIQBExU1bFF1jcF3gUiXduMVtUvXeseBe4ECoD7VfVrr0Xv55YvX86QIUNOWBYaGspvv/3mo4hKFxkZybp163wdhnGTdiiHTxalMj0phY1phwmv7rpjNbEJXayw6rnCQtj6i3PlvmqWq929IZw/yunvXu8cX0dYbkpN9CISBLwGXA6kAgtFZJaqrnLb7HFguqq+LiLnAF8C8a7Hg4C2QEPgWxFpqaoFlJGqVrr/0O3bt7fx4k+TvzUpVrT8gkLmut2xWuAqrD5/41lc3aGBFVbLIm2tU1Rd/hFkpDjt7uf0c8aZib+g0ra7l4Un/1u6ARtUdROAiEwD+gHuiV6B2q7HdYAdrsf9gGmqmgNsFpENrtebX5Ygw8LCSE9PJyYmptIle1N2qkp6ejphYVWvKWJjWibTk1L4ZNF2V2E1lGEXJtC/SxPOrltxY6NUeplpsGKGk+B3LnHa3c/qDZc9Ba2uhurhvo6wQnmS6BsBKW7PU4HzimzzFPCNiNwHRACXue27oMi+jYoeQERGACMAmjZtelIAjRs3JjU1lbS0NA/CNYEgLCyMxo0b+zqMCnE4J5//LXPuWHUvrA7s2oRereKssOqpvCOw5n+u/u7fudrdO8CVzznjzNSq5+sIfcZb3/8GA++o6osi0gOYIiIeD/CgquOB8eD0uim6PiQk5NjdnMYEgqOF1Q8XpvDFsp1k5RbQPC6CR69qzfWdG1G3VtX7NnNaCgth689OUXXVZ5B7CGo3gp73O00zda3XFniW6LcDTdyeN3Ytc3cn0AdAVeeLSBgQ6+G+xlQZew5l88mi7UxPSmGTW2F1YNcmdG5qhVWP7VlzvL/7wdTj7e7nDoJmF0A1+xbkzpNEvxBoISIJOEl6EHBzkW22AZcC74hIGyAMSANmAVNF5N84xdgWwO9eit2YSiHv6B2rC1OYu9YprCY2i2LkjWfRt0MDIqyw6pnMPbB8hpPgdy4FCXLa3S9/ukq2u5dFqf/DVDVfREYBX+N0nXxbVVeKyDNAkqrOAv4PmCAiD+EUZm9Xp9vEShGZjlO4zQfuPZ0eN8ZURhv2ZPJRshVWz0hulqu/+zTY+L3T7t6gI/QZC+1uhJp1fR1hpVAp7ow1xufyc2Ht/+DIfqgRDTWiIDz6+GPX1WRxhdXeresyINEKqx4rLIQtPzlF1VWzXO3ujaFDf6e/e13PhhqpauzOWGNOV2YaJE+ChRMhc3eJmxUGhXJIarErL5wmhTW5P7QOcQn1adq4ERGRdSE7GtYd/XCIOv4BEVy9An8ZP7dn9fH+7ge3Q/Varnb3gdbufoYs0RtTnF3LYcEbTtIpyIGzL4Pzxjl3T2btgyP7yNi3hyXrNrFu8zYKs/YRF3SYVrXzaReeTc3C/cjBjZC8zxnWtiTVa7qSfuSJ3xDcPxCKfjjUiAycm3wO7T7e333XMqfd/ezL4Iq/Q8urrN3dSyzRG3NUYQGsmw0LXneaDkLCodOtcN5IiGsJOIXVuSnVmJ6Uzdy14RQUtqVr/AX0v6IJV7YvprCqCrmZrg+H/XDE9e+x5/tPXHcgxXmcfQC08OQYARAIq1P6B0J41InrQmuDP/Tqyc1y9XefBhvnOu3uDTtBn3+62t3jfB1hwLFEb0z2QVj8Hvz+Juzf4rQHX/4MdL7NSZQ4QxKMm7eRyfO3sjczh7haoQy/sDn9ExtzVtwpCqsiEFrL+Ylq5nlMhYXO3KMlfSCc8DjdmdbuyAFnnxJjCXIl/qhivj1ElvBhEe184J3pB0RhgfPhufRDWD3L+fCr0wQueNDp7x7X6sxe35ySJXpTdaVvhN/Hw+L3nYJfk+5w2dPQ+hoIOv7WyDiSx30fLObHdWlc2roug7s1pVerOILLs7BardrxpFwWBXlOwj/p20PRbxL7ICPVaaI6sg/yskp+zaDQIt8eiqk1FNfsFBwKu1cd7+9+aIfzraLt9U5yb9bT2t0riCV6U7WowuYfneaZdbOhWjC0u8FpnmnU+aTNN+89zJ3vLmRbehbPXd+em887eYgOvxIU4jR9lLX5Iy/7+DeHot8YijY1pW+E1CRnXUFuya8ZEu58gFQLdtrdr3wWWl0FITXO7Hc0ZWaJ3lQNeUecwuqCN2DPSgiPgYsega53ljj2+M/r93Lv1EVUE3hv2Hl0bx5TwUFXoJAwCGkAtRt4vo+qk8hL+saQtd9prmp3I0TEll/splSW6E1gO7jT6RqZPMlpy67XDvq95gxyFVL8eDKqypQFW3n681WcFRfBW0O70iTaen+cRMSZfal6BEQ2KX174zOW6E1g2p7sXL2v/MQpBLa6GrqPhPgLT1lYzCso5MlZK5n62zYua1OXlwZ2pFZYSAUGboz3WaI3gaMg3+nR8dsbkPKbc8NNtxHQbThENy919/2Hc7n7/WQWbNrH3b3O4k9XtCKomh90RzTmDFmiN5Vf1j5YNBl+n+CMZBiV4PTJ7ngzhNUufX9g3e5DDHs3iV0Hs3lp4Llc36lqjIVvqgZL9KbySlvrXL0v+QDyj0DCRXD1v6DllWW6c/S71bt5YNoSwkKCmDaiO52blrFLozF+zhK9qVwKC51RDBeMg43fOX28O/SH8+6G+h7PdQM4RdfxP25i7Ow1tG1Ym/FDEmkYaV3/TOCxRG8qh9zDsPQDp8Cavh5q1odLHofEO06r6152XgGPzVzOJ4u207d9A17ofy41qgfI+DHGFGGJ3vi3AynO3auL3oXsDGdMlBsmwDl/OO2RH/ccyuauKcks3naAhy5ryf2Xnm0zO5mAZone+B9Vp9fMgnGw+gtnWZtrofs90KTbGY27smJ7BsMnJ7E/K5dxt3Tm6vZluEHImErKEr3xH/m5sHIm/PY67FgMYZFw/ijoOtwrN+R8uXwn/zd9KVHhIcwYeT7tGtU585iNqQQs0RvfKzq5R2xL6PtvZ6Ln6hFn/PKqyivfbeClb9fRqWkkbw7pQt1axd8Va0wgskRvfKe4yT26j4Pmvb02quGR3AL+9NFS/rd8Jzd0bsRz17cnLMSKrqZqsURvKpYHk3t4y86MIwyfnMTKHQd57OrWDL+wuRVdTZVkid5UjOyDsOR95wanEib38KZF2/Zz15RkjuQWMPG2RC5tU8/rxzCmsrBEb8rXvk3w23hnBqdTTO7hTZ8sSmX0J8upXzuM94edR8t6tcrlOMZUFh6900SkD/AyEARMVNWxRda/BFziehoO1FXVSNe6AmC5a902Vb3OC3Ebf3Z0co/f3oC1X5U6uYe3FBQq//p6LW/8sJHuzaMZd0sXoiNOr6+9MYGk1EQvIkHAa8DlQCqwUERmqeqqo9uo6kNu298HdHJ7iSOq2tFrERv/lZftmtzjdY8n9/CWzJx8Hpy2mG9X7+GW85ry1HVtCSnPqf6MqUQ8uaLvBmxQ1U0AIjIN6AesKmH7wcCT3gnPVAoHd0LSW5D0tseTe3jTtvQshk1eyMa0w/y9X1uG9Igv92MaU5l4kugbASluz1OB84rbUESaAQnA926Lw0QkCcgHxqrqp8XsNwIYAdC0qZ/PyWmOOza5x0wozPd4cg9vWrApnbvfS6ZQYfIfu9HzbJuyzpiivF0NGwTMUNUCt2XNVHW7iDQHvheR5aq60X0nVR0PjAdITExUL8dkvKkgH9Z87jTPHJvcY7jHk3t409TftvHEZytoGhPOW0O7khB75jdXGROIPEn02wH3+88bu5YVZxBwr/sCVd3u+neTiMzDab/fePKuxq95YXIPb8kvKGTM/1bzzq9buLhlHK8M7kSdGjbdnzEl8STRLwRaiEgCToIfBNxcdCMRaQ1EAfPdlkUBWaqaIyKxQE/geW8EbirI0ck9lk6DvKzTntzDWzKy8hj1wSJ+Wr+XYRck8OjVbWy6P2NKUWqiV9V8ERkFfI3TvfJtVV0pIs8ASao6y7XpIGCaqro3vbQB3hSRQqAaTht9SUVc4y+8OLmHN21My2TYu0mk7s/i+Rs7MKDrmQ90ZkxVICfmZd9LTEzUpKQkX4dRNRU3uUfXYac9uYc3/bgujXunLqJ6UDXeGNKFrvHRPo3HGH8jIsmqmljcOrsz1pTL5B7eoqpM+mULY/63ipb1ajFxaCKNo8J9GpMxlY0l+qos5XeY/xqs/tx57qXJPbwlN7+QJz5bwbSFKVxxTj1eGtiRiFD7L2tMWdm7pipKWQhzn4VNc70+uYe3pGfmcPd7i/h9yz5GXXI2D1/ekmpWdDXmtFiir0q2L4J5/4D130B4LFwxBhL/6JXJPbxpza6DDHs3ibRDObw8qCP9OjbydUjGVGqW6KuCncucBL/2S2dI4Muecq7gQ2v6OrKTzFm1mwenLSYiNJjpd/Xg3CaRvg7JmErPEn0g270K5j3ntMGH1YHej0O3uyr8BidPqCrj5m3khW/W0r5RHcYPSaR+HZvuzxhvsEQfiNLWwryxzhg0obXg4tHQ/W6oEenryIqVnVfA6I+X8emSHVx7bkP+dVMHm+7PGC+yRB9I9m6AH/7pDBVcPQIu/D/ocS+E+2+f8z0Hsxk+JZmlKQd45MpW3NPrLJvuzxgvs0QfCPZthh//5dzsFBwGPe+H8x+AiBhfR3ZKy1MzGD45iYPZebxxaxf6tCvfMeuNqaos0VdmB7Y5CX7JVGcWp+73QM8HoGZdX0dWqs+X7uCRGUuJiQhlxsjzOaeh/9UNjAkUlugro4zt8NMLsGiKc2NT4p1w4cPlPouTNxQWKv/5dh2vfL+BrvFRvH5rF2Jrhvo6LGMCmiX6yuTQLvjp35A8yZmXtfNtTjt8ncrRzzwrN5+HP1zK7JW76N+lMWOub0dosBVdjSlvlugrg8w98PN/nOn6CvOh4y1w0Z8gsvLMxrX9wBGGvZvE2l0HebxvG+68IMGKrsZUEEv0/uxwOvzyH2eyj4IcOHewM9l2dIKvIyuT5K37uGtKMjl5hbx9e1d6tfL/GoIxgcQSvT/K2gfzX4Xf3nSGDu4wAC76M8Se7evIyuyjpBT+OnMFDSPDmDYikbPr1vJ1SMZUOZbo/cmRA85kH/PHQW4mtL0eeo2GuFa+jqzMCgqVsV+tZsJPm+l5dgyv3dyZyHDfDnlsTFVlid4fZB90rt7n/9cZD77NdU6Cr9fW15GdloPZeTzwwWLmrk3jth7N+Ns15xASVM3XYRlTZVmi96WcTGfCj19fgSP7oVVfJ8E36ODryE7blr2HGTY5iS17DzPmD+24tXszX4dkTJVnid4XcrNg4USn0JqVDi2ugF6PQqPOvo7sjPy6cS/3vL8IgMl3duP8s3w7/aAxxmGJviLlZTt94H/6NxzeA2f1hl6PQZOuvo7sjE1ZsJWnZ60kITaCiUMTaRbjX2PcG1OVWaKvCPk5sGgy/PQiHNoJCRdBr8nQrIevIztjeQWFPPP5KqYs2Erv1nV5eVBHaoWF+DosY4wbS/TlKT8XlrwPP74AB1OhaQ9n0u2EC30dmVccyMrlnvcX8evGdO66qDl/7tOaIJvuzxi/Y4m+PBTkwdJp8OPzzsBjjbtCv1eheS+/mHTbGzbsOcSd7yax80A2L/Q/l5u6NPZ1SMaYEniU6EWkD/AyEARMVNWxRda/BFziehoO1FXVSNe6ocDjrnVjVPVdL8TtnwrynbHgf/gn7N8MDTtB33/D2ZcFTIIHmLt2D/dPXUxoSDU+GNGdLs2ifB2SMeYUSk30IhIEvAZcDqQCC0VklqquOrqNqj7ktv19QCfX42jgSSARUCDZte9+r/4WvlZY4MzmNG8spK+H+u1h8DRo2SegEryq8tbPm3nuy9W0rl+bCUMTaRRZw9dhGWNK4ckVfTdgg6puAhCRaUA/YFUJ2w/GSe4AVwJzVHWfa985QB/ggzMJ2m8UFsLqz5wEn7YG6p4DA6ZA62ugWmDdIJSTX8BfZ65gRnIqV7Wrz4sDziW8urX8GVMZePJObQSkuD1PBc4rbkMRaQYkAN+fYt+TxtQVkRHACICmTSvBiIyqsOYLmPsP2LMSYlvBTZPgnD8EXIIH2JuZw11Tkkneup/7L23Bg5e2oJoVXY2pNLx9STYImKGqBWXZSVXHA+MBEhMT1csxeY8qrPsa5j4Lu5ZB9Flww0RodwNUC8xx1VftOMjwyUmkH87h1Zs7cU2Hhr4OyRhTRp4k+u1AE7fnjV3LijMIuLfIvr2K7DvP8/D8hCps+M5J8DsWQVQ8/OF1aD8AggK3+WL2il089OES6tQI4aO7zqd94zq+DskYcxo8yVILgRYikoCTuAcBNxfdSERaA1HAfLfFXwPPicjRbhlXAI+eUcQVSRU2/wBzn4OU36BOU7juv8648EGBe1OQqvLq9xt4cc46OjaJZPyQLtStHebrsIwxp6nURK+q+SIyCidpBwFvq+pKEXkGSFLVWa5NBwHTVFXd9t0nIn/H+bAAeOZoYdbvbfnZSfBbf4HajZxukp2GQHBgD7WbnVfAIzOW8fnSHVzfqRH/uKE9YSGB2SxlTFUhbnnZLyQmJmpSUpLvAti2wEnwm3+AmvWdOVk73wYhgX9FuysjmxFTkli+PYM/X9makRc3t+n+jKkkRCRZVROLWxe4DcxllZrkJPiN30FEHFz5HCT+EUKqRj/xJSkHGDE5icM5+UwYkshl59TzdUjGGC+xRL9jsdNNcv3XUCMaLn8Gug6D6lVn9MXPlmznkRnLqFsrlCl39qRVfZvuz5hAUnUT/a7lToJf+z8Ii4RLn4BuIyC06iS5wkLlxTlreW3uRrolRPP6LZ2JqRnq67CMMV5W9RL9ntUw7x+w6jMIreOMB999JIRVra6D+QWFjJq6mNkrdzG4WxOevq4d1YMD72YvY0xVSvRp6+CHsbDiE6heEy76M/S4B2pUzQG5xn61htkrd/HXq9sw7MIEK7oaE8ACP9Gnb4Qfnofl0yG4BlzwIJx/P4RH+zoyn5m5OJWJP2/m9vPjGX5Rc1+HY4wpZ4Gb6PdvgR/+BUs/gKDq0ONeOP8BqBnn68h8asX2DEZ/vJzzEqL5a982vg7HGFMBAi/RH0iBn16Axe+BBDkF1gseglrWXTDdNThZTER1XrulMyFB1iZvTFUQOIn+cDrMew6S33XGgO9yB1z4MNS2QbjAmdv13qmL2JuZw4yR5xNrvWuMqTICJ9GLOIXWTrc6d7NGNil9nyrkuS9Xs2DTPv494FwbnMyYKiZwEn14NDy4HEJr+joSv/NxciqTftnCHT3juaGzze1qTFUTWI20luRPsiz1AI/OXE6P5jE8drUVX42pigIr0ZsTpB1yiq9xNUN59eZOVnw1pooKnKYbc4Kjxdf9WbnMGHm+DW1gTBVmiT5AjfliFb9v3sfLgzrSrpEVX42pyuy7fACanpTCu/O3MuyCBPp1PGkudmNMFWOJPsAsSTnA4zNX0PPsGEZf1drX4Rhj/IAl+gCy51A2I6ckU7d2KK8O7kywFV+NMVgbfcDIzS/k3vcXceBILp/c3ZOoiMCe29YY4zlL9AHimS9WsnDLfl4Z3IlzGtb2dTjGGD9i3+0DwLTft/Hegm3cdVFzrjvXxvYxxpzIEn0lt2jbfp74bCUXtojlz32s+GqMOZlHiV5E+ojIWhHZICKjS9hmgIisEpGVIjLVbXmBiCxx/czyVuAG9hx0iq/164Tx38GdCKpms0QZY05Wahu9iAQBrwGXA6nAQhGZpaqr3LZpATwK9FTV/SJS1+0ljqhqR++GbXLyCxj5XjKHsvOZfGc3IsOt+GqMKZ4nV/TdgA2quklVc4FpQL8i2wwHXlPV/QCquse7YZqinpq1ikXbDvBC/3NpXd+Kr8aYknmS6BsBKW7PU13L3LUEWorILyKyQET6uK0LE5Ek1/I/FHcAERnh2iYpLS2tLPFXSVN/28YHv2/j7l5n0bdDA1+HY4zxc97qXhkMtAB6AY2BH0WkvaoeAJqp6nYRaQ58LyLLVXWj+86qOh4YD5CYmKheiikgJW/dx5OzVnBxyzj+dEUrX4djjKkEPLmi3w64T9fU2LXMXSowS1XzVHUzsA4n8aOq213/bgLmAZ3OMOYqa/fBbEa+t4iGkTV4ZZAVX40xnvEk0S8EWohIgohUBwYBRXvPfIpzNY+IxOI05WwSkSgRCXVb3hNYhSmznPwC7pqSzOGcfMYPSaROeIivQzLGVBKlNt2oar6IjAK+BoKAt1V1pYg8AySp6izXuitEZBVQADyiqukicj7wpogU4nyojHXvrWM8o6o88elKlqQc4I1bO9Oqfi1fh2SMqURE1b+axBMTEzUpKcnXYfiVKQu28rdPVzDqkrP505XWLm+MOZmIJKtqYnHr7M5YP/f75n08PWsll7SK46HLW/o6HGNMJWSJ3o/tzDjCPe8n0yQ6nP9Y8dUYc5os0fup7LwCRk5J5khuAeOHdKFODSu+GmNOjw1T7IdUlcc/XcHS1AzeHNKFFvWs+GqMOX12Re+HJs/fyozkVO6/tAVXtq3v63CMMZWcJXo/s2BTOn//YhWXtanLg5e28HU4xpgAYInej2w/cIR7319E05hw/j2wI9Ws+GqM8QJL9H7iaPE1J7+Q8UMSqR1mxVdjjHdYMdYPqCqPzVzO8u0ZTLgtkbPr1vR1SMaYAGJX9H5g0i9b+GTRdh66rCWXn1PP1+EYYwKMJXof+3XjXp79cjVXnFOP+3qf7etwjDEByBK9D6Xuz2LU1MXEx4Tz4oBzrfhqjCkXluh95EiuM+xwXn4hE25LpJYVX40x5cSKsT6gqjz6yTJW7TzIW0MTaR5nxVdjTPmxK3ofeOvnzXy6ZAf/d3lLere24qsxpnxZoq9gv2zYy3NfrqZP2/rce4kVX40x5c8SfQVK2ZfFqKmLOCuuJi8MOBcRK74aY8qfJfoKciS3gBFTkikoVCbclkjNUCuPGGMqhmWbCqCq/PnjZazZdZBJt3clPjbC1yEZY6oQu6KvAON/3MTnS3fwpyta0atVXV+HY4ypYizRl7Of1qfxz9lruLp9fe7pdZavwzHGVEGW6MvRtnTnzteW9Wrxr5us+GqM8Q1L9OUkKzefEVOSAHhzSBcirPhqjPERjxK9iPQRkbUiskFERpewzQARWSUiK0VkqtvyoSKy3vUz1FuB+zNV5ZEZy1i3+xD/HdyJZjFWfDXG+E6pl5kiEgS8BlwOpAILRWSWqq5y26YF8CjQU1X3i0hd1/Jo4EkgEVAg2bXvfu//Kv7jjR828b9lOxl9VWsuahnn63CMMVWcJ1f03YANqrpJVXOBaUC/ItsMB147msBVdY9r+ZXAHFXd51o3B+jjndD907y1e3j+6zVc06EBd13U3NfhGGOMR4m+EZDi9jzVtcxdS6CliPwiIgtEpE8Z9kVERohIkogkpaWleR69n9my9zD3f7CYVvVq8fxNHaz4aozxC94qxgYDLYBewGBggohEerqzqo5X1URVTYyLq5xNHZk5TvG1WjVhwm2JhFe34qsxxj94kui3A03cnjd2LXOXCsxS1TxV3Qysw0n8nuxb6akqj3y0lA17Mnl1cGeaRIf7OiRjjDnGk0S/EGghIgkiUh0YBMwqss2nOFfziEgsTlPOJuBr4AoRiRKRKOAK17KAMm7eRr5asYtHr2rDBS1ifR2OMcacoNT2BVXNF5FROAk6CHhbVVeKyDNAkqrO4nhCXwUUAI+oajqAiPwd58MC4BlV3Vcev4ivfL9mNy98s5Z+HRsy7MIEX4djjDEnEVX1dQwnSExM1KSkJF+H4ZHNew9z3as/0yQqnI/vPp8a1YN8HZIxpooSkWRVTSxund0Ze5oyc/IZPjmJ4GrCm0O6WJI3xvgt6xpyGgoLlYc/XMLmvYeZ8sduVnw1xvg1u6I/Da/O3cA3q3bz2NVtOP9sK74aY/ybJfoy+nbVbv49Zx3Xd2rEH3vG+zocY4wplSX6MtiYlslDHy6hXaPa/OOG9nbnqzGmUrBE76GD2XkMn5xE9eBqvDkkkbAQK74aYyoHK8Z64GjxdWt6Fu8PO49GkTV8HZIxxnjMrug98PJ36/l29R7+1rcN3ZvH+DocY4wpE0v0pfhm5S5e/m49N3ZuzNDz430djjHGlJkl+lPYsOcQD324hHMb1+HZ69tZ8dUYUylZoi9BxpE8hk9Opkb1IN4Y0sWKr8aYSsuKscUoLFQe+nAJKfuymDq8Ow3qWPHVGFN52RV9MV76dh3fr9nDk9eeQ7eEaF+HY4wxZ8QSfRGzV+zkv99vYEBiY27t3szX4RhjzBmzRO9m3e5DPDx9KR2bRPJMPyu+GmMCgyV6l4ysPEZMTiIiNJg3brXiqzEmcFiiBwoKlfunLWb7gSO8fktn6tcJ83VIxhjjNdbrBnjxm7X8sC6NZ69vR2K8FV+NMYGlyl/R/2/ZTsbN28jgbk245TwrvhpjAk+VTvRrdh3kTx8tpXPTSJ66rq2vwzHGmHJRZRP9gaxcRkxOplaYU3wNDbbiqzEmMFXJNvqCQuW+DxazM+MI00b0oG5tK74aYwKXR1f0ItJHRNaKyAYRGV3M+ttFJE1Elrh+hrmtK3BbPsubwZ+u579ew0/r9/L3fu3o0izK1+EYY0y5KvWKXkSCgNeAy4FUYKGIzFLVVUU2/VBVRxXzEkdUteMZR+olny/dwZs/bOKW85oyqFtTX4djjDHlzpMr+m7ABlXdpKq5wDSgX/mGVT5W7TjIIzOWktgsiievteKrMaZq8CTRNwJS3J6nupYVdaOILBORGSLSxG15mIgkicgCEflDcQcQkRGubZLS0tI8Dr4s9h/OZcSUJOrUCGHcrZ2pHlxl69DGmCrGW9nucyBeVTsAc4B33dY1U9VE4GbgPyJyVtGdVXW8qiaqamJcXJyXQjouv6CQ+z5YzJ6DObxxaxfq1rLiqzGm6vAk0W8H3K/QG7uWHaOq6aqa43o6Eejitm67699NwDyg0xnEe1r+OXsNP2/Yy5jr29GpqRVfjTFViyeJfiHQQkQSRKQ6MAg4ofeMiDRwe3odsNq1PEpEQl2PY4GeQNEibrn6bMl2Jvy0mdt6NGNAYpPSdzDGmABTaq8bVc0XkVHA10AQ8LaqrhSRZ4AkVZ0F3C8i1wH5wD7gdtfubYA3RaQQ50NlbDG9dcrNiu0Z/OXjZXSLj+Zv15xTUYc1xhi/Iqrq6xhOkJiYqElJSWf8OvsO53Ltf3+mUJVZoy4grlaoF6Izxhj/JCLJrnroSQLyztj8gkLufX8RaZk5zBjZw5K8MaZKC8g+hs99uYb5m9J57vr2dGgc6etwjDHGpwIu0X+yKJW3f9nM7efHc1OXxr4OxxhjfC6gEv3y1Awe/WQ55yVE89e+bXwdjjHG+IWASfR7M3O4a0oSsTVDGXdLZ0KCAuZXM8aYMxIwxdggEc5pWJsHL2tJTE0rvhpjzFEBk+ijIqozcWhXX4dhjDF+x9o3jDEmwFmiN8aYAGeJ3hhjApwlemOMCXCW6I0xJsBZojfGmABnid4YYwKcJXpjjAlwfjcevYikAVvP4CVigb1eCsebLK6ysbjKxuIqm0CMq5mqFjvptt8l+jMlIkklDb7vSxZX2VhcZWNxlU1Vi8uabowxJsBZojfGmAAXiIl+vK8DKIHFVTYWV9lYXGVTpeIKuDZ6Y4wxJwrEK3pjjDFuLNEbY0yAq5SJXkT6iMhaEdkgIqOLWR8qIh+61v8mIvF+EtftIpImIktcP8MqKK63RWSPiKwoYb2IyCuuuJeJSGc/iauXiGS4na8nKiiuJiIyV0RWichKEXmgmG0q/Jx5GFeFnzMRCROR30VkqSuup4vZpsLfkx7G5ZP3pOvYQSKyWES+KGadd8+XqlaqHyAI2Ag0B6oDS4FzimxzD/CG6/Eg4EM/iet24FUfnLOLgM7AihLWXw18BQjQHfjNT+LqBXzhg/PVAOjselwLWFfM37LCz5mHcVX4OXOdg5quxyHAb0D3Itv44j3pSVw+eU+6jv0wMLW4v5e3z1dlvKLvBmxQ1U2qmgtMA/oV2aYf8K7r8QzgUhERP4jLJ1T1R2DfKTbpB0xWxwIgUkQa+EFcPqGqO1V1kevxIWA10KjIZhV+zjyMq8K5zkGm62mI66doL48Kf096GJdPiEhjoC8wsYRNvHq+KmOibwSkuD1P5eT/7Me2UdV8IAOI8YO4AG50fdWfISJNyjkmT3kauy/0cH31/kpE2lb0wV1fmTvhXA268+k5O0Vc4INz5mqGWALsAeaoaonnqwLfk57EBb55T/4H+DNQWMJ6r56vypjoK7PPgXhV7QDM4fgntineIpzxO84F/gt8WpEHF5GawMfAg6p6sCKPfSqlxOWTc6aqBaraEWgMdBORdhVx3NJ4EFeFvydF5Bpgj6oml/exjqqMiX474P6p29i1rNhtRCQYqAOk+zouVU1X1RzX04lAl3KOyVOenNMKp6oHj371VtUvgRARia2IY4tICE4yfV9VPylmE5+cs9Li8uU5cx3zADAX6FNklS/ek6XG5aP3ZE/gOhHZgtPE21tE3iuyjVfPV2VM9AuBFiKSICLVcQoVs4psMwsY6np8E/C9uqoavoyrSBvudThtrP5gFnCbqydJdyBDVXf6OigRqX+0XVJEuuH8fy335OA65lvAalX9dwmbVfg58yQuX5wzEYkTkUjX4xrA5cCaIptV+HvSk7h88Z5U1UdVtbGqxuPkie9V9dYim3n1fAWf7o6+oqr5IjIK+Bqnp8vbqrpSRJ4BklR1Fs6bYYqIbMAp9g3yk7juF5HrgHxXXLeXd1wAIvIBTm+MWBFJBZ7EKUyhqm8AX+L0ItkAZAF3+ElcNwF3i0g+cAQYVAEf2OBccQ0BlrvadwEeA5q6xeaLc+ZJXL44Zw2Ad0UkCOeDZbqqfuHr96SHcfnkPVmc8jxfNgSCMcYEuMrYdGOMMaYMLNEbY0yAs0RvjDEBzhK9McYEOEv0xhgT4CzRmypDRArcRilcIsWMMHoGrx0vJYzCaYyvVbp+9MacgSOu2+GNqVLsit5UeSKyRUSeF5Hl4oxffrZrebyIfO8a8Oo7EWnqWl5PRGa6Bg5bKiLnu14qSEQmiDP2+TeuuzERkfvFGUN+mYhM89GvaaowS/SmKqlRpOlmoNu6DFVtD7yKM7IgOIOCvesa8Op94BXX8leAH1wDh3UGVrqWtwBeU9W2wAHgRtfy0UAn1+uMLJ9fzZiS2Z2xpsoQkUxVrVnM8i1Ab1Xd5Bo0bJeqxojIXqCBqua5lu9U1VgRSQMauw2GdXTY4Dmq2sL1/C9AiKqOEZHZQCbOSJKfuo2RbkyFsCt6YxxawuOyyHF7XMDxGlhf4DWcq/+FrtEIjakwluiNcQx0+3e+6/GvHB9M6hbgJ9fj74C74djEFnVKelERqQY0UdW5wF9whps96VuFMeXJrixMVVLDbdRHgNmqerSLZZSILMO5Kh/sWnYfMElEHgHSOD5C5QPAeBG5E+fK/W6gpCGKg4D3XB8GArziGhvdmApjbfSmynO10Seq6l5fx2JMebCmG2OMCXB2RW+MMQHOruiNMSbAWaI3xpgAZ4neGGMCnCV6Y4wJcJbojTEmwP0/oynwk2lwn7wAAAAASUVORK5CYII=\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### MobileNet" + ], + "metadata": { + "id": "Kz4p8IEwwmxf" + } + }, + { + "cell_type": "code", + "source": [ + "# Create model\n", + "mobilenet_model = create_model(model_url=mobilenet_url, # use EfficientNetB0 TensorFlow Hub URL\n", + " num_classes=train_data_10_percent.num_classes)\n", + "\n", + "# Compile EfficientNet model\n", + "mobilenet_model.compile(loss='categorical_crossentropy',\n", + " optimizer=tf.keras.optimizers.Adam(),\n", + " metrics=['accuracy'])\n", + "\n", + "# Fit EfficientNet model \n", + "mobilenet_history = mobilenet_model.fit(train_data_10_percent, # only use 10% of training data\n", + " epochs=5, # train for 5 epochs\n", + " steps_per_epoch=len(train_data_10_percent),\n", + " validation_data=test_data,\n", + " validation_steps=len(test_data),\n", + " callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\", \n", + " # Track logs under different experiment name\n", + " experiment_name=\"mobilenetB0\")])" + ], + "metadata": { + "id": "gJUfBI_FqEEy", + "outputId": "a74b3ba5-1e45-4191-e846-a38cbbb43c4a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving TensorBoard log files to: tensorflow_hub/mobilenetB0/20230228-153927\n", + "Epoch 1/5\n", + "23/23 [==============================] - 7s 124ms/step - loss: 1.0286 - accuracy: 0.4852 - val_loss: 0.8243 - val_accuracy: 0.6228\n", + "Epoch 2/5\n", + "23/23 [==============================] - 2s 89ms/step - loss: 0.7589 - accuracy: 0.6582 - val_loss: 0.7156 - val_accuracy: 0.7105\n", + "Epoch 3/5\n", + "23/23 [==============================] - 2s 89ms/step - loss: 0.6173 - accuracy: 0.7595 - val_loss: 0.6525 - val_accuracy: 0.7632\n", + "Epoch 4/5\n", + "23/23 [==============================] - 2s 106ms/step - loss: 0.5338 - accuracy: 0.8031 - val_loss: 0.6292 - val_accuracy: 0.7018\n", + "Epoch 5/5\n", + "23/23 [==============================] - 4s 163ms/step - loss: 0.4783 - accuracy: 0.8340 - val_loss: 0.6115 - val_accuracy: 0.7368\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plot_loss_curves(mobilenet_history)" + ], + "metadata": { + "id": "BV25MUmqqjrt", + "outputId": "94e8bd52-5883-47c7-a8ff-4dda40627a6c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 573 + } + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEWCAYAAAB2X2wCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzqklEQVR4nO3dd3hUZdrH8e+dRhJSCAkkpBFK6IHQIs0GiggoiChg2cWyrtjQtbvu6rK6FnZdZVWwvK6dIpZFxQKCIkUJhASkhdDSKEmAhBZIed4/zgAhBBjIZGYyuT/XlYspZ865Z3R+efKcc+4jxhiUUkrVf16uLkAppZRjaKArpZSH0EBXSikPoYGulFIeQgNdKaU8hAa6Ukp5CA10pZTyEBroyuOJyDYRuczVdShV1zTQlVLKQ2igqwZJRBqJyMsikm/7eVlEGtmeixCRr0Rkn4jsEZGfRcTL9tyjIpInIvtFZKOIDHLtO1HqBB9XF6CUi/wZ6AMkAwb4H/Ak8BfgQSAXaGZbtg9gRKQ9cA/Q2xiTLyIJgLdzy1bq9HSErhqqG4FJxpjdxpgC4G/AzbbnyoAWQEtjTJkx5mdjNT2qABoBnUTE1xizzRiz2SXVK1UDDXTVUEUD26vc3257DGAykAV8LyJbROQxAGNMFnA/8DSwW0RmiEg0SrkJDXTVUOUDLavcj7c9hjFmvzHmQWNMa+Bq4E/H5sqNMR8bYwbYXmuAF5xbtlKnp4GuGgpfEfE/9gNMB54UkWYiEgH8FfgQQESGi0hbERGgGGuqpVJE2ovIQNvO01LgMFDpmrej1Kk00FVDMRcrgI/9+AMrgNXAGiANeMa2bCIwHzgALANeN8YsxJo/fx4oBHYCzYHHnfcWlDoz0QtcKKWUZ9ARulJKeQgNdKWU8hAa6Eop5SE00JVSykO47NT/iIgIk5CQ4KrNK6VUvbRy5cpCY0yzmp5zWaAnJCSwYsUKV21eKaXqJRHZfrrndMpFKaU8hAa6Ukp5CA10pZTyENoPXSl1krKyMnJzcyktLXV1KQ2av78/sbGx+Pr62v0aDXSl1Elyc3MJDg4mISEBqz+ZcjZjDEVFReTm5tKqVSu7X6dTLkqpk5SWlhIeHq5h7kIiQnh4+Dn/laSBrpQ6hYa5653Pf4N6F+ibCw7wwrcb0C6RSil1snoX6AvW72bqj5v5v8VbXV2KUkq5lXoX6Ldf2IohnaN47psNLNtc5OpylFIOtm/fPl5//fVzft3QoUPZt2/fGZf561//yvz588+zspoFBQU5dH21Ue8CXUSYfF1XEsIDuXd6GjuKD7u6JKWUA50u0MvLy8/4urlz59KkSZMzLjNp0iQuu+yy2pTn1urlYYvB/r68cXNPRry6hLs+SmPGHX1o5OPt6rKU8jh/+3It6/JLHLrOTtEhPHVV59M+/9hjj7F582aSk5Px9fXF39+fsLAwNmzYQGZmJiNHjiQnJ4fS0lImTpzIHXfcAZzoD3XgwAGuvPJKBgwYwNKlS4mJieF///sfAQEBjB8/nuHDhzN69GgSEhL4/e9/z5dffklZWRmffPIJHTp0oKCggBtuuIH8/Hz69u3LvHnzWLlyJREREWd8X8YYHnnkEb755htEhCeffJIxY8awY8cOxowZQ0lJCeXl5UydOpV+/fpx2223sWLFCkSEW2+9lQceeKDWn229G6Ef07Z5MJOv68aq7H38/at1ri5HKeUgzz//PG3atCE9PZ3JkyeTlpbGK6+8QmZmJgDvvPMOK1euZMWKFUyZMoWiolOnXjdt2sTdd9/N2rVradKkCZ9++mmN24qIiCAtLY0JEybwz3/+E4C//e1vDBw4kLVr1zJ69Giys7Ptqvuzzz4jPT2djIwM5s+fz8MPP8yOHTv4+OOPueKKK44/l5ycTHp6Onl5efz222+sWbOGW2655Tw/rZPVyxH6MUOTWvDHi1rzxqItJMeFMbpnrKtLUsqjnGkk7SwpKSknnVwzZcoUPv/8cwBycnLYtGkT4eHhJ72mVatWJCcnA9CzZ0+2bdtW47pHjRp1fJnPPvsMgMWLFx9f/5AhQwgLC7OrzsWLFzNu3Di8vb2JjIzk4osvJjU1ld69e3PrrbdSVlbGyJEjSU5OpnXr1mzZsoV7772XYcOGMXjwYLs/jzOptyP0Yx6+oj19W4fz58/X8FtesavLUUo5WOPGjY/f/vHHH5k/fz7Lli0jIyOD7t2713jyTaNGjY7f9vb2Pu38+7HlzrRMbV100UUsWrSImJgYxo8fz/vvv09YWBgZGRlccsklTJs2jdtvv90h2zproIvIOyKyW0R+O83zIiJTRCRLRFaLSA+HVGYnH28v/nNDd5o29uPOD1ey9+BRZ25eKeVgwcHB7N+/v8bniouLCQsLIzAwkA0bNvDLL784fPv9+/dn1qxZAHz//ffs3bvXrtddeOGFzJw5k4qKCgoKCli0aBEpKSls376dyMhI/vCHP3D77beTlpZGYWEhlZWVXHvttTzzzDOkpaU5pHZ7plzeBV4F3j/N81cCibafC4Cptn+dJiKoEVNv6sn105YxcWY6/x3fG28vPdNNqfooPDyc/v3706VLFwICAoiMjDz+3JAhQ5g2bRodO3akffv29OnTx+Hbf+qppxg3bhwffPABffv2JSoqiuDg4LO+7pprrmHZsmV069YNEeHFF18kKiqK9957j8mTJ+Pr60tQUBDvv/8+eXl53HLLLVRWVgLw3HPPOaR2seeMSxFJAL4yxnSp4bk3gB+NMdNt9zcClxhjdpxpnb169TKOvmLRx79m88Tna7h3YFseHNzeoetWqqFYv349HTt2dHUZLnPkyBG8vb3x8fFh2bJlTJgwgfT0dJfUUtN/CxFZaYzpVdPyjtgpGgPkVLmfa3vsjIFeF8alxJGes5f/LMiia2wTLu8UefYXKaVUFdnZ2Vx//fVUVlbi5+fHW2+95eqS7ObUo1xE5A7gDoD4+Pi6WD+TRnRh/Y79/GlmOnPuHUCriMZnf6FSStkkJiayatWqkx4rKipi0KBBpyz7ww8/nHKEjSs5ItDzgLgq92Ntj53CGPMm8CZYUy4O2PYp/H29mXpTD676z2Lu/GAln9/dj0C/en10plLKxcLDw1027XIuHHHY4hzgd7ajXfoAxWebP69rsWGBTBnXnU279/Pop2u0M6NSqkGw57DF6cAyoL2I5IrIbSJyp4jcaVtkLrAFyALeAu6qs2rPwYWJzXhwcHu+zMjnnSXbXF2OUkrVubPORRhjxp3leQPc7bCKHOiuS9qQkbOPf8xdT5foEC5o7T5zXUop5Wj1/kzRMxER/nV9N1o2DeTuj1exq0QvequU8lweHehwojPjoaPlTPhwJUfLK11dklLKgc7Uj3zbtm106XLK6TMey+MDHSAxMpjJo7uRlr2PZ77WzoxKKc/UYI7nG9a1Bek5rXjr560kxzVhVA/tzKjUWX3zGOxc49h1RiXBlc+f9unHHnuMuLg47r7b2jX39NNP4+Pjw8KFC9m7dy9lZWU888wzjBgx4pw2W1payoQJE1ixYgU+Pj689NJLXHrppaxdu5ZbbrmFo0ePUllZyaeffkp0dDTXX389ubm5VFRU8Je//IUxY8bU6m07Q4MJdIBHh3RgTV4xj3+2hvZRwXSODnV1SUqpasaMGcP9999/PNBnzZrFd999x3333UdISAiFhYX06dOHq6++GhH7eza99tpriAhr1qxhw4YNDB48mMzMTKZNm8bEiRO58cYbOXr0KBUVFcydO5fo6Gi+/vprwGoKVh80qED38fbi1Rt6MHzKYu78cCVf3jOAJoF+ri5LKfd1hpF0XenevTu7d+8mPz+fgoICwsLCiIqK4oEHHmDRokV4eXmRl5fHrl27iIqKsnu9ixcv5t577wWgQ4cOtGzZkszMTPr27cuzzz5Lbm4uo0aNIjExkaSkJB588EEeffRRhg8fzoUXXlhXb9ehGsQcelURQY14/aYe7Cwu5f6Z6VRW6klHSrmb6667jtmzZzNz5kzGjBnDRx99REFBAStXriQ9PZ3IyMga+6CfjxtuuIE5c+YQEBDA0KFDWbBgAe3atSMtLY2kpCSefPJJJk2a5JBt1bUGF+gAPeLDeOqqzvy4sYCXf9jk6nKUUtWMGTOGGTNmMHv2bK677jqKi4tp3rw5vr6+LFy4kO3bt5/zOi+88EI++ugjADIzM8nOzqZ9+/Zs2bKF1q1bc9999zFixAhWr15Nfn4+gYGB3HTTTTz88MMO61de1xrUlEtVN14QT3rOPqb8sImuMaFcpp0ZlXIbnTt3Zv/+/cTExNCiRQtuvPFGrrrqKpKSkujVqxcdOnQ453XeddddTJgwgaSkJHx8fHj33Xdp1KgRs2bN4oMPPsDX15eoqCieeOIJUlNTefjhh/Hy8sLX15epU6fWwbt0PLv6odeFuuiHfq5KyyoYPW0p24sO8eU9A0jQzoxKNfh+6O7kXPuhN8gpl2P8fb2ZemNPvL2EP36wkkNH6+aagkop5QwNOtAB4poGMmVsdzJ37+cx7cyoVL20Zs0akpOTT/q54AKnXgnTLTTYOfSqLmrXjIcGt2fydxtJjmvCrQNaubokpVzKGHNOx3i7WlJSUr3oV34uzmdw2eBH6MdMuLgNl3eK5B9z17N86x5Xl6OUy/j7+1NUVKR/rbqQMYaioiL8/f3P6XUNeqdodSWlZYx8dQklpeV8fd8AIkPO7cNUyhOUlZWRm5vrsOO81fnx9/cnNjYWX1/fkx4/005RDfRqMnftZ+RrS+jYIoTpf+iDn4/+EaOUch96lMs5aBcZzIuju7Jy+16e1c6MSql6RAO9BsO7RnP7gFa8t2w7n6/KdXU5SillFw3003jsyg5c0Kopj3+2hnX5Ja4uRymlzkoD/TSOdWZsEuDHnR+upPhQmatLUkqpM9JAP4NmwVZnxh3Fh7l/5irtzKiUcmsa6GfRIz6Mv17VmYUbC3hFOzMqpdyYBrodbrognmt7xPLKD5tYsGGXq8tRSqkaaaDbQUR49poudI4O4f4Z6WwvOujqkpRS6hQa6Hby9/Vm2k09EbE6Mx4+WuHqkpRS6iQa6OcgrmkgU8Z1Z+Ou/Tz+2WrtdaGUcisa6Ofo4nbN+NNl7fgiPZ/3lm5zdTlKKXWcXYEuIkNEZKOIZInIYzU831JEfhCR1SLyo4jEOr5U93H3pW25rGNznvl6PanbtDOjUso9nDXQRcQbeA24EugEjBORTtUW+yfwvjGmKzAJeM7RhboTLy/hX9cnExsWwF0fpbG7RLvSKaVcz54RegqQZYzZYow5CswARlRbphOwwHZ7YQ3Pe5zQAF/euLkXB0rLufvjNMoqKl1dklKqgbMn0GOAnCr3c22PVZUBjLLdvgYIFpHw6isSkTtEZIWIrCgoKDifet1K+6hgXhjdldRte3n26/WuLkcp1cA5aqfoQ8DFIrIKuBjIA045rs8Y86YxppcxplezZs0ctGnXurpbNLf2b8W7S7fxv/Q8V5ejlGrA7LmmaB4QV+V+rO2x44wx+dhG6CISBFxrjNnnoBrd3uNDO/BbfjGPfrqadpHBdGwR4uqSlFINkD0j9FQgUURaiYgfMBaYU3UBEYkQkWPrehx4x7Flujdfby9evaE7oQG+VmfGw9qZUSnlfGcNdGNMOXAP8B2wHphljFkrIpNE5GrbYpcAG0UkE4gEnq2jet1W82B/Xr+xB/n7DvOnmenamVEp5XR6TVEHe3/ZNv76v7U8cFk7Jl6W6OpylFIeRq8p6kQ392nJqO4xvPxDJgs37nZ1OUqpBkQD3cGszoxJdIgKYeL0VWQXHXJ1SUqpBkIDvQ4E+HnzxrHOjB9qZ0allHNooNeR+PBAXh6bzIadJfz58zXamVEpVec00OvQpe2bc/+gdny2Ko8Pftnu6nKUUh5OA72O3TuwLYM6NGfSl+tYuV07Myql6o4Geh3z8hJeGpNMTFgAEz5MY/d+7cyolKobGuhOEBrgy7SbelJSWsY9H63SzoxKqTqhge4kHVuE8MK1XVm+bQ/Pzd3g6nKUUh5IA92JRiTHML5fAu8s2aqdGZVSDqeB7mR/HtaR3glhPPbpGjbsLHF1OUopD6KB7mS+3l68dkMPgvx9uPMD7cyolHIcDXQXaB7iz9Qbe5C79zAPztLOjEopx9BAd5FeCU15clhH5q/fzWsLs1xdjlLKA2igu9Dv+yUwMjmal+Zn8qN2ZlRK1ZIGuguJCM+N6kr7yGAmzkgnZ492ZlRKnT8NdBcL8PPmjZt7Yozhjx+spLRMOzMqpc6PBrobaBnemJfHJrNuRwl//vw37cyolDovGuhuYmCHSCYOSuTTtFw+/DXb1eUopeohDXQ3MnFQIpe2b8akL9eycvteV5ejlKpn6l+gHzkA+zxzBOvlJbw8pjstQgO466OVFOw/4uqSlFL1SP0L9F+nwZQe8PWDUJLv6mocLjTQ6sxYfLiMez5Oo1w7Myql7FT/Ar3bWOh+E6x8F15Jhm+fgAMFrq7KoTpFh/D8qK78unUPz3+jnRmVUvapf4EeGgtXvQz3roSk6+DXqfBKV5j3FBzynCsCjexudWZ8e/FW5mR43l8iSinHq3+BfkxYAox8De5OhQ7DYMkr8HJXWPgPOLzP1dU5xBNDO9KrZRiPzl7Nxp37XV2OUsrN1d9APyaiLVz7NkxYCm0uhZ9esEbsi/5p7UCtx/x8vHj9Rltnxg9XUlKqnRmVUqdX/wP9mMhOMOYD+OMiiO8LC/5uBfvS/8DR+ntKffMQf16/sQc5ew7xp5kZ2plRKXVadgW6iAwRkY0ikiUij9XwfLyILBSRVSKyWkSGOr5UO7XoBjfMhNt/gKiu8P2TMCUZfn0DyuvnYYC9E5ry52Edmb9+F6//qJ0ZlVI1O2ugi4g38BpwJdAJGCcinaot9iQwyxjTHRgLvO7oQs9ZbC/43RdwyzcQ3ha+ecQ63HHFf6Gi/k1djO+XwIjkaP41L5OfMj3rqB6llGPYM0JPAbKMMVuMMUeBGcCIassYIMR2OxRwn8MyWvaD8V/DzV9ASAv46n54tRekfwwV5a6uzm5WZ8YkW2fGVdqZUSl1CnsCPQbIqXI/1/ZYVU8DN4lILjAXuLemFYnIHSKyQkRWFBQ4cZQpYu0wvW0e3DALGoXAFxPg9T6wZjZU1o+TdwL9fJh2U08qKg13fqidGZVSJ3PUTtFxwLvGmFhgKPCBiJyybmPMm8aYXsaYXs2aNXPQps+BCLS7wtpxOuZD8PaFT2+Daf1h/ZdQD7ocJkQ05uUxyazNL+HJL7Qzo1LqBHsCPQ+Iq3I/1vZYVbcBswCMMcsAfyDCEQXWCRHoeBXcuQSu/T+oOAozb4I3L4bM79w+2Ad1jOS+QYnMXpnLR9qZUSllY0+gpwKJItJKRPywdnrOqbZMNjAIQEQ6YgW6+++58/KCpNFw168wcqp1QtLH18P/XQ6bF7p1sN8/KJFL2jfjb1+uJS1bOzMqpewIdGNMOXAP8B2wHutolrUiMklErrYt9iDwBxHJAKYD4019mgvw9oHkG6x2AsNftpp+fTAS3h0O25e6uroaWZ0Zk4kK9eeuD9O0M6NSCnFV7vbq1cusWLHCJds+q7JSSHsPfv4XHNgFrS+FgU9ah0K6mbX5xYx6fSnd45vw4W0X4OPtOeeKKaVOJSIrjTE1hpF++2vi6w8X/BHuS4fBz8DO1fD2IPh4DOzIcHV1J+kcHcpzo5L4ZcseXvhWOzMq1ZBpoJ+JXyD0uxcmZsDAv0D2MnjjIph5M+xe7+rqjhvVI5bf9W3JWz9v5avV7nMKgFLKuTTQ7dEoGC56CCauhosftXaYvt4XPr0dCt3jVPwnh3WiZ8swHpm9msxd2plRqYZIA/1cBDSBS5+A+1dD/4mw4Wt4LQW+uBv2bnNpacc6Mwb6+XDnB9qZUamGSAP9fAQ2hcv/Zk3FXPBHWPMJ/KcnfPUAFFc/RN95IkP8ee2G7mzfc4iHZmlnRqUaGg302ghqDkOeg4np0OP3kPYBTOkO3zwG+3e5pKQLWofzxNCOfL9uF1N/2uySGpRSrqGB7ggh0TD8Jes49q7Xw/I34ZVu8P1f4GCR08u5tX8CV3WL5l/fb+TnTe5/fpdSyjE00B0prCWMeBXuSYVOV1sX13ilKyx4xqmXxRMRXrg2icTmwdw3fRW5e7Uzo1INgQZ6XQhvA6PehLt+gbaXwaLJ1vVOf5oMR5xzBEqgnw/Tbu5JeYXVmVHPJFXK82mg16XmHeD69+CPP0NCf1j4jBXsS15xymXxWkU05pVxyWTuOsDgf//EnIx87c6olAfTQHeGFl1h3HT4wwKI6QHz/mrNsf8y1WozUIcGdohk7n0DaBnemPumr2LCh2kUHtDRulKeSHu5uEL2L9a8+rafITjaOmmp+83g41dnmyyvqOTtxVt5aV4mjf28+fvILgzvGl1n21NK1Y0z9XLRQHelLT/Bwmch51doEm+dhdp1rNX9sY5s2rWfh2avJiNnH0OTopg0ogsRQY3qbHtKKcfSQHdnxkDWfGvEviMdmraBSx6HLqPAy7tONlleUcmbP2/h5XmbCPL34e8jujCsa4s62ZZSyrG026I7E4HEy+GOH2Hsx+DjD5/dDlP7wbr/1cn1Tn28vbjrkrZ8dd8AYsMCuPvjNO7+KI0inVtXql7TQHcXItBhGNy5GEb/F0wlzPodvHkRbPymTq6e1C4ymM8m9OPhK9ozb90uBv97EXPX7HD4dpRSzqGB7m68vKzplrt+gWvegCMHYPpYqx971g8OD3Yfby/uvrQtX947gOgmAdz1URp3f6yjdaXqI51Dd3cVZZD+sXVyUnEOxPeDgX+GhAEO31R5RSVvLNrCy/MzCfH35ZmRXbgySefWlXInulPUE5QfgbT3YdE/4cBOaHWxdVm8uBSHb2rjzv089EkGa/KKGd61BZNGdKFp47o7pFIpZT8NdE9SdhhWvAM/vwSHCiFxsNWjPbq7YzdTUckbP23mlR82ERpgjdaHdNHRulKupoHuiY4csLo6LnkFSvdBh+FWsEd2duhmNuws4aFPMvgtr4SrukUz6erOhOloXSmX0UD3ZKXFVguBZa9Zjb+6jLKOY49IdNgmyioqmfbjZqYsODZaT2JIlyiHrV8pZT8N9Ibg0B6rXe+vb0D5YeuM04sfgaatHLaJ9Tus0fra/BJGJEfz9FU6WlfK2TTQG5IDBbDkZUh9GyrLIflGuOhhaBLnkNWXVVTy+sLN/GfBJpoE+vGPa7owuLOO1pVyFg30hqhkByx+CVbYTlKK7wPtroB2V1rTMSK1Wv26fGu0vm5HCSOTo3n66s40CdTRulJ1TQO9IduXAyvfhczvYNca67GwVtBuiBXwLfufd5fHsopKXluYxasLsghr7Mc/rkni8k6RjqtdKXUKDXRlKc61gj3zO9j6E5SXgl8wtLkU2l8JbS+HoGbnvNq1+cU89Mlq1u8o4ZruMTx1VScdrStVR2od6CIyBHgF8AbeNsY8X+35fwOX2u4GAs2NMU3OtE4NdBc7esgK9cxvrYDfvwMQiO1lm5oZApFd7J6aOVpujdZfW2iN1p+7JonLdLSulMPVKtBFxBvIBC4HcoFUYJwxZt1plr8X6G6MufVM69VAdyPGwM7VsPFbK+Dz06zHQ2JPhHurC8E34Kyr+i2vmIc+yWDDzv2M6h7DU1d1JjTQt47fgFINR20DvS/wtDHmCtv9xwGMMc+dZvmlwFPGmHlnWq8Guhvbvws2fW+F++aFUHYQfAKg9SW2gL8CQk5/taOj5ZW8umATr/24mfDGfjw3KolBHXW0rpQj1DbQRwNDjDG32+7fDFxgjLmnhmVbAr8AscaYihqevwO4AyA+Pr7n9u3bz/W9KGcrPwLbFtumZr6FfdnW4y26ndix2qK71SWympNG6z1ieGq4jtaVqi1nBvqjWGF+79mK0hF6PWQMFGw4Me+e86t1SGTj5tBusBXwrS+FRkHHX1J1tB4RZI3WB3bQ0bpS58tpUy4isgq42xiz9GxFaaB7gINF1uXzMr+1erUfKQZvP0i48MToPawlAGtyrdH6xl37Gd0zlr8M70RogI7WlTpXtQ10H6ydooOAPKydojcYY9ZWW64D8C3Qythx6IwGuoepKIPsX05MzRRlWY836wjth0C7IRyJ6sF/Fm5l6k+baRbUiOeuTeLS9s1dW7dS9YwjDlscCryMddjiO8aYZ0VkErDCGDPHtszTgL8x5jF7itJA93CFWbDpOyvcty+12hAENIXEy9kefiH3r2zKqt1wXc9YntTRulJ20xOLlGuVFsPmBdZhkZu+h8N7MOJNTnA3PtjTifSAPtw1+godrStlBw105T4qKyB3xYkdq7utmbstlVHkNruInoPH0bjtheCtI3alaqKBrtzXvmzKNnxDzrLPidmXSiMpp9w3CJ92l1s7VtteDo3DXV2lUm5DA13VC6u35DH7kw/puH8Zw/wzCCnfA4h13dRjnSKbd6x1p0il6jMNdFVvlJZV8PL8Tby1aBMXBeXzdPscWhb9DDvSrQVC40+0I0gYAL7+Lq1XKWfTQFf1zqrsvTz0SQabCw4ytnccT17UhKDshda8+5aFUHYIfAOtE5naD7Eulh2sF9pQnk8DXdVLpWUV/Ht+Jm8t2kJUiD8vjO7KhYnNoOzwiXYEG7+FklzrBdHdq7QjSNapGeWRNNBVvVZ1tD4uJZ4nhnYg2N92FIwxsHsdbPzGGr3npgIGgltYo/Z2Q6D1xeDX2KXvQSlH0UBX9V5pWQX/npfJWz9voUVoAC9c25UBiRGnLniwEDbNO9GO4Oh+8G4ErS46MffuoOurKuUKGujKY6TZRutbbKP1Pw/rSFAjn5oXLj8K2UutkfvGb2DvVuvxyC4nwj2mJ3h5O+8NKFVLGujKo5SWVfCSbbQefabRelXGWP1ljs27Zy8DUwGB4bapmSugzSDwD3HOm1DqPGmgK4+0cvteHv4kgy2FB7nxgngeH3qG0Xp1h/daUzKZ31ntCEr3gZePddHstpdBeFvrIh4hMdA4QnewKrehga48VmlZBf/6fiNvL95KdGgAk0d3pV/bs4zWq6sot3amZtp2rBZsOPl5b78T4R4SbfuJrXI7Bho3q/EiH0o5mga68ngrtu3h4dmr2Vp4kJv6xPP4lR1pbO9ovboDu6E4B0rybT95UJx34nZJPlSWnfwaL18IaVEt9GOq/ERDUHOdr1e1poGuGoTDRyv45/cbeWfJVmKaBPDi6K70a3OOo3V7VFbCoSJbuFcL+pJ8KM61/q04cvLrxNs6nDI05vQj/qBI8D7PX0SqQdBAVw1K6rY9PPxJBtuKDnFzn5Y8dmWH8x+tny9j4NCeKkGfe/KIvyTfGvWXHz75deIFQVFWuIfG1DDij7Z+KWg3ygZLA101OIePVjD5u438d+lWYsMCePHabvRt42ZdG42xds5WD/qqI//iPCg7WO2FYo3kqwZ99fAPbgE+jVzytlTd0kBXDdbyrXt4ZLY1Wv9935Y8MsQFo/XaMAaOlJw6h1/93yMlp762cfNTp3ZCq+zMDY7W5mb1kAa6atAOH63gxe828O7SbcSGBTB5dDf6tHaz0XptlZbA/h0178A9NuVTWnzq6wLDT95xW/UXQGisNdL3C3T++1GnpYGuFNZo/eHZGWy3jdYfvbIDgX71aLReW0cOnAj9U47esd0/vOfU1wWEVQn804R/oyDnv58GSgNdKZtDR8t58duNvLt0G/FNA5k8uisXeNpovTbKDtc8pVNcZV7/UOGpr/MNhMAI6ySsxhEn327c7NTndNR/3jTQlarm1y1FPDx7Ndl7DjG+XwKPDGnfsEbrtVFWahvpV9mBe7DQ+jlUCAcL4GCR9W/1QzeP8W1sXVrweNg3s+4fv13tF4NvgHPfoxvTQFeqBlVH6y3DA5k8uhsprZq6uizPYQwcPVBD2Bdax/Efu32w4MT9iqM1r8svyJrvrynsa/oLwIN39mqgK3UGyzYX8cinGeTuPWyN1q/oQICfntHpdMbAkf224C+sEvaFJ0b81f8CqH7G7jF+wdX+Aqge/tWeq0eHeGqgK3UWB4+U88K3G3h/2XZahgdy+4BWjOgeQ4i/nsDjto4d0lnTXwDH71d7rrK85nU1Cjl17v900z+BEeDj59z3WoUGulJ2Wrq5kGe+Ws+6HSX4+3oxLCmacSlx9GwZhmjHxfrNGOvQzVOme6oHf5Xbp/0FEGr/DuDGEQ49s1cDXalzYIxhTV4x05fnMCc9j4NHK0hsHsSY3nGM6hFL08auG50pJzLGaqt8uumemn4RmIqa1+UfenLY97oV2g46r7I00JU6TwePlPPV6nymL88hPWcfft5eDO4cybiUePq2DsfLS0ftyqay0vYLoOpIv+DkvwiOPX7xI9D5mvPaTK0DXUSGAK8A3sDbxpjna1jmeuBpwAAZxpgbzrRODXRV32zYWcKM5Tl8lpZLSWk5LcMDub5XHNf1jKV5iOceVaHcS60CXUS8gUzgciAXSAXGGWPWVVkmEZgFDDTG7BWR5saY3Wdarwa6qq9Kyyr49redTF+eza9b9+DtJQzq0JxxKfFc1K4Z3jpqV3XoTIFuz5kUKUCWMWaLbWUzgBHAuirL/AF4zRizF+BsYa5Ufebv683I7jGM7B7DloIDzEzNYfbKXL5ft4sWof5c1yuOMb3jiGmiJ8Mo57JnhD4aGGKMud12/2bgAmPMPVWW+QJrFN8fa1rmaWPMtzWs6w7gDoD4+Pie27dvd9DbUMq1jpZXMn/9LqYvz2ZxlnVq/EWJzRiXEsegjpH4euvl6ZRj1HaEbg8fIBG4BIgFFolIkjFmX9WFjDFvAm+CNeXioG0r5XJ+Pl4MTWrB0KQW5Ow5xKwVOcxakcOdH6YREdSI0T1jGds7joSIxq4uVXkwewI9D4ircj/W9lhVucCvxpgyYKuIZGIFfKpDqlSqHolrGsiDg9szcVAiP2UWMH15Dm/9vIVpP22mb+twxqbEcUXnKPx99WxU5Vj2BHoqkCgirbCCfCxQ/QiWL4BxwH9FJAJoB2xxYJ1K1Ts+3l4M6hjJoI6R7Cop5ZMVOcxckcPEGek0CfTlmu4xjEuJp11ksKtLVR7C3sMWhwIvY82Pv2OMeVZEJgErjDFzxDqF7l/AEKACeNYYM+NM69SjXFRDVFlpWLK5kBnLc/h+3U7KKgw94pswNiWe4V1baMdHdVZ6YpFSbqjowBE+S8tjemo2WwoOEtzIh6uToxnbO56k2FBXl6fclAa6Um7MGEPqtr3MWJ7N12t2cKS8ks7RIYxNiWdEcrQ2CFMn0UBXqp4oPlTGF+l5TF+ezYad+wnw9WZY1xaMS4mjR7w2CFMa6ErVO8YYVucWMyM1mznp+ccbhI1NiWdU9xjCtEFYg6WBrlQ9duBIOV9l5DM9NYcMW4OwK7pEMa53HH20QViDo4GulIdYv6OEGcuz+XxV3vEGYWN6xzG6ZyzNg7VBWEOgga6Uhyktq+Cb33YwfXkOy7fuwcdLGNSxOWNT4rkoURuEeTINdKU82OYqDcL2HDxKtK1B2PXaIMwjaaAr1QAcLa9k3rpdzEjN5udNhYjAxe2aMbZ3PIM6NtcGYR5CA12pBqZqg7BdJUdoFnyiQVjLcG0QVp9poCvVQJVXVPLjxgJmpGazYMNuKg3aIKye00BXSrGz+ESDsNy9h2kS6Muo7rGMS4kjURuE1Rsa6Eqp4yorDYuzCpmZeqJBWM+WYYztHccwbRDm9jTQlVI1KjxwhM/ScpmxPIcthScahI1LiadLjDYIc0ca6EqpMzLGsHzrHmak5jDX1iCsS0wIY3tbDcKCtUGY29BAV0rZrfhQGZ+vymVGas7xBmHDu7ZgbEo8PeKbaIMwF9NAV0qdM2MMGbnFzFiezZyMfA4draBdZBBjemuDMFfSQFdK1cqBI+V8mZHPjOXZZOQW4+fjxZDOUYxNiaNv63AdtTuRBrpSymHW5ZcwI9VqELa/tJyE8EAGdoikf9twLmgdTlAjPUqmLmmgK6Uc7vBRq0HYZ2l5LN+2h6PllXh7Cd1iQxnQNoJ+bSPoHt+ERj568pIjaaArpepUaVkFK7fvZUlWIUs2F7Emdx+VBvx9veid0JT+bSPo3yaCTtEh2gmyls4U6Pq3kVKq1vx9va3QbhsBQPHhMn7dUsTSzUUsySrk+W82ABAa4Evf1uH0bxtOv7YRtI5orPPvDqSBrpRyuNAAXwZ3jmJw5ygAdpeUHg/3JVmFfLt2JwAtQv3p2yacAbZfBpEhepGO2tApF6WUUxlj2FZ0iCVZhSzdXMiyzUXsPVQGQJtmjenfNoJ+bSLo2zqc0EA9oak6nUNXSrmtykrDuh0lLN1cyJKsIpZv3cPhsgq8BLrEhNKvTQT924bTO6GpdodEA10pVY8cLa8kPWff8RH8qux9lFca/Hy86Bkfdnz+vWtMKD4N8KIdGuhKqXrr4JFylm/dc/wImvU7SgAIbuTDBa2b2kbwEbSLDGoQO1j1KBelVL3VuJEPl3ZozqUdmgNQdOAIy7YUsSSriKWbC5m/fjcAEUGN6NfGdgRNmwjimga6smyXsGuELiJDgFcAb+BtY8zz1Z4fD0wG8mwPvWqMeftM69QRulLKEXL3HmJpVhFLbHPwhQeOABDfNNB2KGU4fVuHEx7UyMWVOkatplxExBvIBC4HcoFUYJwxZl2VZcYDvYwx99hblAa6UsrRjDFs2n2AxZus+fdft+xh/5FyADq2CKF/m3D6t40gpVVTGtfTFgW1nXJJAbKMMVtsK5sBjADWnfFVSinlZCJCu8hg2kUGc+uAVpRXVLI6r5ilWdbo/f1l23l78VZ8vITkuCb0axvBgLYRJMc1wc+n/u9gtWeEPhoYYoy53Xb/ZuCCqqNx2wj9OaAAazT/gDEmp4Z13QHcARAfH99z+/btDnobSil1dqVlFazYtpclmwtZmlXImrxiKg0E+HqT0qrp8fn3Ti1C8HLTFgXO2Cn6JTDdGHNERP4IvAcMrL6QMeZN4E2wplwctG2llLKLv683AxIjGJBoa1FwqIxfthaxNKuQxVmF/GNuAQBhgb70bRN+/AiahPDAenEEjT2BngfEVbkfy4mdnwAYY4qq3H0beLH2pSmlVN0KDfTlis5RXGFrUbCzuPT4CU5LNxcyd43VoiA61P/49Ey/NuE0d9MWBfYEeiqQKCKtsIJ8LHBD1QVEpIUxZoft7tXAeodWqZRSThAV6s+oHrGM6hGLMYathQdZstkawc9fv4vZK3MBSGweZGtREE6fNuGEuMk1V88a6MaYchG5B/gO67DFd4wxa0VkErDCGDMHuE9ErgbKgT3A+DqsWSml6pyI0LpZEK2bBXFzn5bHWxQcO8FpRmo27y7dhpdAUmyT40fQ9GwZ5rIWBXqmqFJKnYcj5RWsyt5nHUGzuYj0nH1U2FoU9GoZdrydcFJMqEN7wOup/0opVccOHCln+VbrDNYlWYVs2LkfgGB/H/q0Dj8+gm/bvHYtCvTUf6WUqmNBjXwY2CGSgR0iASg8cIRlm4uO72Sdt24XAM2DG/HnYR0ZkRzj8Bo00JVSqg5EBDXiqm7RXNUtGoCcPYeOz7/X1YU8NNCVUsoJ4poGMjYlnrEp8XW2jfp/rqtSSilAA10ppTyGBrpSSnkIDXSllPIQGuhKKeUhNNCVUspDaKArpZSH0EBXSikP4bJeLiJSAJzvJYsigEIHluMoWte50brOnbvWpnWdm9rU1dIY06ymJ1wW6LUhIitO15zGlbSuc6N1nTt3rU3rOjd1VZdOuSillIfQQFdKKQ9RXwP9TVcXcBpa17nRus6du9amdZ2bOqmrXs6hK6WUOlV9HaErpZSqRgNdKaU8hFsHuogMEZGNIpIlIo/V8HwjEZlpe/5XEUlwk7rGi0iBiKTbfm53Ul3viMhuEfntNM+LiEyx1b1aRHq4SV2XiEhxlc/rr06oKU5EForIOhFZKyITa1jG6Z+XnXW54vPyF5HlIpJhq+tvNSzj9O+jnXW55Pto27a3iKwSka9qeM7xn5cxxi1/AG9gM9Aa8AMygE7VlrkLmGa7PRaY6SZ1jQdedcFndhHQA/jtNM8PBb4BBOgD/OomdV0CfOXkz6oF0MN2OxjIrOG/o9M/LzvrcsXnJUCQ7bYv8CvQp9oyrvg+2lOXS76Ptm3/Cfi4pv9edfF5ufMIPQXIMsZsMcYcBWYAI6otMwJ4z3Z7NjBIanM5bcfV5RLGmEXAnjMsMgJ431h+AZqISAs3qMvpjDE7jDFpttv7gfVA9av2Ov3zsrMup7N9Bgdsd31tP9WPqHD699HOulxCRGKBYcDbp1nE4Z+XOwd6DJBT5X4up/6PfXwZY0w5UAyEu0FdANfa/kyfLSJxdVyTveyt3RX62v5s/kZEOjtzw7Y/dbtjje6qcunndYa6wAWfl236IB3YDcwzxpz283Li99GeusA138eXgUeAytM87/DPy50DvT77EkgwxnQF5nHit7CqWRpWf4puwH+AL5y1YREJAj4F7jfGlDhru2dzlrpc8nkZYyqMMclALJAiIl2csd2zsaMup38fRWQ4sNsYs7Kut1WVOwd6HlD1N2ms7bEalxERHyAUKHJ1XcaYImPMEdvdt4GedVyTvez5TJ3OGFNy7M9mY8xcwFdEIup6uyLiixWaHxljPqthEZd8Xmery1WfV5Xt7wMWAkOqPeWK7+NZ63LR97E/cLWIbMOalh0oIh9WW8bhn5c7B3oqkCgirUTED2unwZxqy8wBfm+7PRpYYGx7GFxZV7V51qux5kHdwRzgd7ajN/oAxcaYHa4uSkSijs0dikgK1v+XdRoEtu39H7DeGPPSaRZz+udlT10u+ryaiUgT2+0A4HJgQ7XFnP59tKcuV3wfjTGPG2NijTEJWBmxwBhzU7XFHP55+dTmxXXJGFMuIvcA32EdWfKOMWatiEwCVhhj5mD9j/+BiGRh7XQb6yZ13SciVwPltrrG13VdACIyHesIiAgRyQWewtpJhDFmGjAX68iNLOAQcIub1DUamCAi5cBhYKwTfjH3B24G1tjmXwGeAOKr1OWKz8ueulzxebUA3hMRb6xfILOMMV+5+vtoZ10u+T7WpK4/Lz31XymlPIQ7T7kopZQ6BxroSinlITTQlVLKQ2igK6WUh9BAV0opD6GBrjyOiFRU6ayXLjV0xKzFuhPkNF0jlXI1tz0OXalaOGw7FVypBkVH6KrBEJFtIvKiiKwRq4d2W9vjCSKywNa86QcRibc9Hikin9uaYGWISD/bqrxF5C2x+m9/bztDERG5T6w+5qtFZIaL3qZqwDTQlScKqDblMqbKc8XGmCTgVaxueGA1uHrP1rzpI2CK7fEpwE+2Jlg9gLW2xxOB14wxnYF9wLW2xx8DutvWc2fdvDWlTk/PFFUeR0QOGGOCanh8GzDQGLPF1gBrpzEmXEQKgRbGmDLb4zuMMREiUgDEVmnsdKyl7TxjTKLt/qOArzHmGRH5FjiA1f3wiyp9upVyCh2hq4bGnOb2uThS5XYFJ/ZFDQNewxrNp9o66CnlNBroqqEZU+XfZbbbSznRGOlG4Gfb7R+ACXD8Igqhp1upiHgBccaYhcCjWK1QT/krQam6pCMI5YkCqnQqBPjWGHPs0MUwEVmNNcoeZ3vsXuC/IvIwUMCJrooTgTdF5DaskfgE4HTtc72BD22hL8AUW39upZxG59BVg2GbQ+9ljCl0dS1K1QWdclFKKQ+hI3SllPIQOkJXSikPoYGulFIeQgNdKaU8hAa6Ukp5CA10pZTyEP8PZhjtNHP3LEgAAAAASUVORK5CYII=\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "mobilenet_model.summary()" + ], + "metadata": { + "id": "rI3DcMq7rjB3", + "outputId": "3a8d84ff-5f2d-4b9c-f22b-eb687b93fb29", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential_5\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " feature_extraction_layer (K (None, 1280) 2257984 \n", + " erasLayer) \n", + " \n", + " output_layer (Dense) (None, 3) 3843 \n", + " \n", + "=================================================================\n", + "Total params: 2,261,827\n", + "Trainable params: 3,843\n", + "Non-trainable params: 2,257,984\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Comparing models on Tensorboard\n", + "Don't put any private data here because it is available in public" + ], + "metadata": { + "id": "hEaxXI0Uro0I" + } + }, + { + "cell_type": "code", + "source": [ + "# Upload TensorBoard dev records\n", + "!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n", + " --name \"Sneakers_CNN\" \\\n", + " --description \"Comparing different models for Sneaker's Dataset\" \\\n", + " --one_shot\n", + " " + ], + "metadata": { + "id": "sbvTIMwUr5t7", + "outputId": "8489263d-7657-425a-f6c7-c64fc24a6d08", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 31, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2023-02-28 15:46:43.598843: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/lib64-nvidia\n", + "2023-02-28 15:46:43.598940: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/lib64-nvidia\n", + "2023-02-28 15:46:43.598957: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n", + "\n", + "New experiment created. View your TensorBoard at: https://tensorboard.dev/experiment/1sEjm0kgR1CvMxeAGPN4SA/\n", + "\n", + "\u001b[1m[2023-02-28T15:46:45]\u001b[0m Started scanning logdir.\n", + "\u001b[1m[2023-02-28T15:46:49]\u001b[0m Total uploaded: 120 scalars, 0 tensors, 4 binary objects (9.8 MB)\n", + "\u001b[1m[2023-02-28T15:46:49]\u001b[0m Done scanning logdir.\n", + "\n", + "\n", + "Done. View your TensorBoard at https://tensorboard.dev/experiment/1sEjm0kgR1CvMxeAGPN4SA/\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Link to TensorBoard\n", + "# https://tensorboard.dev/experiment/WtnFkayNRLuV3WOnb1CRyQ/#scalars&runSelectionState=eyJlZmZpY2llbnRuZXRCMC8yMDIzMDIyOC0xNTMwMzAvdHJhaW4iOnRydWUsImVmZmljaWVudG5ldEIwLzIwMjMwMjI4LTE1MzAzMC92YWxpZGF0aW9uIjpmYWxzZSwiZWZmaWNpZW50bmV0XzJfQjAvMjAyMzAyMjgtMTUzMzExL3RyYWluIjpmYWxzZSwiZWZmaWNpZW50bmV0XzJfQjAvMjAyMzAyMjgtMTUzMzExL3ZhbGlkYXRpb24iOmZhbHNlLCJtb2JpbGVuZXRCMC8yMDIzMDIyOC0xNTM5MjcvdHJhaW4iOmZhbHNlLCJtb2JpbGVuZXRCMC8yMDIzMDIyOC0xNTM5MjcvdmFsaWRhdGlvbiI6ZmFsc2UsInJlc25ldDUwVjIvMjAyMzAyMjgtMTUyNzI4L3RyYWluIjpmYWxzZSwicmVzbmV0NTBWMi8yMDIzMDIyOC0xNTI3MjgvdmFsaWRhdGlvbiI6ZmFsc2V9&_smoothingWeight=0.871\n", + "\n", + "# Delete an experiment\n", + "# !tensorboard dev delete --experiment_id [INSERT_EXPERIMENT_ID]\n", + "# Check to see if experiments still exist\n", + "# !tensorboard dev list" + ], + "metadata": { + "id": "kvSGzKpvtC5G" + }, + "execution_count": 50, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Predictions" + ], + "metadata": { + "id": "0DBOFzqmtk5h" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a function to import an image and resize it to be able to be used with our model\n", + "def load_and_prep_image(filename, img_shape=224):\n", + " \"\"\"\n", + " Reads an image from filename, turns it into a tensor\n", + " and reshapes it to (img_shape, img_shape, colour_channel).\n", + " \"\"\"\n", + " # Read in target file (an image)\n", + " img = tf.io.read_file(filename)\n", + "\n", + " # Decode the read file into a tensor & ensure 3 colour channels \n", + " # (our model is trained on images with 3 colour channels and sometimes images have 4 colour channels)\n", + " img = tf.image.decode_image(img, channels=3)\n", + "\n", + " # Resize the image (to the same size our model was trained on)\n", + " img = tf.image.resize(img, size = [img_shape, img_shape])\n", + "\n", + " # Rescale the image (get all values between 0 and 1)\n", + " img = img/255.\n", + " return img" + ], + "metadata": { + "id": "4D0LQul1t5Wt" + }, + "execution_count": 34, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Adjust function to work with multi-class\n", + "def pred_and_plot(model, filename, class_names):\n", + " \"\"\"\n", + " Imports an image located at filename, makes a prediction on it with\n", + " a trained model and plots the image with the predicted class as the title.\n", + " \"\"\"\n", + " # Import the target image and preprocess it\n", + " img = load_and_prep_image(filename)\n", + "\n", + " # Make a prediction\n", + " pred = model.predict(tf.expand_dims(img, axis=0))\n", + "\n", + " # Get the predicted class\n", + " if len(pred[0]) > 1: # check for multi-class\n", + " pred_class = class_names[pred.argmax()] # if more than one output, take the max\n", + " else:\n", + " pred_class = class_names[int(tf.round(pred)[0][0])] # if only one output, round\n", + "\n", + " # Plot the image and predicted class\n", + " plt.imshow(img)\n", + " plt.title(f\"Prediction: {pred_class}\")\n", + " plt.axis(False);" + ], + "metadata": { + "id": "xp4WIxF4uK7A" + }, + "execution_count": 35, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Get the class names for our multi-class dataset\n", + "import pathlib\n", + "import numpy as np\n", + "data_dir = pathlib.Path(train_dir)\n", + "class_names = np.array(sorted([item.name for item in data_dir.glob('*')]))\n", + "print(class_names)" + ], + "metadata": { + "id": "5z9C62OwuMT7", + "outputId": "66b11ac8-9f90-415c-cabf-d928499cd1fd", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 37, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['adidas' 'converse' 'nike']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make a prediction using efficienet_2_model\n", + "pred_and_plot(model=efficientnet_2_model, \n", + " filename=\"nike_example.jpeg\", \n", + " class_names=class_names)" + ], + "metadata": { + "id": "BnObiamRuZg-", + "outputId": "2e76a376-973e-42d3-a6d3-021d838ed191", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + } + }, + "execution_count": 45, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1/1 [==============================] - 0s 49ms/step\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make a prediction using model_1\n", + "pred_and_plot(model=efficientnet_2_model, \n", + " filename=\"converse_example.jpg\", \n", + " class_names=class_names)" + ], + "metadata": { + "id": "m0j0dMi9u7RY", + "outputId": "b133bb0c-9e2e-4f24-f84a-810eeeac32a4", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + } + }, + "execution_count": 46, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1/1 [==============================] - 0s 29ms/step\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make a prediction using model_1\n", + "pred_and_plot(model=efficientnet_2_model, \n", + " filename=\"adidas_example.jpeg\", \n", + " class_names=class_names)" + ], + "metadata": { + "id": "82U8-p0KvsZ1", + "outputId": "d02f02b5-c8e5-4976-ff42-25b68af83e1a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + } + }, + "execution_count": 49, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1/1 [==============================] - 0s 36ms/step\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# well this looks so much similar to Converse's" + ], + "metadata": { + "id": "qCwrwlXlvxPN" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Make a prediction using model_1\n", + "pred_and_plot(model=efficientnet_2_model, \n", + " filename=\"adidas_example_2.jpeg\", \n", + " class_names=class_names)" + ], + "metadata": { + "id": "5GXpbIe-vD9e", + "outputId": "e5c7ed03-a3eb-4b6f-d95c-87d2e9c852fe", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + } + }, + "execution_count": 48, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1/1 [==============================] - 0s 101ms/step\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Conclusion\n", + "\n", + "* Resnet : val_accuracy: 0.7456\n", + "* EfficientNet (version 1) : val_accuracy: 0.7982\n", + "* EfficientNet (version 2) : val_accuracy: 0.8246\n", + "* MobileNet : val_accuracy: 0.7368\n", + "\n", + "EfficientNet (version 2) has the most validation accuracy and give better results than models without transfer learning From previous [notebook](https://github.com/adijams01/Sneakers_CNN/blob/main/Sneakers_CNN.ipynb)\n" + ], + "metadata": { + "id": "NgQqBOX1vH3E" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "kFDTNrF0xYbl" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file