diff --git a/demos/gpu/README.ipynb b/demos/gpu/README.ipynb index 1ea9aa58..36596ff6 100644 --- a/demos/gpu/README.ipynb +++ b/demos/gpu/README.ipynb @@ -25,16 +25,11 @@ "- A **horovod** directory with applications that use Uber's [Horovod](https://eng.uber.com/horovod/) distributed deep-learning framework, which can be used to convert a single-GPU TensorFlow, Keras, or PyTorch model-training program to a distributed program that trains the model simultaneously over multiple GPUs.\n", " The objective is to speed up your model training with minimal changes to your existing single-GPU code and without complicating the execution.\n", " Horovod code can also run over CPUs with only minor modifications.\n", - " For more information and examples, see the [Horovod GitHub repository](https://github.com/horovod/horovod).\n", - " \n", " The Horovod tutorials include the following:\n", - "\n", - " - An image-recognition demo application for execution over GPUs (**image-classification**).\n", - " - A slightly modified version of the GPU image-classification demo application for execution over CPUs (**cpu/image-classification**).\n", " - Benchmark tests (**benchmark-tf.ipynb**, which executes **tf_cnn_benchmarks.py**).\n", + " - Note that under the demo folder you will find an image classificaiton demo that is also running with Horovod and can be set to run with GPU
\n", "\n", "- A **rapids** directory with applications that use NVIDIA's [RAPIDS](https://rapids.ai/) open-source libraries suite for executing end-to-end data science and analytics pipelines entirely on GPUs.\n", - "\n", " The RAPIDS tutorials include the following:\n", "\n", " - Demo applications that use the [cuDF](https://rapidsai.github.io/projects/cudf/en/latest/index.html) RAPIDS GPU DataFrame library to perform batching and aggregation of data that's read from a Kafaka stream, and then write the results to a Parquet file.
\n", diff --git a/demos/gpu/horovod/cpu/image-classification/01-load-data-cats-n-dogs.ipynb b/demos/gpu/horovod/cpu/image-classification/01-load-data-cats-n-dogs.ipynb deleted file mode 100644 index d08237a5..00000000 --- a/demos/gpu/horovod/cpu/image-classification/01-load-data-cats-n-dogs.ipynb +++ /dev/null @@ -1,284 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Load Cats and Dogs Images" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "fe76d1d1ded592430e7548feacfa38dc42f085d9" - }, - "source": [ - "## Install Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install --upgrade keras==2.2.4\n", - "!pip install --upgrade tensorflow==1.13.1 \n", - "!pip install --upgrade 'numpy<1.15.0'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note:** After running the pip command you should restart the Jupyter kernel.
\n", - "> To restart the kernel, click on the kernel-restart button in the notebook menu toolbar (the refresh icon next to the **Code** button)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Import Library" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", - "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Using TensorFlow backend.\n" - ] - } - ], - "source": [ - "# This Python 3 environment comes with many helpful analytics libraries installed.\n", - "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python.\n", - "# For example, here are several helpful packages to load:\n", - "\n", - "import numpy as np # linear algebra\n", - "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", - "from keras.preprocessing.image import load_img\n", - "\n", - "# Input data files are available in the \"../input/\" directory.\n", - "# For example, running the following (by selecting 'Run' or pressing Shift+Enter) will list the files in the input directory:\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import random\n", - "\n", - "import os\n", - "import zipfile\n", - "\n", - "# Define locations\n", - "BASE_PATH = os.getcwd()\n", - "DATA_PATH = BASE_PATH + \"/cats_and_dogs_filtered/\"\n", - "!mkdir model\n", - "MODEL_PATH = BASE_PATH + '/model/'\n", - "\n", - "# Define image parameters\n", - "FAST_RUN = False\n", - "IMAGE_WIDTH=128\n", - "IMAGE_HEIGHT=128\n", - "IMAGE_SIZE=(IMAGE_WIDTH, IMAGE_HEIGHT)\n", - "IMAGE_CHANNELS=3 # RGB color\n", - "\n", - "# Any results you write to the current directory are saved as output." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "DATA_PATH + 'catsndogs.zip'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Download the Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!mkdir cats_and_dogs_filtered\n", - "# Download a sample stocks file from Iguazio demo bucket in AWS S3\n", - "!curl -L \"iguazio-sample-data.s3.amazonaws.com/catsndogs.zip\" > ./cats_and_dogs_filtered/catsndogs.zip" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "zip_ref = zipfile.ZipFile(DATA_PATH + 'catsndogs.zip', 'r')\n", - "zip_ref.extractall('cats_and_dogs_filtered')\n", - "zip_ref.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "7335a579cc0268fba5d34d6f7558f33c187eedb3" - }, - "source": [ - "## Prepare the Traning Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import json" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def build_prediction_map(categories_map):\n", - " return {v:k for k ,v in categories_map.items()}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0", - "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a" - }, - "outputs": [], - "source": [ - "# Create a file-names list (JPG image-files only)\n", - "filenames = [file for file in os.listdir(DATA_PATH+\"/cats_n_dogs\") if file.endswith('jpg')]\n", - "categories = []\n", - "\n", - "# Categories and prediction-classes map\n", - "categories_map = {\n", - " 'dog': 1,\n", - " 'cat': 0,\n", - "}\n", - "prediction_map = build_prediction_map(categories_map)\n", - "with open(MODEL_PATH + 'prediction_classes_map.json', 'w') as f:\n", - " json.dump(prediction_map, f)\n", - "\n", - "# Create a pandas DataFrame for the full sample\n", - "for filename in filenames:\n", - " category = filename.split('.')[0]\n", - " categories.append([categories_map[category]])\n", - "\n", - "df = pd.DataFrame({\n", - " 'filename': filenames,\n", - " 'category': categories\n", - "})\n", - "df['category'] = df['category'].astype('str');" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "_uuid": "915bb9ba7063ab4d5c07c542419ae119003a5f98" - }, - "outputs": [], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "_uuid": "72bf69e817f67f5a2eaff8561217e22077248553" - }, - "outputs": [], - "source": [ - "df.tail()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "a999484fc35b73373fafe2253ae9db7ff46fdb90" - }, - "source": [ - "## Check the Total Image Count\n", - "\n", - "Check the total image count for each category.
\n", - "The data set has 12,000 cat images and 12,000 dog images." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "_uuid": "fa26f0bc7a6d835a24989790b20f3c6f32946f45" - }, - "outputs": [], - "source": [ - "df['category'].value_counts().plot.bar()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "400a293df3c8499059d9175f3915187074efd971" - }, - "source": [ - "## Display the Sample Image" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "_uuid": "602b40f7353871cb161c60b5237f0da0096b2f47" - }, - "outputs": [], - "source": [ - "sample = random.choice(filenames)\n", - "image = load_img(DATA_PATH+\"/cats_n_dogs/\"+sample)\n", - "plt.imshow(image)" - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/demos/gpu/horovod/cpu/image-classification/02-train-with-horovod-cats-n-dogs.ipynb b/demos/gpu/horovod/cpu/image-classification/02-train-with-horovod-cats-n-dogs.ipynb deleted file mode 100644 index 281e82a7..00000000 --- a/demos/gpu/horovod/cpu/image-classification/02-train-with-horovod-cats-n-dogs.ipynb +++ /dev/null @@ -1,216 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install git+https://github.com/v3io/v3io-gputils" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "!rm -f /User/demos/gpu/horovod/cpu/image-classification/cats_dogs.hd5\n", - "!mkdir /User/demos/gpu/horovod/cpu/image-classification/checkpoints" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "HOROVOD_JOB_NAME = \"horovod-cats-n-dogs\"" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'apiVersion': 'kubeflow.org/v1alpha1',\n", - " 'kind': 'MPIJob',\n", - " 'metadata': {'creationTimestamp': '2019-07-02T07:41:59Z',\n", - " 'generation': 1,\n", - " 'name': 'horovod-cats-n-dogs',\n", - " 'namespace': 'default-tenant',\n", - " 'resourceVersion': '1391131',\n", - " 'selfLink': '/apis/kubeflow.org/v1alpha1/namespaces/default-tenant/mpijobs/horovod-cats-n-dogs',\n", - " 'uid': 'df9b08a1-9c9c-11e9-98d3-d8c4972b0204'},\n", - " 'spec': {'replicas': 8,\n", - " 'template': {'spec': {'containers': [{'command': ['mpirun',\n", - " 'python',\n", - " '/User/demos/gpu/horovod/cpu/image-classification/horovod_train_cats_n_dogs.py',\n", - " '/User/demos/gpu/horovod/cpu/image-classification/cats_and_dogs_filtered',\n", - " '/User/demos/gpu/horovod/cpu/image-classification'],\n", - " 'image': 'iguaziodocker/horovod-cpu:0.0.1',\n", - " 'name': 'horovod-cats-n-dogs',\n", - " 'resources': {'limits': {'nvidia.com/gpu': 0}},\n", - " 'securityContext': {'capabilities': {'add': ['IPC_LOCK']}},\n", - " 'volumeMounts': [{'mountPath': '/User',\n", - " 'name': 'v3io'}]}],\n", - " 'volumes': [{'flexVolume': {'driver': 'v3io/fuse',\n", - " 'options': {'accessKey': '1e52ff93-a541-4880-abf1-d9b948af77de',\n", - " 'container': 'users',\n", - " 'subPath': '/iguazio'}},\n", - " 'name': 'v3io'}]}}}}\n" - ] - } - ], - "source": [ - "from v3io_gputils.mpijob import MpiJob\n", - "\n", - "job = MpiJob(HOROVOD_JOB_NAME, 'iguaziodocker/horovod-cpu:0.0.1', ['/User/demos/gpu/horovod/cpu/image-classification/horovod_train_cats_n_dogs.py',\n", - " '/User/demos/gpu/horovod/cpu/image-classification/cats_and_dogs_filtered',\n", - " '/User/demos/gpu/horovod/cpu/image-classification'])\n", - "\n", - "job.replicas(2).gpus(0)\n", - "job.submit()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "horovod-cats-n-dogs-launcher-8kg8c 1/1 Running 0 75s\n", - "horovod-cats-n-dogs-worker-0 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-1 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-2 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-3 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-4 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-5 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-6 1/1 Running 0 83s\n", - "horovod-cats-n-dogs-worker-7 1/1 Running 0 83s\n" - ] - } - ], - "source": [ - "\n", - "!kubectl get pods | grep $HOROVOD_JOB_NAME" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "apiVersion: kubeflow.org/v1alpha1\n", - "kind: MPIJob\n", - "metadata:\n", - " creationTimestamp: 2019-07-02T06:49:07Z\n", - " generation: 1\n", - " name: horovod-cats-n-dogs\n", - " namespace: default-tenant\n", - " resourceVersion: \"1386982\"\n", - " selfLink: /apis/kubeflow.org/v1alpha1/namespaces/default-tenant/mpijobs/horovod-cats-n-dogs\n", - " uid: 7d0cd80c-9c95-11e9-98d3-d8c4972b0204\n", - "spec:\n", - " backoffLimit: 6\n", - " replicas: 8\n", - " template:\n", - " metadata:\n", - " creationTimestamp: null\n", - " spec:\n", - " containers:\n", - " - command:\n", - " - mpirun\n", - " - python\n", - " - /User/demos/gpu/horovod/cpu/image-classification/horovod_train_cats_n_dogs.py\n", - " - /User/demos/gpu/horovod/cpu/image-classification/cats_and_dogs_filtered\n", - " - /User/demos/gpu/horovod/cpu/image-classification\n", - " image: iguaziodocker/cpu/horovod-cpu:0.1.1\n", - " name: horovod-cats-n-dogs\n", - " resources:\n", - " limits:\n", - " nvidia.com/gpu: \"1\"\n", - " securityContext:\n", - " capabilities:\n", - " add:\n", - " - IPC_LOCK\n", - " volumeMounts:\n", - " - mountPath: /User\n", - " name: v3io\n", - " volumes:\n", - " - flexVolume:\n", - " driver: v3io/fuse\n", - " options:\n", - " accessKey: 1e52ff93-a541-4880-abf1-d9b948af77de\n", - " container: users\n", - " subPath: /iguazio\n", - " name: v3io\n", - "status:\n", - " completionTime: 2019-07-02T06:56:20Z\n", - " launcherStatus: Succeeded\n", - " startTime: 2019-07-02T06:49:14Z\n" - ] - } - ], - "source": [ - "!kubectl get mpijob $HOROVOD_JOB_NAME -o yaml" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'apiVersion': 'v1',\n", - " 'details': {'group': 'kubeflow.org',\n", - " 'kind': 'mpijobs',\n", - " 'name': 'horovod-cats-n-dogs',\n", - " 'uid': '1b58dd58-9c97-11e9-98d3-d8c4972b0204'},\n", - " 'kind': 'Status',\n", - " 'metadata': {},\n", - " 'status': 'Success'}\n" - ] - } - ], - "source": [ - "job.delete()" - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/demos/gpu/horovod/cpu/image-classification/03-infer.ipynb b/demos/gpu/horovod/cpu/image-classification/03-infer.ipynb deleted file mode 100644 index 995a17ba..00000000 --- a/demos/gpu/horovod/cpu/image-classification/03-infer.ipynb +++ /dev/null @@ -1,548 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create and Test a Model-Serving Nuclio Function\n", - "\n", - "This notebook demonstrates how to write an inference server, test it, and turn it into an auto-scaling Nuclio serverless function.\n", - "\n", - "- [Initialize Nuclio Emulation, Environment Variables, and Configuration](#image-class-infer-init-func)\n", - "- [Create and Load the Model and Set Up the Function Handler](#image-class-infer-create-n-load-model-n-set-up-func-handler)\n", - "- [Trigger the Function](#image-class-infer-func-trigger)\n", - "- [Prepare to Deploy the Function](#image-class-infer-func-deploy-prepare)\n", - "- [Deploy the Function](#image-class-infer-func-deploy)\n", - "- [Test the Function](#image-class-infer-func-test)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Initialize Nuclio Emulation, Environment Variables, and Configuration\n", - "\n", - "> **Note:** Use `# nuclio: ignore` for sections that don't need to be copied to the function." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# nuclio: ignore\n", - "import nuclio\n", - "import random\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: setting 'IMAGE_WIDTH' environment variable\n", - "%nuclio: setting 'IMAGE_HEIGHT' environment variable\n", - "%nuclio: setting 'version' environment variable\n" - ] - } - ], - "source": [ - "%%nuclio env\n", - "IMAGE_WIDTH = 128\n", - "IMAGE_HEIGHT = 128\n", - "version = 1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: setting 'MODEL_PATH' environment variable\n", - "%nuclio: setting 'PREDICTION_MAP_PATH' environment variable\n" - ] - } - ], - "source": [ - "%nuclio env -c MODEL_PATH=/model/\n", - "%nuclio env -l MODEL_PATH=/User/demos/gpu/horovod/cpu/image-classification/cats_dogs.hd5\n", - "%nuclio env -l PREDICTION_MAP_PATH=./model/prediction_classes_map.json" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "%%nuclio cmd -c\n", - "pip install keras==2.2.4\n", - "pip install tensorflow==1.13.1 \n", - "pip install 'numpy<1.15.0'\n", - "pip install requests\n", - "pip install pillow" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: setting spec.build.baseImage to 'python:3.6-jessie'\n" - ] - } - ], - "source": [ - "%%nuclio config \n", - "spec.build.baseImage = \"python:3.6-jessie\"" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mounting volume path /model as ~/demos/gpu/horovod/cpu/image-classification/cats_dogs/model\n" - ] - } - ], - "source": [ - "%nuclio mount /model ~/demos/gpu/horovod/cpu/image-classification/cats_dogs/model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Create and Load the Model and Set Up the Function Handler" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Using TensorFlow backend.\n" - ] - } - ], - "source": [ - "import numpy as np \n", - "from tensorflow import keras\n", - "from keras.models import load_model\n", - "from keras.preprocessing import image\n", - "from keras.preprocessing.image import load_img\n", - "import json\n", - "import requests\n", - "\n", - "import os\n", - "from os import environ, path\n", - "from tempfile import mktemp" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "model_file = environ['MODEL_PATH']\n", - "prediction_map_file = environ['PREDICTION_MAP_PATH']\n", - "\n", - "# Set image parameters\n", - "IMAGE_WIDTH = int(environ['IMAGE_WIDTH'])\n", - "IMAGE_HEIGHT = int(environ['IMAGE_HEIGHT'])\n", - "\n", - "# load model\n", - "def init_context(context): \n", - " context.model = load_model(model_file)\n", - " with open(prediction_map_file, 'r') as f:\n", - " context.prediction_map = json.load(f)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def download_file(context, url, target_path):\n", - " with requests.get(url, stream=True) as response:\n", - " response.raise_for_status()\n", - " with open(target_path, 'wb') as f:\n", - " for chunk in response.iter_content(chunk_size=8192):\n", - " if chunk:\n", - " f.write(chunk)\n", - "\n", - " context.logger.info_with('Downloaded file',url=url)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def handler(context, event):\n", - " tmp_file = mktemp()\n", - " image_url = event.body.decode('utf-8').strip()\n", - " download_file(context, image_url, tmp_file)\n", - " \n", - " img = load_img(tmp_file, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n", - " x = image.img_to_array(img)\n", - " x = np.expand_dims(x, axis=0)\n", - "\n", - " images = np.vstack([x])\n", - " predicted_probability = context.model.predict_proba(images, batch_size=10)\n", - " predicted_class = list(zip(predicted_probability, map(lambda x: '1' if x >= 0.5 else '0', predicted_probability)))\n", - " actual_class = [(context.prediction_map[x[1]],x[0][0]) for x in predicted_class] \n", - " os.remove(tmp_file)\n", - " result = {'class':actual_class[0][0], 'dog-probability':float(actual_class[0][1])}\n", - " return json.dumps(result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Trigger the Function" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Logging before flag parsing goes to stderr.\n", - "W0702 07:05:39.756876 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:529: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", - "\n", - "W0702 07:05:39.784578 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:4420: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n", - "\n", - "W0702 07:05:39.814317 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:250: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n", - "\n", - "W0702 07:05:39.814856 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:178: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n", - "\n", - "W0702 07:05:39.815345 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:185: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n", - "\n", - "W0702 07:05:39.920376 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:2029: The name tf.nn.fused_batch_norm is deprecated. Please use tf.compat.v1.nn.fused_batch_norm instead.\n", - "\n", - "W0702 07:05:39.987011 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:4255: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n", - "\n", - "W0702 07:05:39.994644 140252009395584 deprecation.py:506] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:3721: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n", - "W0702 07:05:40.865994 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n", - "\n", - "W0702 07:05:40.875694 140252009395584 deprecation.py:323] From /User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/ops/nn_impl.py:180: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Use tf.where in 2.0, which has the same broadcast rule as np.where\n" - ] - } - ], - "source": [ - "# nuclio: ignore\n", - "init_context(context)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python> 2019-07-02 07:06:07,287 [info] Downloaded file: {'url': 'https://s3.amazonaws.com/iguazio-sample-data/images/catanddog/dog.391.jpg'}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0702 07:06:07.287323 140252009395584 logger.py:100] Downloaded file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\"class\": \"dog\", \"dog-probability\": 1.0}\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# nuclio: ignore\n", - "# Select a sample for the test.\n", - "# Set both the local path for the test and the URL for downloading the sample from AWS S3.\n", - "DATA_LOCATION = \"./cats_and_dogs_filtered/\"\n", - "sample = random.choice(os.listdir(DATA_LOCATION+\"/cats_n_dogs\"))\n", - "image_local = DATA_LOCATION + \"cats_n_dogs/\"+sample # Temporary location for downloading the file \n", - "image_url = 'https://s3.amazonaws.com/iguazio-sample-data/images/catanddog/' + sample \n", - "\n", - "# Show the image\n", - "img = load_img(image_local, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n", - "plt.imshow(img)\n", - "\n", - "event = nuclio.Event(body=bytes(image_url, 'utf-8'))\n", - "output = handler(context, event)\n", - "print(output)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: notebook infer exported\n", - "Config:\n", - "apiVersion: nuclio.io/v1\n", - "kind: Function\n", - "metadata:\n", - " annotations:\n", - " nuclio.io/generated_by: function generated at 02-07-2019 by iguazio from /User/demos/image-classification/infer.ipynb\n", - " labels: {}\n", - " name: infer\n", - "spec:\n", - " build:\n", - " baseImage: python:3.6-jessie\n", - " commands:\n", - " - pip install git+https://github.com/fchollet/keras\n", - " - pip install tensorflow\n", - " - pip install numpy\n", - " - pip install requests\n", - " - pip install pillow\n", - " functionSourceCode: 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\n", - " noBaseImagesPull: true\n", - " env:\n", - " - name: IMAGE_WIDTH\n", - " value: '128'\n", - " - name: IMAGE_HEIGHT\n", - " value: '128'\n", - " - name: version\n", - " value: '1.0'\n", - " - name: MODEL_PATH\n", - " value: /model/\n", - " handler: infer:handler\n", - " runtime: python:3.6\n", - " volumes:\n", - " - volume:\n", - " flexVolume:\n", - " driver: v3io/fuse\n", - " options:\n", - " accessKey: 1e52ff93-a541-4880-abf1-d9b948af77de\n", - " container: users\n", - " subPath: /iguazio/demos/gpu/horovod/cpu/image-classification/cats_dogs/model\n", - " name: fs\n", - " volumeMount:\n", - " mountPath: /model\n", - " name: fs\n", - "\n", - "Code:\n", - "# Generated by nuclio.export.NuclioExporter on 2019-07-02 07:06\n", - "\n", - "import numpy as np \n", - "from tensorflow import keras\n", - "from keras.models import load_model\n", - "from keras.preprocessing import image\n", - "from keras.preprocessing.image import load_img\n", - "import json\n", - "import requests\n", - "\n", - "import os\n", - "from os import environ, path\n", - "from tempfile import mktemp\n", - "\n", - "model_file = environ['MODEL_PATH']\n", - "prediction_map_file = environ['PREDICTION_MAP_PATH']\n", - "\n", - "IMAGE_WIDTH = int(environ['IMAGE_WIDTH'])\n", - "IMAGE_HEIGHT = int(environ['IMAGE_HEIGHT'])\n", - "\n", - "def init_context(context): \n", - " context.model = load_model(model_file)\n", - " with open(prediction_map_file, 'r') as f:\n", - " context.prediction_map = json.load(f)\n", - "\n", - "def download_file(context, url, target_path):\n", - " with requests.get(url, stream=True) as response:\n", - " response.raise_for_status()\n", - " with open(target_path, 'wb') as f:\n", - " for chunk in response.iter_content(chunk_size=8192):\n", - " if chunk:\n", - " f.write(chunk)\n", - "\n", - " context.logger.info_with('Downloaded file',url=url)\n", - "\n", - "def handler(context, event):\n", - " tmp_file = mktemp()\n", - " image_url = event.body.decode('utf-8').strip()\n", - " download_file(context, image_url, tmp_file)\n", - " \n", - " img = load_img(tmp_file, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n", - " x = image.img_to_array(img)\n", - " x = np.expand_dims(x, axis=0)\n", - "\n", - " images = np.vstack([x])\n", - " predicted_probability = context.model.predict_proba(images, batch_size=10)\n", - " predicted_class = list(zip(predicted_probability, map(lambda x: '1' if x >= 0.5 else '0', predicted_probability)))\n", - " actual_class = [(context.prediction_map[x[1]],x[0][0]) for x in predicted_class] \n", - " os.remove(tmp_file)\n", - " result = {'class':actual_class[0][0], 'dog-probability':float(actual_class[0][1])}\n", - " return json.dumps(result)\n", - "\n", - "\n" - ] - } - ], - "source": [ - "%nuclio show" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Prepare to Deploy the Function\n", - "\n", - "Before you deploy the function, open a Jupyter terminal and run the following command:\n", - "\n", - "`pip install --upgrade nuclio-jupyter`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Deploy the Function\n", - "\n", - "Run the following command to deploy the function:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[nuclio.deploy] 2019-07-02 07:07:08,424 project name not found created new (ai)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0702 07:07:08.424754 140252009395584 deploy.py:317] project name not found created new (ai)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[nuclio.deploy] 2019-07-02 07:07:09,507 (info) Building processor image\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0702 07:07:09.507237 140252009395584 deploy.py:274] (info) Building processor image\n" - ] - } - ], - "source": [ - "%nuclio deploy -n cats-dogs -p ai -c" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Test the Function" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Run a test with the new function. Replace \"function URL:port\" with the actual URL and port number.\n", - "# To get the function's URL, in the platform dashboard, navigate to the function page - Functions > ai > cats-dogs - and select the 'Status' tab.\n", - "!curl -X POST -d \"https://s3.amazonaws.com/iguazio-sample-data/images/catanddog/cat.123.jpg\" " - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/demos/gpu/horovod/cpu/image-classification/horovod_train_cats_n_dogs.py b/demos/gpu/horovod/cpu/image-classification/horovod_train_cats_n_dogs.py deleted file mode 100644 index f00b9973..00000000 --- a/demos/gpu/horovod/cpu/image-classification/horovod_train_cats_n_dogs.py +++ /dev/null @@ -1,177 +0,0 @@ -from __future__ import print_function -import os -import sys -import json -import keras -from keras.datasets import mnist -from keras.models import Sequential -from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, Activation, BatchNormalization -from keras.preprocessing.image import ImageDataGenerator -from keras import backend as K -import tensorflow as tf -import horovod.keras as hvd -import pandas as pd -from sklearn.model_selection import train_test_split - -# Get the images path -DATA_PATH = sys.argv[1] -HOROVOD_DIR = sys.argv[2] - -epochs = 6 -batch_size = 64 -os.environ["CUDA_VISIBLE_DEVICES"]="-1" - -# Define image parameters -IMAGE_WIDTH=128 -IMAGE_HEIGHT=128 -IMAGE_SIZE=(IMAGE_WIDTH, IMAGE_HEIGHT) -IMAGE_CHANNELS=3 # RGB color - -# Create a file-names list (JPG image-files only) -filenames = [file for file in os.listdir(DATA_PATH + "/cats_n_dogs/") if file.endswith('jpg')] -categories = [] - -# Create a categories and prediction classes map -categories_map = { - 'dog': 1, - 'cat': 0, -} - -# Create a pandas DataFrame for the full sample -for filename in filenames: - category = filename.split('.')[0] - categories.append([categories_map[category]]) - -df = pd.DataFrame({ - 'filename': filenames, - 'category': categories -}) -df['category'] = df['category'].astype('str'); - -# Prepare, test, and train the data -train_df, validate_df = train_test_split(df, test_size=0.20, random_state=42) -train_df = train_df.reset_index(drop=True) -validate_df = validate_df.reset_index(drop=True) -train_df['category'] = train_df['category'].astype('str'); -total_train = train_df.shape[0] -total_validate = validate_df.shape[0] - -total_train = train_df.shape[0] -total_validate = validate_df.shape[0] - -# Horovod: initialize Horovod. -hvd.init() - -# Horovod: pin GPU to be used to process local rank (one GPU per process). -config = tf.ConfigProto() -K.set_session(tf.Session(config=config)) - - -model = Sequential() - -model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS))) -model.add(BatchNormalization()) -model.add(MaxPooling2D(pool_size=(2, 2))) -model.add(Dropout(0.25)) - -model.add(Conv2D(64, (3, 3), activation='relu')) -model.add(BatchNormalization()) -model.add(MaxPooling2D(pool_size=(2, 2))) -model.add(Dropout(0.25)) - -model.add(Conv2D(128, (3, 3), activation='relu')) -model.add(BatchNormalization()) -model.add(MaxPooling2D(pool_size=(2, 2))) -model.add(Dropout(0.25)) - -model.add(Flatten()) -model.add(Dense(512, activation='relu')) -model.add(BatchNormalization()) -model.add(Dropout(0.5)) -model.add(Dense(1, activation='sigmoid')) - - -# Horovod: adjust learning rate based on number of GPUs. -opt = keras.optimizers.Adadelta(lr=1.0 * hvd.size()) - -# Horovod: add Horovod Distributed Optimizer. -opt = hvd.DistributedOptimizer(opt) - -model.compile(loss='binary_crossentropy', - optimizer=opt, - metrics=['accuracy']) - -model.summary() - -callbacks = [ - # Horovod: broadcast initial variable states from rank 0 to all other processes. - # This is necessary to ensure consistent initialization of all workers when - # training is started with random weights or restored from a checkpoint. - hvd.callbacks.BroadcastGlobalVariablesCallback(0), - - # Horovod: average metrics among workers at the end of every epoch. - # Note: This callback must be in the list before the ReduceLROnPlateau, - # TensorBoard or other metrics-based callbacks. - hvd.callbacks.MetricAverageCallback(), - - # Horovod: using `lr = 1.0 * hvd.size()` from the very beginning leads to worse final - # accuracy. Scale the learning rate `lr = 1.0` ---> `lr = 1.0 * hvd.size()` during - # the first five epochs. See https://arxiv.org/abs/1706.02677 for details. - hvd.callbacks.LearningRateWarmupCallback(warmup_epochs=5, verbose=1), - - # Reduce the learning rate if training plateaues. - keras.callbacks.ReduceLROnPlateau(patience=10, verbose=1), -] - -# Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them. -if hvd.rank() == 0: - callbacks.append(keras.callbacks.ModelCheckpoint(HOROVOD_DIR + '/checkpoints/checkpoint-{epoch}.h5')) - -# Set up ImageDataGenerators to do data augmentation for the training images. -train_datagen = ImageDataGenerator( - rotation_range=15, - rescale=1./255, - shear_range=0.1, - zoom_range=0.2, - horizontal_flip=True, - width_shift_range=0.1, - height_shift_range=0.1 -) -train_generator = train_datagen.flow_from_dataframe( - train_df, - DATA_PATH + "/cats_n_dogs/", - x_col = 'filename', - y_col = 'category', - target_size = IMAGE_SIZE, - class_mode = 'binary', - batch_size = batch_size -) - -validation_datagen = ImageDataGenerator(rescale=1./255) -validation_generator = validation_datagen.flow_from_dataframe( - validate_df, - DATA_PATH + "/cats_n_dogs/", - x_col = 'filename', - y_col = 'category', - target_size = IMAGE_SIZE, - class_mode = 'binary', - batch_size = batch_size -) - -# Train the model -history = model.fit_generator( - train_generator, - steps_per_epoch=total_train // batch_size, - callbacks=callbacks, - epochs=epochs, - verbose=1, - validation_data=validation_generator, - validation_steps=total_validate // batch_size -) - -#save the model only on worker 0 to prevent failures ("cannot lock file") -if hvd.rank() == 0: - model.save(HOROVOD_DIR + '/cats_dogs.hd5') - -print(pd.DataFrame(history.history)) - diff --git a/demos/gpu/horovod/image-classification/01-load-data-cats-n-dogs.ipynb b/demos/gpu/horovod/image-classification/01-load-data-cats-n-dogs.ipynb deleted file mode 100644 index 9081de7b..00000000 --- a/demos/gpu/horovod/image-classification/01-load-data-cats-n-dogs.ipynb +++ /dev/null @@ -1,520 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Load Cats and Dogs Images" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "fe76d1d1ded592430e7548feacfa38dc42f085d9" - }, - "source": [ - "## Install Packages" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install --upgrade keras==2.2.4\n", - "!pip install --upgrade tensorflow==1.13.1 \n", - "!pip install --upgrade 'numpy<1.15.0'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note:** After running the pip command you should restart the Jupyter kernel.
\n", - "> To restart the kernel, click on the kernel-restart button in the notebook menu toolbar (the refresh icon next to the **Code** button)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Import Library" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19", - "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Using TensorFlow backend.\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n", - "/User/.pythonlibs/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", - " np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n" - ] - } - ], - "source": [ - "# This Python 3 environment comes with many helpful analytics libraries installed.\n", - "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python.\n", - "# For example, here are several helpful packages to load:\n", - "\n", - "import numpy as np # linear algebra\n", - "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n", - "from keras.preprocessing.image import load_img\n", - "\n", - "# Input data files are available in the \"../input/\" directory.\n", - "# For example, running the following (by selecting 'Run' or pressing Shift+Enter) will list the files in the input directory:\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import random\n", - "\n", - "import os\n", - "import zipfile\n", - "\n", - "# Define locations\n", - "BASE_PATH = os.getcwd()\n", - "DATA_PATH = BASE_PATH + \"/cats_and_dogs_filtered/\"\n", - "!mkdir model\n", - "MODEL_PATH = BASE_PATH + '/model/'\n", - "\n", - "# Define image parameters\n", - "FAST_RUN = False\n", - "IMAGE_WIDTH=128\n", - "IMAGE_HEIGHT=128\n", - "IMAGE_SIZE=(IMAGE_WIDTH, IMAGE_HEIGHT)\n", - "IMAGE_CHANNELS=3 # RGB color\n", - "\n", - "# Any results you write to the current directory are saved as output." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/User/demos/gpu/horovod/image-classification/cats_and_dogs_filtered/catsndogs.zip'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "DATA_PATH + 'catsndogs.zip'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Download the Data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " % Total % Received % Xferd Average Speed Time Time Time Current\n", - " Dload Upload Total Spent Left Speed\n", - "100 65.2M 100 65.2M 0 0 13.9M 0 0:00:04 0:00:04 --:--:-- 15.3M\n" - ] - } - ], - "source": [ - "!mkdir cats_and_dogs_filtered\n", - "# Download a sample stocks file from Iguazio demo bucket in AWS S3\n", - "!curl -L \"iguazio-sample-data.s3.amazonaws.com/catsndogs.zip\" > ./cats_and_dogs_filtered/catsndogs.zip" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "zip_ref = zipfile.ZipFile(DATA_PATH + 'catsndogs.zip', 'r')\n", - "zip_ref.extractall('cats_and_dogs_filtered')\n", - "zip_ref.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "7335a579cc0268fba5d34d6f7558f33c187eedb3" - }, - "source": [ - "## Prepare the Traning Data" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import json" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def build_prediction_map(categories_map):\n", - " return {v:k for k ,v in categories_map.items()}" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0", - "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a" - }, - "outputs": [], - "source": [ - "# Create a file-names list (JPG image-files only)\n", - "filenames = [file for file in os.listdir(DATA_PATH+\"/cats_n_dogs\") if file.endswith('jpg')]\n", - "categories = []\n", - "\n", - "# Categories and prediction-classes map\n", - "categories_map = {\n", - " 'dog': 1,\n", - " 'cat': 0,\n", - "}\n", - "prediction_map = build_prediction_map(categories_map)\n", - "with open(MODEL_PATH + 'prediction_classes_map.json', 'w') as f:\n", - " json.dump(prediction_map, f)\n", - "\n", - "# Create a pandas DataFrame for the full sample\n", - "for filename in filenames:\n", - " category = filename.split('.')[0]\n", - " categories.append([categories_map[category]])\n", - "\n", - "df = pd.DataFrame({\n", - " 'filename': filenames,\n", - " 'category': categories\n", - "})\n", - "df['category'] = df['category'].astype('str');" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "_uuid": "915bb9ba7063ab4d5c07c542419ae119003a5f98" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
filenamecategory
0cat.0.jpg[0]
1cat.1.jpg[0]
2cat.10.jpg[0]
3cat.100.jpg[0]
4cat.101.jpg[0]
\n", - "
" - ], - "text/plain": [ - " filename category\n", - "0 cat.0.jpg [0]\n", - "1 cat.1.jpg [0]\n", - "2 cat.10.jpg [0]\n", - "3 cat.100.jpg [0]\n", - "4 cat.101.jpg [0]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "_uuid": "72bf69e817f67f5a2eaff8561217e22077248553" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
filenamecategory
1995dog.995.jpg[1]
1996dog.996.jpg[1]
1997dog.997.jpg[1]
1998dog.998.jpg[1]
1999dog.999.jpg[1]
\n", - "
" - ], - "text/plain": [ - " filename category\n", - "1995 dog.995.jpg [1]\n", - "1996 dog.996.jpg [1]\n", - "1997 dog.997.jpg [1]\n", - "1998 dog.998.jpg [1]\n", - "1999 dog.999.jpg [1]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.tail()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "a999484fc35b73373fafe2253ae9db7ff46fdb90" - }, - "source": [ - "## Check the Total Image Count\n", - "\n", - "Check the total image count for each category.
\n", - "The data set has 12,000 cat images and 12,000 dog images." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "_uuid": "fa26f0bc7a6d835a24989790b20f3c6f32946f45" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df['category'].value_counts().plot.bar()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "_uuid": "400a293df3c8499059d9175f3915187074efd971" - }, - "source": [ - "## Display the Sample Image" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "_uuid": "602b40f7353871cb161c60b5237f0da0096b2f47" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sample = random.choice(filenames)\n", - "image = load_img(DATA_PATH+\"/cats_n_dogs/\"+sample)\n", - "plt.imshow(image)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/demos/gpu/horovod/image-classification/02-train-with-horovod-cats-n-dogs.ipynb b/demos/gpu/horovod/image-classification/02-train-with-horovod-cats-n-dogs.ipynb deleted file mode 100644 index 7cb681f7..00000000 --- a/demos/gpu/horovod/image-classification/02-train-with-horovod-cats-n-dogs.ipynb +++ /dev/null @@ -1,212 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install git+https://github.com/v3io/v3io-gputils" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "!rm -f {os.path.join(os.getcwd(), 'model', 'cats_dogs.hd5')}\n", - "!mkdir {os.path.join(os.getcwd(), 'checkpoints')}" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "HOROVOD_JOB_NAME = \"horovod-cats-n-dogs\"" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'apiVersion': 'kubeflow.org/v1alpha1',\n", - " 'kind': 'MPIJob',\n", - " 'metadata': {'creationTimestamp': '2019-09-18T11:59:45Z',\n", - " 'generation': 1,\n", - " 'name': 'horovod-cats-n-dogs',\n", - " 'namespace': 'default-tenant',\n", - " 'resourceVersion': '2002259',\n", - " 'selfLink': '/apis/kubeflow.org/v1alpha1/namespaces/default-tenant/mpijobs/horovod-cats-n-dogs',\n", - " 'uid': 'ce99b2ad-da0b-11e9-a796-02e0e01c020a'},\n", - " 'spec': {'replicas': 1,\n", - " 'template': {'spec': {'containers': [{'command': ['mpirun',\n", - " 'python',\n", - " '/User/demos/gpu/horovod/image-classification/horovod_train_cats_n_dogs.py',\n", - " '/User/demos/gpu/horovod/image-classification/cats_and_dogs_filtered',\n", - " '/User/demos/gpu/horovod/image-classification'],\n", - " 'image': 'iguaziodocker/horovod:0.1.1',\n", - " 'name': 'horovod-cats-n-dogs',\n", - " 'resources': {'limits': {'nvidia.com/gpu': 1}},\n", - " 'securityContext': {'capabilities': {'add': ['IPC_LOCK']}},\n", - " 'volumeMounts': [{'mountPath': '/User',\n", - " 'name': 'v3io'}],\n", - " 'workingDir': '/User'}],\n", - " 'volumes': [{'flexVolume': {'driver': 'v3io/fuse',\n", - " 'options': {'accessKey': 'bd182781-6b24-4899-b2b7-a84608931aeb',\n", - " 'container': 'users',\n", - " 'subPath': '/iguazio'}},\n", - " 'name': 'v3io'}]}}}}\n" - ] - } - ], - "source": [ - "from v3io_gputils.mpijob import MpiJob\n", - "\n", - "job = MpiJob(HOROVOD_JOB_NAME, 'iguaziodocker/horovod:0.1.1', [os.path.join(os.getcwd(), 'horovod_train_cats_n_dogs.py'),\n", - " os.path.join(os.getcwd(), 'cats_and_dogs_filtered'),\n", - " os.getcwd()])\n", - "\n", - "job.replicas(1).gpus(1)\n", - "job.submit()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "horovod-cats-n-dogs-launcher-ghqw6 0/1 PodInitializing 0 4s\n", - "horovod-cats-n-dogs-worker-0 1/1 Running 0 8s\n" - ] - } - ], - "source": [ - "\n", - "!kubectl get pods | grep $HOROVOD_JOB_NAME" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "apiVersion: kubeflow.org/v1alpha1\n", - "kind: MPIJob\n", - "metadata:\n", - " creationTimestamp: 2019-09-18T11:59:45Z\n", - " generation: 4\n", - " name: horovod-cats-n-dogs\n", - " namespace: default-tenant\n", - " resourceVersion: \"2002304\"\n", - " selfLink: /apis/kubeflow.org/v1alpha1/namespaces/default-tenant/mpijobs/horovod-cats-n-dogs\n", - " uid: ce99b2ad-da0b-11e9-a796-02e0e01c020a\n", - "spec:\n", - " backoffLimit: 6\n", - " replicas: 1\n", - " template:\n", - " metadata:\n", - " creationTimestamp: null\n", - " spec:\n", - " containers:\n", - " - command:\n", - " - mpirun\n", - " - python\n", - " - /User/demos/gpu/horovod/image-classification/horovod_train_cats_n_dogs.py\n", - " - /User/demos/gpu/horovod/image-classification/cats_and_dogs_filtered\n", - " - /User/demos/gpu/horovod/image-classification\n", - " image: iguaziodocker/horovod:0.1.1\n", - " name: horovod-cats-n-dogs\n", - " resources:\n", - " limits:\n", - " nvidia.com/gpu: \"1\"\n", - " securityContext:\n", - " capabilities:\n", - " add:\n", - " - IPC_LOCK\n", - " volumeMounts:\n", - " - mountPath: /User\n", - " name: v3io\n", - " workingDir: /User\n", - " volumes:\n", - " - flexVolume:\n", - " driver: v3io/fuse\n", - " options:\n", - " accessKey: bd182781-6b24-4899-b2b7-a84608931aeb\n", - " container: users\n", - " subPath: /iguazio\n", - " name: v3io\n", - "status:\n", - " launcherStatus: Active\n", - " startTime: 2019-09-18T11:59:49Z\n", - " workerReplicas: 1\n" - ] - } - ], - "source": [ - "!kubectl get mpijob $HOROVOD_JOB_NAME -o yaml" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'apiVersion': 'v1',\n", - " 'details': {'group': 'kubeflow.org',\n", - " 'kind': 'mpijobs',\n", - " 'name': 'horovod-cats-n-dogs',\n", - " 'uid': '1b58dd58-9c97-11e9-98d3-d8c4972b0204'},\n", - " 'kind': 'Status',\n", - " 'metadata': {},\n", - " 'status': 'Success'}\n" - ] - } - ], - "source": [ - "job.delete()" - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/demos/gpu/horovod/image-classification/03-infer.ipynb b/demos/gpu/horovod/image-classification/03-infer.ipynb deleted file mode 100644 index 115b2af6..00000000 --- a/demos/gpu/horovod/image-classification/03-infer.ipynb +++ /dev/null @@ -1,548 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create and Test a Model-Serving Nuclio Function\n", - "\n", - "This notebook demonstrates how to write an inference server, test it, and turn it into an auto-scaling Nuclio serverless function.\n", - "\n", - "- [Initialize Nuclio Emulation, Environment Variables, and Configuration](#image-class-infer-init-func)\n", - "- [Create and Load the Model and Set Up the Function Handler](#image-class-infer-create-n-load-model-n-set-up-func-handler)\n", - "- [Trigger the Function](#image-class-infer-func-trigger)\n", - "- [Prepare to Deploy the Function](#image-class-infer-func-deploy-prepare)\n", - "- [Deploy the Function](#image-class-infer-func-deploy)\n", - "- [Test the Function](#image-class-infer-func-test)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Initialize Nuclio Emulation, Environment Variables, and Configuration\n", - "\n", - "> **Note:** Use `# nuclio: ignore` for sections that don't need to be copied to the function." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# nuclio: ignore\n", - "import nuclio\n", - "import random\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: setting 'IMAGE_WIDTH' environment variable\n", - "%nuclio: setting 'IMAGE_HEIGHT' environment variable\n", - "%nuclio: setting 'version' environment variable\n" - ] - } - ], - "source": [ - "%%nuclio env\n", - "IMAGE_WIDTH = 128\n", - "IMAGE_HEIGHT = 128\n", - "version = 1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: setting 'MODEL_PATH' environment variable\n", - "%nuclio: setting 'PREDICTION_MAP_PATH' environment variable\n" - ] - } - ], - "source": [ - "%nuclio env -c MODEL_PATH=/model/\n", - "%nuclio env -l MODEL_PATH=/User/demos/gpu/horovod/image-classification/cats_dogs.hd5\n", - "%nuclio env -l PREDICTION_MAP_PATH=./model/prediction_classes_map.json" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "%%nuclio cmd -c\n", - "pip install keras==2.2.4\n", - "pip install tensorflow==1.13.1 \n", - "pip install 'numpy<1.15.0'\n", - "pip install requests\n", - "pip install pillow" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: setting spec.build.baseImage to 'python:3.6-jessie'\n" - ] - } - ], - "source": [ - "%%nuclio config \n", - "spec.build.baseImage = \"python:3.6-jessie\"" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mounting volume path /model as ~/demos/gpu/horovod/image-classification/cats_dogs/model\n" - ] - } - ], - "source": [ - "%nuclio mount /model ~/demos/gpu/horovod/image-classification/cats_dogs/model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Create and Load the Model and Set Up the Function Handler" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Using TensorFlow backend.\n" - ] - } - ], - "source": [ - "import numpy as np \n", - "from tensorflow import keras\n", - "from keras.models import load_model\n", - "from keras.preprocessing import image\n", - "from keras.preprocessing.image import load_img\n", - "import json\n", - "import requests\n", - "\n", - "import os\n", - "from os import environ, path\n", - "from tempfile import mktemp" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "model_file = environ['MODEL_PATH']\n", - "prediction_map_file = environ['PREDICTION_MAP_PATH']\n", - "\n", - "# Set image parameters\n", - "IMAGE_WIDTH = int(environ['IMAGE_WIDTH'])\n", - "IMAGE_HEIGHT = int(environ['IMAGE_HEIGHT'])\n", - "\n", - "# load model\n", - "def init_context(context): \n", - " context.model = load_model(model_file)\n", - " with open(prediction_map_file, 'r') as f:\n", - " context.prediction_map = json.load(f)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def download_file(context, url, target_path):\n", - " with requests.get(url, stream=True) as response:\n", - " response.raise_for_status()\n", - " with open(target_path, 'wb') as f:\n", - " for chunk in response.iter_content(chunk_size=8192):\n", - " if chunk:\n", - " f.write(chunk)\n", - "\n", - " context.logger.info_with('Downloaded file',url=url)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def handler(context, event):\n", - " tmp_file = mktemp()\n", - " image_url = event.body.decode('utf-8').strip()\n", - " download_file(context, image_url, tmp_file)\n", - " \n", - " img = load_img(tmp_file, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n", - " x = image.img_to_array(img)\n", - " x = np.expand_dims(x, axis=0)\n", - "\n", - " images = np.vstack([x])\n", - " predicted_probability = context.model.predict_proba(images, batch_size=10)\n", - " predicted_class = list(zip(predicted_probability, map(lambda x: '1' if x >= 0.5 else '0', predicted_probability)))\n", - " actual_class = [(context.prediction_map[x[1]],x[0][0]) for x in predicted_class] \n", - " os.remove(tmp_file)\n", - " result = {'class':actual_class[0][0], 'dog-probability':float(actual_class[0][1])}\n", - " return json.dumps(result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Trigger the Function" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Logging before flag parsing goes to stderr.\n", - "W0702 07:05:39.756876 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:529: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n", - "\n", - "W0702 07:05:39.784578 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:4420: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n", - "\n", - "W0702 07:05:39.814317 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:250: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n", - "\n", - "W0702 07:05:39.814856 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:178: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n", - "\n", - "W0702 07:05:39.815345 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:185: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n", - "\n", - "W0702 07:05:39.920376 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:2029: The name tf.nn.fused_batch_norm is deprecated. Please use tf.compat.v1.nn.fused_batch_norm instead.\n", - "\n", - "W0702 07:05:39.987011 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:4255: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n", - "\n", - "W0702 07:05:39.994644 140252009395584 deprecation.py:506] From /User/.pythonlibs/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:3721: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n", - "W0702 07:05:40.865994 140252009395584 deprecation_wrapper.py:119] From /User/.pythonlibs/lib/python3.6/site-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n", - "\n", - "W0702 07:05:40.875694 140252009395584 deprecation.py:323] From /User/.pythonlibs/lib/python3.6/site-packages/tensorflow/python/ops/nn_impl.py:180: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Use tf.where in 2.0, which has the same broadcast rule as np.where\n" - ] - } - ], - "source": [ - "# nuclio: ignore\n", - "init_context(context)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python> 2019-07-02 07:06:07,287 [info] Downloaded file: {'url': 'https://s3.amazonaws.com/iguazio-sample-data/images/catanddog/dog.391.jpg'}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0702 07:06:07.287323 140252009395584 logger.py:100] Downloaded file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\"class\": \"dog\", \"dog-probability\": 1.0}\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD7CAYAAABqkiE2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOy9eaxk2Xkf9jt3qVt71dv79d49PcOZ4XAojkiG2mVRlgxJiSJAsmQbhhwrIZxYAoPIiGQHAQIrQRwgiUMgQJKJ7UABiFASI4m0FmuhSTCkREokJZLDGTZnpqdnen177cvdTv443/edc2+97iZnONQzuj5gpl7funW2e8/59t+ntNZY0pKW9PCS91c9gCUtaUl/tbQ8BJa0pIeclofAkpb0kNPyEFjSkh5yWh4CS1rSQ07LQ2BJS3rI6U07BJRSf0MpdVUp9ZJS6pffrH6WtKQlvTFSb0acgFLKB/A1AH8dwE0Afw7gb2mtn/+md7akJS3pDVHwJrX7bgAvaa2vAYBS6kMAfhzAsYdAs9nQq6srX3fjSikAgOd58DxF14xQk2UZ0jSV7wEgzzXd86CWjzsQlfP/hYEAAALfhy79tni2Fr9TypM58JjyXIMP5DRNAABx4gMA9vb34Smv0FaW5dLGceOVfx17yNtrWueFn7lN8t8K5p5ca1lvd0153PaauScMA1SrtYXxydx1Jl2nSUzzMs8O9Oxm8wR5aQpKeYgqpt1ms236znLwErXbTXOfl0ub8/lc+gcAD0rGzeOpVmvY3d0x/c5mhT4Lyyjr4q516fkv3n5PKj8jz/elDV7TLM+ddsstqoX+j6d8X2u9Ub76Zh0CZwDccP59E8C/596glHofgPcBwMpKF7/4i/+w8FLbTVL8BIAwDAEAlUoFtVqNrkUAgOFwiL29PQBAvV4HAMSxecH4ULgXeUgXrt1vHD49rE6ng5weEn+fZJncl9Hf/F2lUkGlUilcm8/ncnjt7u4CAG7sdAAAzz77LKqRmQv3Mx5PZD5G8DKk8+ILUqH7gRxQ2v4NQOsMSTqluZi2gtBu6iCga8FIxlitVgHYTRIEgawvbzR+PltbW3jyyScL49GqipDGHSQDc7/KcbDzGgDgqNcz46H5PvfyDUwT/q35XRQ0cfHsEwCA7/muv0HrMUZUM/P6gfd+l5l7zcytP9jHq6++SiMwbVSyCpIkKYz3ySefxAc+8AEAwNWrVwvjzpznyc8sCOz24efCa+dK2PyeuNfcv6tZUuir2myZPpWP0dSsc388o2sKGXweCH36WDgpj6N88Opxl9+sQ+C4w6/IG7V+FsCzAHD+/FmtlDr2EDju3/zye57nXCdulafIaFE1cZo8N5vL98MHDFrx2BY2Lj9wpRY5iOmjeAg86EA77kDiNrjvwzsvAwCaYYLAGzuzBIKqRhh6Ml7+vdbFdfMVS0NqgesDCu1Kg/62B4RGJn8DQDUy3DaqJPbgoRex1WrJ5nfHAZgD6bVXbxbGc+7iFQwGZvPXPXr5Q4Vq3fSxUTGb34/MYbNyOEad16M3oZHG+I7vfCcAYDw5Mm01mvinv/JfAQDu7FwHAPz+H/w6ACNZHR4MAQCV0LT/yJlNvPTSS6Yv2qSXL11Cu2U2YJrwO+SubfG5TycTmdfxUlnxu3sdAlFk3stqvVa4P0kSWUtedw0rMebyzBS8B8ob9t0p05t1CNwEcM7591kAt+/3g3sdAvzJDwqwC+L7vr1OG11niYiZ9arhtr76ekQlAMRFPd9HQBxPvspz+QyIc/DBEIUhtMMpzLjdfxSv+QrwUOQYeZogI5E4mZtT/5XnPwUA6FRG0j9IHA+bIbKMRMWU5ufbdeI1GvI+qzjrq+yLPZ0OC/ODyh3OZeY0n9n5suRVqZj16XZXZVMPh8PChCuVKqKoVlirnTu7mI6NZDHpGYmnUa9ipWUOozgza3Dw2h0AwPrGJkJSKd5Kon+tonB4cAsAcOHcWwAAv/Ir/xS/87sfAQDs7ZvvXvzqiwCAXq+Hr77wiulzbN6TP/69D+F3Pmruv3HDCK2/+eHfkAMtCgNag3sfArWoAiZZv2P+XZYSyn+ntF7DsZFcMk0HvuchSc1vfVo/nQOaGQ63oXLoN2Djf7O8A38O4FGl1CWlVAXAzwD46JvU15KWtKQ3QG+KJKC1TpVSPw/gDwD4AP6V1vor9/vNcWK0S3meCzdhHQ6A6NajnhELQz8QETjwDEdTFWMv8H1/UWTVWv6OqqxjK8eoaL6LY1YPNEKfOAFJGlHoQ2emL9YzM0el4D75NPc9IJ6zLm5+N5uORbce9M1cJpNDAIDnxahUzG+ZU2VZjDAw84JOaGw+WE3Nc3Ot2TJGsn6/L33N46nMjVUlHuvFixcwnU6LfaUk8USRrD3bL9j+AhgbgLtmYRjKOnL7rvq7sm7uDwIPcW6+7w2pb5JyMBxDj4xkpDwzjnFvhOnESArf9jajFnz5S3+BV6591bQXmuczHhkJpX/UAwkYmI7MnFZWu9jdM0bA/YM9GW+SmhsbjUZxDfJ00ZBYa2A0GsnaAEB/aLj4SqclkhG/o55n3z/XxpCQMZTbzUkyyLJMpDZN93gKYjRl0kpDl9SB47x+32p1AFrr3wPwe29W+0ta0pK+OfSmHQLfKN1LEnCvl62slUpFOM18OpFr114yuuCrr1wDgAXjituG1tbQ4nvWuMd9lY06WuuCYZLvYS7OfW2fPi3cYWXFuD89bThC7ikkfD/1MxkOcHhoOP8X/vzPAABhwxixQp2DVcwwIClIe2KbyOYkfWQZJikbQ3Nqd9/8LgxFh2zWmrJWFy9eBADs7+/L2lTbjcKce4OJzIM5H2uSm5ubIhWwvYC5XLValXGwN6HZsC7DHnkCBuORSB+XH3lL4f6jowORAG/fNLr+6fUV+MT5PvaHfwQA+OQn/i1m874Z56qZ381b1wEA9VobZ0+fAgD8q//zvwcA/Ovf/i3cvmE8EivdLgDjYVjtGLsDj8cn202z3ZJ5sbQXTydyP0sMF8+conEfYXtzo/DdeDyWudcc79AkJnsWfSfvmnNRs+dKL7q6lQa8wKyra7vith4UC7QMG17Skh5yOhGSgOsZuJ9t4H6SAFuy9/d3EYZ+4Xei8xNnPq5/wJ7697vHJeYMaZKiSnYHHs/+/r70y64o5phJkggXdH3sPD7mtju9jOZdld+yfjkeTZEM2UVl7RccMxCGxnq/vdmW73j9zp45L2M9ODgAALTr6wCARsPqss2m4ajVWl/GurG+CcBa+0cj67kIW2Zs1cjx5JBO22wYqSWexqi3zJhS0vsrUQ1nzpu+XnvtulkjWpdK6En7Z0+fNm1VWhgrDuYxcx8MBvB885ujntHxa3Wy2UQKP/ojP0TrYLj4r33oQ+h2TBxGRmsb+D5i4trsKuTno5QSXdyjZ1Cv1WSt1tbWZJ0BYGN9XdaIXYnNRkNsKixNJEki19jlJ9w8tVp8wM9Y3UOzp/c/IO+Razfgd3c4zRZ+Zto+CaQBX9Ng2etRuiXLMvilPRoqD9mcAoFobYZHfbTr5oXijRPUA2lDujzWXaMWrrHf3Y3FSHP+jmIH/Aiz1DHmABgnM3mB4jk/cPNdvz9Empg26Bb0ezHSlDe12UQB6IWZJTKOCYnJs+lMxEx+AYMgsCInjSMi11sURbLh104bMfXu3buotMxhwRv+8PAQ9ZZRQ85ePgsAODrsyNz4pWfRf/v0eemT14zVGt/30aLNNJmwulbF4KhXuL8WVpBOzLwubBvPMs+t3++Lka7bNmL7fDrDKh1GrDaooC3jyOfFt2euQ/zr3/ljAMBvf+QPzJrGMcKGmVeTD99h3wZ0Vc21gNyTs/EIG+vmoMxpbePRCCGtm0eGTZ9/73vY3TFe8YDcjdWogow2a5bNaY0UMtqvEtORWXVT3sPcqqWsGrpGbo+YUNnwuFQHlrSkJT2QToYkoO4dLMTkBgu5AURiAKHbtSr+fdwnUAxftHKAjXSTE5jHQTfl0Mi0jegCgMlwhH7PuKOY+49nU0yn5rRnbsVjnU6njpRQdA+59/PjabVaIlqyuhGGYSFsla+dPXu20F69YUTvIAiwuWmMVgcHRzTWVK7x2N7yli0JDWZuwt91Oh1sbGwU2q9Wq+iSYY3Xgw2haZrKPFdXVwEAvf0D+S1LMNVqVSQF13gGAJcuXUK73Zb7AGA0GIpEcurUKVlT7oOlGv5dlmW4ds0YiY+OzNyn8xnyjHM1zPxq9aYkCbQ4/4Cfe7uNQPI3yNg5HCOqGqkpqlVpbY20NZvPEVJAFXmqobVGSO9xWrHBSBLazUZAWp9MZSIBegG/H/adh0S4esj8YsQqS5PutVl/juNoKQksaUkPOZ0ISUDh/ok65X+7YcPMfex55pX+dj+P4//O3x4bJDTylHUxc8KmGbtcFGZzwyGnFN47Gc9F309z01e1soY6BR9xoA/bKA6PDjCbGc7HHLDXO5QTnjketLEJtJpt4W5sPBwOh0WjFX3Wa5wLYIiNTvv7+5JQxfc3m03hXKzjr62tLQTFPPHEE9Inc32+5+joCB0ysPGzcPMsuH3+rru2Kr9lXd/zPKSU1xBR/Pwaudc4AAmwUkIQBNjaPlWYp1LKBuz0jSGzPxzI7+YUks0ce33zwsLYQs9Ko7NZMelsa2PdujvpmZ29eFlsF/x6zuk98Hwni5X6bjRr1l3dt3YRDc6QKuaCZFngPAvHvZ0vbtvcKxrDj7MD7CxcMXQiDgHgwZs/z/OFpJs8z+UheL6ZSqe7Ill4rbZ5OSUOwFEp3BddROzIqgOclehRlNpR31jsZ9MY/Vt3AQBTEuVbnTV014zFOCA/fui1JAtvMjEvL4vXKytrOKAotZ5EB04kek8MPmIgCtAjdePMmTMAgEuXHpFNwQfJxsbGQpz62qrZTKPhBBPKRDt3zhrftja3qQ+bGNQm6z2360a+cTYeb/xWq+WkDofSLv97nYxpfM94PJbn4Prd10nN4IOBD8y7d+9KGzlnN0YVzGhjMXU6HUSsxtAGa5IPv9ZsICHDHbfrK2B1bbMwjqODQ/EOrK2Y+bGR89XXbuPxxx83362bA2h3dx++oihG8uhUKb9hY20FdTrQhgPTxnQ8RByb9vnd8JSyadQ55Y7E9lCwcSruvlgU4BOKAj1uHy0Ng0ta0pLuSydGEngQHacOuHH/PrlIVtY3sLbJMelmeuWoNf5tmaoRuX7SVIx6MUVzjYjrjsdT7B6Yk12RC69e91AjkIvAJ195pSIGoTRjF6Wif/sLUWRBUIHvmzZ8n42RZk7r65sirrOou7d3gPPnjb//zp071L5GvW44KXPlft9w8Varg1bLcLetrW26PxPxnlWLer0u68YGs+1ts56j0QgXLlwAYDn24eGhGPiYo/LzCYJA1p4zDRuUywA4cfk6hxdQ5ORsWhhPd3VFRPmgQrEGs/lCJieUkmfUoTnxWsVJgia5Klkl8hxVhd+L7ooSSWE8NuvmUX5Gq17HYDCi78wYvUoVgWeey8qakVZYyklmVgXhFHbf92VtOA5Cay0GaRb5RaKa2VRiFzPi6wMQgbRfznAs01ISWNKSHnL6d0YScDMAOWrOdUEp0Wktl5+XDGeZcyK6QRXMkXrEreazGLv7hkv0e4YjPPc85aYfjVCtGb2v2TAcB14NfkBgGASU4fkThMpwkbBCrjYKGur19ySDbW/XxOx7nie59+trhvOurhruEgSBcGw2Grr57ewKazQach9z3lrNjOvChQsSiShx/M2mSA57e/vURhPjsbEFrK9vFO7P81w4qZUWUuGersGRiSMj+bs0z8SA1yadOUkSmVfZuDgYDNCg+3lOnucJl3dzPFha4neCqV6vS5+8Zp3OKqpkRB0NhtL3dFYMfKoJvFeCg8N+YX5rpzfF6NsllyJH8uzenQsuxCFJHKP+geRvMPCN0taol6Vst6DAoyBCIDYxh/vrRd7NvxVgnNwGEuUltKky/TtzCLjRU8epAwr2mjWOFNN72cgHuEhA8twwJkPYYDDEyy8bVJ8BGQRZrJ7PY6ytG9GSN1+z2cT6mtkwLMp53pEkoezskiGRVIzbt287KbhmrJ3OigPrZQ65WtUm8nDEGBvyDg8P4ZFRqkIhwmEQSXox33/mnAm1nUwmcgjwIRrHsSP+jmVt+VCUNGfaGN1ud2HzpWmK27dvF9aZLfq+74txkQ2JnWZd1ogPl/l8Lv57vsaqxaVLl6QNpiRLkXKEHkXjpVmGmLAZQwL7YJXFPZQkjmM4xdbWKZqXiWtI5nN5Zq160UA56B1hn54jj3H/4AAVmsuobw6ojMKSkc4KhmgeD0cUHh5M7Hg4mYgOA79Ca5tkyHNOYS+2VSbtWVxCAMg1x894yB6gPizVgSUt6SGnEyEJaACZuj8un1exEXIBxXVPJhPknDDhJB1oXXS1wbduM4+MbgmLuEiRUTJKf2RO8b2DEW7eMcY/dqsFxG03WmuoUyoui9prK6sIybAViPsrQJ7xiU5JLn1z+h8c9NEiVxLDdJ06dVrE2c1N47q6c9dwnre97W0i/bCr8NIjj8hatVtFFQAANjbNGsWUcHHx4mXhTL3eIS2ZxoiAN6qUX/HyteeFc84oxn86MRLE3bvXhTOGjmFO1C8BPDGSQxRFMqZXXpnLfCVikNSdVquFTVJjmBNzVOPosCfrkU9N31ur6wtgHm5eA78noubFR6ImKXlNMont5/FPp1Ph8jxujn4M63WcunAJgJWaRtOZXY+KkXRA0mamfQtuQziOmQokWckPKQoy0Hjt7n5hHDm5A7UTG5BSzoExIx6DT0mpxqwOuEjI98M/BJaSwJKW9NDTiZAEgAcDjbpAH0xJkjhBPw/uI88tPqsFBglE/7xxw3CG3d1dMQjyOTmdGs4zHIwx6BtuEYbGuHdwcIRHLj8KwOqf83lfOMa1a9cB2Lj1zc1NsSFYo15LuOvly5fN55VLNK4bwpEYU79Ws0CojaaRIEbjAU5vm9wBtjk0Vus0/jFmxGV3SbdNZnMMR0bH1xQR2Ww2kJFufZckkTlBobluVbf2Qxl4he0GjUZD5sf3jEYTsUlwIM5sNkONjHTcJ7vjarWaxP2z7WMWT6U91vGn02nBWAkUjZcWBBXynWvX4Gtlwyc/s8lkIjYPsU05yL8H+7uF362tdITDtrrGhbp395ZweY8kwMlkgkbXvAuSmk7jSR3jb5ay7QtixMqdACI/KD4DyZjV+oEexaUksKQlPeR0IiQBlgIeVHegfK0IA/3gfjzPkyo1AnyZZcKRdu4a7nlwcCg6qZz6iq3+ATyvIu0BJrhHSd4BB8eMxKrNwTRsNVdKoVYtYsyfPXva4T4HNGDz3cpKRzj7I2QLSOJMAndefNF4MhqNOlJG1KRxMPf3PODWLQOtzUOdTEeoVhh4g9xw/SPcukmgrWJxLuYSuOuSZZlcZ+wAlmgGg4GM23p0lKxLGlJwVhyj1/sSAAjc2RNPvBUAcP36dVkXfma7+zvCsZmbj0Yj6fc0gY/YPIDZQiCT50iWzHmNO81megL22UVRJBmUbI+4dfs2ogqPrVhMJkkSsS/UaG29sCregYDC0lPto6GN/SEhwNhKsyLjYemD3Xx5niOOLZwcYDwjw6S0lQVe3oHIu0fM0Ik4BAAuKeYtxL67ySjsS3YjAQWVpTDB8olg/81lrmzE3hDXr18HAOzsGAPNaDSS6C1euClFsgGeiK5hy6c2Rrh167VCj3du7Ugfly6ZzVqhB//UU09hNC7i/b/08lWZF7/gA0KubbVa6HTMBrtxw8Tu12oNXH+V0GQoDj2OZ05+hVm//R0jXo/GA3nZ2S8ehgHqBDrC4ux42BcknIzyINzklAWDrZPPsbNj1CPeXEEQLKA5NRx0HV7bLMvk+fGhMRpNZO68LuMR4RBevozXXjPrbd2/nvRb/q7dbi+gJPueJ2oJt+9iKLJL01V1rOHTrHurWZd5sQrEtLq9ja2tSuG7ztqGHC4S81BtIByQekY4mbOxWYxWo446GZwZ4RrwoGvFCNQk0ZhWO4X58VhNHIdZh6JCZGmpDixpSQ85nRhJwODjLcr0LqeRqLN0sWbgcXBh9pqNnuJTnEXSfr8vJzXH/VfCKnzPnKR5xuIYj8fCtwnScTxFr1/ss9XqYHWVY8bZnUY1EkYj3LptkHPZ6BYEgUSRHR4S8i+pIC6a8WTCEok1rAk4R1QvSAWAxfiLZ7bWIXtV8ywTqK8BuQ3n05lkMzYYeTehdOrULewJWVPJ3yhVP3IjOnldhsOxSHTdjjF21ut1dOhv5pD8nG7duiXtcRHS8XQkfbHhMQxD4fy8HoygnOe5GPi43dWVlYW+Wq3WgvGZyQ1WY7Vna2NF+hS3KqkAcRzbgDR6/o1WBy2aZ6O9Kvff7pNRkXJHElrjW0cDqRXQoFoKoe+hRSjUFYow7XSqUBTMJkJvlasj2SpJzx9aF3JhbsdeXdKSlvTQ0ImQBBgM8TgXlKuTuUaX8n1aL+YFlCUBo3sWDT+jkcW8Z+kgz3M57TmLMI4PpX1rSDKfzzzzTnzxi18E4FTrRY6tU8aQtEbuQEZE3tnZkVBbLcCTifQZUKHROKGMumQmMGQM8HH79h2xHbD7sNvt4sZrt2SuAHDzpjEGhmEoa7S3Z+EluG5jQoCtURTKnIc9IyFNaWnjOBbObsOjvQXJTPRut1YkUaVSlefC620Kb5rvxR5CLsJmsymwYRwzP0+s7cPFVGDbDgddsRG13+8XYNkA896wTYCpWrWoziytiBEzTRfeHaVtxiXXNRiQLePmzZtOZSszp97BgYy31jCSQ73ZwmPvfm9hbHdumSKu069dRUISXX9KIKqzFIOc3bmm7/VWFw2Qq7f07n89QKOv+xBQSp0D8H8DOAUDuvas1voDSqlVAL8G4CKA6wD+ptb66L5tAfB1LojB1D4AgKQgJPMZIiqfnXCt6jSBpthqjs4DIB4ALtjAG80PNPKkqA70egPMplwsg9JMnRdba/PAOQ5day2blV+2r371eQEJYTp/tovOilneJDMHSEKppQcHB5jH5iXnoqJRpYEhleBS9FiabdNPEmuBEJ/NGJQiENCKXo8SVMZHGE9tGXEAqJCXIJtPRO3JYyvSl4umAFZ9GZLqEVJMglJa1jJN7UvmbnqzfqA2fUSRedn5Ba+HNmIwpYPNfJIBmNKzz52/CMDE9fOmu06AJrPpyKICV6ynhsugM6gMp1i7laT52R0e9CR2gL+Loki+Z8Ngo96icdk8iJw8MLfv7so4+H6m9fV1eT8Ekj3wMJuZ9lgVmY76mM7NBudnITkY212ZH79f8/lcVMhKhzAXswmaq2dpvUxkJDOB0WgkaiNgU+ldeiPqQArgF7XWTwB4D4B/qJR6EsAvA/iY1vpRAB+jfy9pSUs6ofS6JQGt9R0Ad+jvoVLqBQBnAPw4gO+n234VwCcA/NIbGiWKeIL8WYgr8FyRh92MxYKgWueYEL49R6bt7uyJ6DmdmvvcgqdlUdfzPItvTyd8lmUL7stTp07JfXfvFrPsxuORFDjlKDjoRNBvGw1z+jPn4XgAwBrCWq0WPLLw8ek/j6fCjXk8U8k56FnDoFNstax2uQVdeC6Jtki27pz5Whn2zV07lj4kTqCpZH07XYsOHEvEIkdcGmnlpZdekt/KPKvWCMj3jUYjUcXKWINufgM/dwXAD7iMHI0NGTTMvGp1W8QWMJiBUbVYOEQjkb/ZPSpp61lWcF/yJ8+d5xkEAZKsLesFWIPmzs5d4eKuq5wlNc5KzfMU49y8wwejoloAAGGtqPaU6ZtiGFRKXQTwDgCfBbBFBwQfFJv3+M37lFKfU0p9bjgaH3fLkpa0pG8BvWHDoFKqCeD/BfCfa60HD8pYYtJaPwvgWQC4eOHcA/GSPM8rRPktjsNxEZaCpVkimEysXnxIEYHD4RhpwtzNfLo5CfzpSiGs6wmnTBLh2qzXDfsjgQnjuO61tRUax1SgvtgtmcSpwHk1m4b7RFV7grNxzAVNvXLFGL5u3jSGpP2D/QLoCGBj3/f3920WZikCz6yfDf4p38eQ92EYLuitrsHWLUnObblFW/ket/QaYPRpzt9nzsuf6+vr0saAdHg34EjqN8SxzLUsDSmlpC+e0+HBnozXjXS8edMEGt2+fbPQRqPRELsQk5HGigZHHs9sZjMMWa/PskzWnMeTJAmUb6Mp3bVqNJrS/mjMdS0Sx5hspTHuK6OAI24jiiLUHEi34+gNHQJKqRDmAPig1vo36fKOUmpba31HKbUNYPfBDRX9sIB9kPygarWaE0JZjCoEbCql53mSAMNqAd8/Gk2wv2/Eq6MjsnxP5/B5IyZD6Vuw4JJiiKZ7jR+k+8CZskzb2olkc/M9I2I+9tjj2KXoRIYqj6ImqlVz/5nTBg241bURadwWW887nc5CEo37orIYyffM53O5TyDNHeKDrV6vFzYxABwO+jJvnrskuaSpPAcWcdngFoahqC88/ngWS/98IGutBRcyITVpJTKHXrvdls3tFp3h9tjAlue5bDYuSMIYgkopAYnhwzrwtXh3OC7DFddt6DPXjJwhSTgd2vTT6azIOrDKxv++fv26qCVu/cHjvF6McFQ+MJPEqpn83EcjG46eU8r8bDaTOoaM1cjPZBbPcfuuMZDei163OqDMSP8lgBe01v+z89VHAfws/f2zAD7yevtY0pKW9ObTG5EEvgvA3wXwZaXUX9K1fwLgnwH4daXUzwF4DcBPPbAl7cJ9HR+bXqlUFqCnigkttmQWR94x1BMb6F588UUxArLonWdKYtKPQ2W1rkIrdbjwZkyu6Gk6DxCGhmNsbXG8gFEHdnZ2BEwEJMGsrq6j0zbfM7afCmwkG2Pvc9ES11AqnF1VZK7ltWo0GvL3VJKKbLw9/87ti9udpVbyYc7ritxlNcCt0Osm5wDASscWN7lw8bK0y7EOCsWaBFprW92X8ApbzZq0y78LgkD6vXHDxEawJDCZ2PRl5s6Hh3eRZkVsxFxnmEyNtJQOi899OqvggCQGbmt9bSp/s1tSjJ6djnBs7rPb7Vo0Yke9PDwquipZejq15UlCGBuXK5XIFjyhpKJ6LQRycFcAACAASURBVMBkSrkI7B9nwOo3M05Aa/0p29UCvff1trukJS3pW0snImIQuHeVFD6lXTdPWWowxPq/Fl2JuQVzPjd3gDnlZDIXg8xx5ZzLfblAnEzH6XrIFDxls+kMsZ0hk1j509vG7XXlyuMSmOIx+ixMP7VaTTh1GNo2y4awg8PDBWnGNZy5xiIeaxmZd2dnR/ri+16lCLYsyxay1Gq1mnAuMeA50gJzStd+wdfYXbeyYgOCqpHRfbk+Qa/XE8Rit0YCp/WKIXY4lHGzbYIlGq01XnnlFQBFac+NEOU1Ldeo4HeiWq3K/HisSZyLtMQ2FTf6tAy24rpTpY0kcaJTGR3bSgscHNamsuxhGBYqNxnSaDYimQPfx33yOL745S/hOFrmDixpSQ85nRhJAChCVTG5YBC2+KPl3HKyUwCF1pnU8GMnwXxm2jg87GFKwUJZal1t7MqrE9CHW4uAYbfEA6m1LVdNWO+B5yP0i263dqcjnKvdMlw/proDa6ubEuLKHCQMQ1ARJdQouCOTmP0ZqhGXsqb49ckQOuesQApdbbWt1T7mgBYKMvEqNi9/aOwiQRDg3LaxavM6pkkiIbC1iLP9LJz61atfBWBz9seHPXhc0JN8ie1Ok8aaICKbR4XsI2FrVcYhdQJyhZVaER7ccviBBEWxm6XRaOPgwEgHYktQUwwGRhKwHJI8EvEczaaZk80FiMWtzLUDer3eQt1KycUfzguuPsBgUfB9LDXxv1stCxfXIJCQqNqwGZaM/gWNdp2kSPIAcN0Br92GJinhiELDvbQCr01uYM3wacnCvgEW7Vv3ohNzCNyrEKlbvLLsGjxObNewtQhcn22ZbASWJzUL+n2LJlQ2TLp9lkV/3/flgfOLffHiRdlMPAd+wd1SX/w796VhsbYS2ReKNze3MR6PC2IsU9mF56bylpGCK5WKiLMsktZrNRlvhUBFelOrMjz+xNNmfldMcc7nn39OxPpmm/zosfldtdpCQOm/M3q8VV+Jq43Tnuv1OloEbtKh9GV2M+Z53YlmtAVP+XlwdJ1SSubArkeOrTg8PJQ1ctWTMh6fm/5rwWrsZuL73PewjAtY7ofHC5hDpnwA1ut1TAjkhWtFcLxKrdqwwCchqxETSVtPUgYOSY5Nr/96aakOLGlJDzmdDEmAgoXcU7cciZWmacFwBxQxBlmE0sgLXJvvA4rBLjbwSCNNCbTCKVVVjqrj09zt0xUdXTcQ388GLea2DF1Vr9dx5cqVwv1BEAjHY0Mbl6pO01Tad42SZc6ntZb2WJrodrnMeGCLjnZt5aTVNXM/Bxl12x0Z74BSiR9f50jHCe7uEm6eZ57Lo+fPY4VqKAxJYvB8DjaqodUxgTsRZSKeWm/YDEficpVKRTjdhLIg2TUWVa0hrD8wklrgW7ek5bgaBwdGKuB3ZkrRcysrXQyHA3oG5rmvr69LQNVxGIPHGYSZXGzCct4Ev1f9fn8hctGNMHQlNpYKuKIUO90m45lIsVweDdALuR1hGIiL/PXQUhJY0pIecjoRkoCCRRt2oamAYvjwcRxe9DMGV/VsG+VT3TU8Wn3eEyRh1lWPC7BwC1+WpZQgCOQan9wKlQU9nkM/K5XKAvotYCUR5uIc9+G6rvj+Wq0mHJXbV0ot1AW8dfuG/I77r9cNZ6pWKxLAZCv6hOKG5Iy6tz+yJWP8+CeMu/DuoQmO2Wq00eFqOlQJ6StXXzJtwYeaGWni/FnTRtiIRFfn9ZlMJiLBMNAor+PBwcECRx0O+2Lg489WqyXPjNtnN1yWJTJP5pjXrt1cgENLkqQQ02/WI5K+y+7USqUi/XOfrouRbUK8toeHhyK5sOTlgq7w+Pn5N+rWFsT5J4AWAzLXjMiyVDIiXw+diENA48HIQm7yhfzOzR2QwqT2AfKLVPb5uu261V5ZLEvTVB4c/4YfVhiGC4AWzWZTHqoYhsK6FfNKB1uj0RCDlltpme/jyDflLVp4y+g27jjyPLdGPbpWq0UyNz4sWs2GzGWfUIa57739HXnxRyNjsPr1D/8/0uejjxtko+954j0AgGqthZTW8NHHjMejs2I2xCvXruN3fv/fmHZvXAUAXHz7M7CWazZsehK/b9O/zefe3o6oPZzUs7KyJuXkWJ0ZDoeyljdvmWcnG1NbbEQWq9005+PSqMtivta68H7wPbzROWaDGUO32104IMbjsVzj5xcEASpciNTjNOOWzMlNYDJ9J5jHNjcDMIwszYqJQ+U8hPvRUh1Y0pIecjoRkgD0vWOc+USL43ghZ8D9jZUc3KIgxbTULMsW7tc6Fz+7e4qWsxhdNyP7pl3RjkVtbqMa1QrAEe44arXasaoNczzuy/NtGrObQ8FUTut1x8sch8uWGaMoqTuwaLXxlAxPxJl8z/6mvmki7hIqxZ5lGQIql35nbJ5FJwBWV00cwXMvv0b3vULjS7F9/hIAoDm0tQ543D6l0DYadYl/YOmD59RqNbG/b6G1eM14vLYMusKQ4h9YnGa1x/NMH6aNhtxTNv5lWbagSvJ6u2nUbtQff88cm6WoZrO54DZ0jbp8n+d5YkC2eRMMRxbZ8u0xG6Et3+Z2Z7MEQXCv0uUPzNJfSgJLWtLDTidDElA2jr1cGuq4gB9XJxMJgDLCPO2BGCg80lV1QhlhcQZF7sCAoq08VYGvCBqsZt2BYZNcVsRRq4HV9TgmnXVEpZQtYU16WpZURI9bXydDGLm9VldXxCXG3Gow6CEhIxq3xZmOw9HQZqcRR5uNhvCckto8Do+AV+sUWBMQ5/C9aCHizYBtUmASfad7Y4znd2hspq+Y1jGOY2htxmiz4W4UMB/MuM16R1FkjZbEqb785S8X3KiA4ZqMFMzPmdufz+fC2ZmOnByJGbkBtdbS1/YpIx3sUB799vY2KiFlIk5MWwf7PQF5ZW6poBHHZi05N4EltVq1iZUug72aMa6thQXXsUtxnDpSBLuelYMtYJ7BcHiEFYpmlMC0nEFFLHgKu4uhcqQ5SSsxSQwVBV9xRGkZafveeTlMJ+MQoFRi11fulhoDGJb6wRGDfC9gDxDX08A4fja+IEWS0YvnpJayD5kfAsNXe563UHMvy7KC9wAAtre37OIT4q99sRbh0T0vgO8XvRlu2Supw0cpq6PRaCHEFbCRdmzYZCPT3bt3LQ4eLEDJysrawnqLFZwgvscEe+0a05jCMJTxspGMQT3iOC6k1gLA9unTEmHIovzBwYFsLBaNeQP5vi/j4WfSbDRkvDxPNxmK14APpYODA3kn3CIkLJK7EZfl5Bw+8PM8FwOfGN08q3qUkYsrlcpCCbYgsKoQv0Obm5sItPX4AMB0YtUebpdVQ6h8ITowDEPkaTGknsmNcL0XLdWBJS3pIacTIQlorZEkCXzfl5PYhWTiz+NAP8rc0I0JL4tBSZKgHGJtjIAUT+7b+1xUX8BypjRNF07WarW6AKOV60TEU+YgzHGGoz5yGtvR0UTaYKAR9pXzGR3HsZz+zBniOHYKdXA03MhJObZx9oBBNY4qNkbezD1wCrl6cl8ZXiyk8mmddhcdSml1wVak8OpFYwRkru/me7AEdnTUk/TY3V1bq+HKlUcBWEmA1TDTNhtxzb1ZkmKdCrqwBOHGkYy4kCtFMiZxKmndnMTlPkO3ECyrYqxiua68MizbdDrFfBZLH4BjuNVKrvF6rq6sLcQaRJUq8rgIV8cS482bN+UdSjMyKirX/Udp5aGHFGVk7a9fHVhKAkta0kNOJ0ISABYNK2XXnMuBy9lf5m/L4ss6JOuxYRhCC24+twukOelgylxrtVq4dOlSoY9yGrNL6+vrOH/+PIBi/gFz5ZevmUAZ5jha64Jkwd/xb2fEXbjvZrNZ4HiAkRbY8MgSgQvnZUtwc8SbEgPV3t4BzSlBm8qrzyjuf3VlQ3R1ljAiYiTtdnsh9r1Wq8maMPd+5ZVXZW1Yz+Xx7x3syzx5jYMgQLdr1mZ11ejgPLeXX35Z5sxwYbdu3ESfCnBevHgRgHnmVnow9zE+/5kzZ5wUZbMuL7zwgrwnrk2A2+P14z673S5efPFFANaWEUU1MB9tNm0+BmAkGrYnWCN3inrdfG/fdw/nzhlgWX5PWRpaW7NQbAGFxM7jqTzvGQU+uW7xMte/X10IpqUksKQlPeR0IiQBrQ0GgHtileP+XYvocXoPM2jXGlqODR+Px4BexN7PqI/zF8/J78ogEezWcq/xiby5uWldbDSmvf07NlNRU70/9gpoW+uQx+rClnueGduZM2cAGA4hhU6dCkduHjx/x/YHth2wNGQCjsxvWWfXuZK5bG+flnVm4NUWua6ORhactUq1EAKKZb9zZ0cs9CwtuVDbcWxh3AEDp85rxfDio+FkIdyZJZMzp89ZDwMBsYZ+RSQMzpXodruIYyO51AighN1wgCd1HsZjW1uSOa8LZc/9l/Mb5nMLKsK/i6JUbCphyO+Tef4rK2s4d84AtjDwaaVScfIgbN5JuUoTezA2NjZkTas1e/9sNijcP5tNUAmO9wC48GL3ohNxCADWsFMW9d0osbKoc1yugWsgKkd/NRoNzKYsLjMGfw3nqYhHmo/ld/ySsVjKRiGttbjAXBcTu+7YkDSeWF+2jTAzYw3DCtqUbMMvbJYtgpW4mPpsoHSx+gRDnw6GyWQi18S/XeM8gdRREazRcETVn8LAvIgXL14UIyfHELD42+/3ZcPz+rh+fL7PLc5SjsqbzmYLbrU0TbG5aQpVsSjMBrp6vS7j5vZXV1ak4AqL37PZTER53tS8LkdHR9Ie9722tmYLtNIYB4OBzI/X0cUOLFdCHg6nwhxY9OdN3u/3ZTNz37VaTYy+LkZi/8C8O3zIsGo5HA5lHFDkbnRchJ63iI61VAeWtKQlfcN0YiSBMqcvBwG5lW6O+w3j0LmZdMwlmLPdvbMn4huf3M1mVzjG1sYZastNuzWfLvcvR7C53FDKkaVTW5+eILYY1TiKooWMyGazabkliQwsrUSRjfZzXVeu0RQw0hPfx+NgbhtFESiYEFHE8e6WM7HEc3R0JK4nVhvmFMs+GlpJY23N8I9TW6exsb4l68bjAIAwCAucGgCqtYZTL6Eu37Hozqi6p04Z9aTf72Nnx4zx7FlTfnt/71BUA1YbfN+XICQex1NPPQXABFjx/ft7hzJf5vIs0cVxXEBRBopwZOWy31GlJetWo5wK/neWagm2mozN3M+cPieBQPxOTMYzkTJ5XVz3OKuEX736FQBAd6UtUtNwaKQmqBw6K7oemb4edWApCSxpSQ85nQhJQOsceTxDrjOB+grpJM4pZBVZJpVOpEioE0SjIgZ8zCWA42DfcMEeVXipRm2snDIGn7XVbXN/kqNCKA0rHcOZiqCf5revXX+JhpEhJ5bKRSIrFVsTIU1ovLqGiKHRkmKE0nyWQVcYsdZWDGIOxtJHlnEeRY40Ne0eHho9M881Go1WoY00nYnrTCoPEXCnWylI7AYecPqC4bgxTPvN9iq8Kt2XmvlNCa253ooQRCStxGQbaK5ifYWrIxXdmAYjn55PQFKRF0IS4Rg7IA+E8zLOwqvXGW+/jbVVw4GnE9Pn5qkNm3lHAV5hFMAj41iNoMz6xCk3ttZx9UWDkswSoHdTo91pFNaj2aphMKRaDrQzVqtkREWK4Yj6JJyH0eQAg5GRUra2uTy8+a67UhepM3Xg0VZWTXts79FaI+OCrzRuAstGtdXAkCpOnb1kjIzz+RQDyn/wKow2HEt5dc9f5OvZMUF2Ln0zqhL7AD4H4JbW+seUUpcAfAjAKoAvAPi7WuvjZRWHtPIwdzYLA1XcpaiymoOCKxFTfoCAABnijPMF5uj1jcg8JCt3Sqvc6a6hwRbvHhvdNB65bET9M2fMCzIc9nHrlrHoluP/tdaIYxuFBxhQDBYjeWyT8cxJhy3mGgCLngsXr64sVruqEIuO4/FYVAMWZ6Mokj54Qybajpv7ZDGf23b7ctOS7djM3ObzuYj3TIeHh6JysOjMBrwkSRzUYDOOtZWGbABel/X19ULhVHccw+FQRGwez87OzoLXZjQaFQxq7hp0Oh1sb28XxugWOnWrXfM4eB1dTwf3yTkYvh/KAcKG4W1SY06fPo3plCz7gog0LMQRmDZ8zONilCfHcxRU4NyC23D0oPKsMdC/BxjK10PfDHXg/QBecP79PwD451rrRwEcAfi5b0IfS1rSkt4keqOlyc8C+FEA/x2A/4IqFf8AgL9Nt/wqgP8GwP92v3biJMWN2zvwPE9Oaj7hJ3MqJRaPFoqDVioVGyOf2KzAm7eM8Ycj79gd89ijj4sBan3dGFd837duISrqWK1V8Lan3wrAntgcLQYswoWNx2MHkISBQ0IZJ3Mc67ariVjqIgwzt2TX1YQKpbTbbcdYmEobzFFd1+KCtJQXcffMuph2oyiSPplbtdttG6XGmYWkFrQadRwdHhTGcfbsWXkGPE/mWqHvoVlno6hNRxZpyTFeljPjeE6tVkvWg6WEupNFyHEQLgYgr61Vk9KFrNStrW30euxvN9/t7e3JmnMEIL9Dly9fkVJmrhrG7+urr5ooyesULVmr1SRDk9d+b+9FUfU4EnFtbU2eGUs8bKx1i6zeum0AW5Jkjo1NI8mxRLCysoJxv0dz+dZLAv8LgP8SFjRuDUBPa81P9CaAM8f9UCn1PqXU55RSn5tOF4uDLGlJS/rW0OuWBJRSPwZgV2v9eaXU9/PlY249NoVJa/0sgGcB4Oy5M3r7wiUMh0M5za/fNu6eg0Nzwg2Hw4UMs9lsZiOwtOFkcRzj0UdNRtpbnnwMgNW/x/2eGKBW2hYWKvRMnyFlE8ZxLEYgzv1fW7Nosv2+4SAMA+V7Fj14TrHp/VF/oeIPU5IkC+7ObrdbyDtwfzedTgv4BzwO1qldAFNX5wUA7Vv7Qjkazs1vZw7i5sDzdxFFw/kKaJDxijnqq69cE27Ma7tzx0Tx1et1sQ8wHfUn8jdLH240HhPbLW7fvr0AJTaZTqVPXoM8z8WOwO8HB+lorReChVZX1kR/z7NbZr7tREp7c1WqJnH9ixcv4ivPPQ8AqJDO3t5uiy2AiSWYL3zhC7hIpdfdbFJeU3k+WqNJxVf5PWVJZjgcFmpVAECa2i3rvh9u/kOZHiQdvBF14LsA/AdKqR8BUAXQhpEMukqpgKSBswBuv4E+lrSkJb3J9LoPAa31PwbwjwGAJIF/pLX+O0qp3wDwkzAegp8F8JEHtTUcjvCJT/5/2N3dldPcBRilPmzeN6HlNFpt4Qg56W6+1nj3t30bAODtb38bAOuOeeGrzyNPyHNAoZp5o4EarUKuuJ6ATxliiyg/aZoiIS8GB9/M0hnm8yKaURAEC3ooSwuVSkXGxKd5tVpdqLDE8e4uSg1zOc/zCgE+AIePFm0Co5mZb6fTES7lShPlAJj5fC5z5eCbitg5augdHRTubzabgC7CYzHn7vdmGA2Loblnzj8qXJ+fXRRFhfh9t41GoyFzdyHnZH5O3kIZW4LXxbWyiwdGaSkPPxhwG9YzskZ4BSxpnDlzTmwHeW7z/1likSpQpBhnWSaQaU8//bTMqRyO7Ba/tYhIDfluESxXLdSqjKLwgQFB96M3I07glwB8SCn13wL4CwD/8kE/mMcxrr3yKq5cuSKLyi8Bv4huvfcBxbTP53N5QR45b0wPlSjAhTMmsixlF1HTLPh7v++7kZErkX29u7u7+NKX/tL0wZVitZaXgEXWkKrqGjcc1Rto2Bh7jrLjh3Xr7i1b9otEOX4Rp9OpbH5XLOT7eWO6UGt8nxvJ6GIt8icb/SS9mNxIBlDF3M9rnOe5bCLX6MqHF0em8SFwdHS0kOjT6/UKxkp3DZRShcIogDmQyxu+1+tJe+UN4ao4ly8b8Xp1bU02ArvrZrOZ/PbOHYMtyEa1lZUVWXvJx8gSSeHljdnv9+V58xpxxN4Xv/hF+U5QpEMlKqrgTZIaYYBmigVVWq2ORQ+eJbLG9YZZb37X3TgLqV3hszpYwXRG7uIauxR96OSBXvh70jflENBafwLAJ+jvawDe/c1od0lLWtKbTyciYtCDh5pfw0svXUd71YhoGxcNNz/iUlzdNlZahhtS8Bl2X70Jj1I3xzSVJAvxh5/4NADgLY8ZztFqGq54enMd9aq5r1GjjK2NU3jsR/59AMD1A3YpxVIRh1NV9/YNx2m329jaNIEnUYOMWVmK2YyCbsgweGrrnIijfXLfiBiu0wXIMcDNlyCxl9x7rZUuJnER1TafWWmCuX1/OLDl0Ck/oKlscArfz5xSKSUqBf/O8zzhssyxbxJqr+d50ARSGlMasF+pIawWRXNB2a2GqDaKMG1Znkr7U3LHVSo1dLurhTZ4PEmSCAd+5Rq53+qR5HJwzYhatYpTZDgsg63OplMcUCSiRa3ORR1xq0uV8zG47/39fbzrXe8CAHzlKyaO//DwEEnCqMdmrXg9+/2hAJiwRKV1hk7HrINIH4MDeLmZe7vGhkwKlJoOMZM4O5L6fKBGZeIU6aN5nBfqEXyjtMwdWNKSHnI6EZJAFFVw+fJFZAo4Ghmd7StfNHp6jdwnFy9ewLWvmYCd0ZExwgSpxgbpfZcIECSKIkyojZu3DQdjI1avPxROypyp2Wzi0StGYjh/wdgBfN+XstY/8IN/HQBw966RCD772c/ihatfM/dRXv75c4+gSXUEJAf/9GnhZrdumdx3AUNBJjp7EDA8VdMx/pCRMbeVcVgPFdCN2UwCTphcoFa2qfD9rVZrAa8gSRJxnbkBObayTTF+w4UvY3JDlcvVndy6ENyWRi7319ca0i7bWXjNuOaC53lOfUfDlXd274j+z9w+SRKZA4+Ry7+7eRnc1s7OnYWsvSiKFoBlOdx4Npvh5ZdfNuOmZ3fr1i35m4nXoN1u22pUJE3s7OzI31uO1GKN3xwabgFqJKuxTkVidS65CD5JZUHgwfdf/1Y+EYfAdDrFc899Cc2VDtr0Ejz1+FsAAEf0YL/wmc/gNImAjXWz8Xv7B1K48mDPbPhOpwNFhUI6FLHFC/niqzflodYCwr5DhL2RaWNn/xoAY5jj4iDD6yZS6wIdMj/10z+D/+l//Ofm/h3jYWh3hqhVzSZd3zCi38bGhk3FnRdRgaKqteY2GjadlcfZ61EUnLPhyyXH5vO5vLy8EQAsGO74oAhDWyjDRQBisdTFPCzH5TN8Y57ncr9b20GSlRq2xBdgXmJeA0nImozEmDYc7Mq6cOpwubbEdDq10YOU91GrXxTLOx9iAPD8888X+rLlzvyFA61Wq9kK0k6+AB8CPBdWLe7evSvf8YHiok2xyM+/G41GC3UNqtXqguGzUqkgncc0Xiqcm9OzyGJ4nLqiGBErREQHCQOJ+L6/cDh/I7RUB5a0pIecToQkoDyFShSgUY0kBvprV01O0vomueoA3L5mYreZa22srokf+urA+s8vUBHMCWVxsajkBRWEkTmpucDjcHSEt7/dGHwunTPxBb3+IT7/+T83bVD66l988TkA5oQ/ddqkdb7z3d8DANjfO0I8Nxys2TZGnsuXL+P0acPdXnjBSDDMlZN0Ln9LLfpGw4l+M6f6gAAoTp06JZyRjVlbW1viemKR1MXFd2MB+N/lAplaa5EieBy9Xk++Z046J6NnvV5f+K7RaAg35v7ZaOf7/gISsVLKQrWRgdf3fZmXLezqy+/4eXP+hudbN52rEvH6sSrEc6tWqwtFQafT6UIJ+0rFYhcyMT6g7/u2GhBJAu9617skZ0BKtjnSR7mallLKGkjduIyRWZuwwqXXzHgGg56oi2GFUrGrISLwGAk+TyeiTi3rDixpSUv6hulESAK1Wg1PPfUUPv/5zwvnOn/aBGkwoGSlUsGlcyZfnE/YGzduCBdKZuZ3QRBgSKALQWQ4DvPHdruN/R0TkMF5Ap7n4fc+8lsAgO/8rncCMByFo/UY2ur69Vel/Srp/+fPXQQAxDONq7eN0WhjnewWjYZwNw5akcoyt14TLrSxYe0WrCuz0ahJGZRJkhTKoAOGc5cDq0xeQ7+wRsz9j46OilF+NBfu0w1eKnM81n3TNF0IRvJ9X4BAOOadA3JqtZpIQ1J3YP8QTHt7+9IGV18qIy67tg8OmErSuawf358kiXB+vp+5+KVLlxyEYIu9UK5jEQSBtMf2BZ4TYO0PLodnqYfb53m2Wq0CYAzfXw4Iy7IMqmZzVgBgHjPEWYRGkwOwrLGV3YF+wIZeTzJ0Xk/k4Ik4BOq1Gp5++m14+um3IaWSTM8/Z8Tv27T5smyGOS+qGMli7O7uUCsc6eXhdNNslOmU/N0UOtuqVZGQEaY/MC/6SqeLOlV8/a3f/igAI4J2ukZsa5F3gnKFMBmOEVaM//+3P2ruv3jhMXznd32vGQWJutvb27JhZ9S/AHaoXKLV2BK8t7cnouKf/qmJcwhrpm83CYdVgPl8vlCyrdFoyObkvl56ySAieZ4nG4A3S5Zl8oLyht/a2pIDh6PxysjPgBX5m82mxFIwucAjHJPA/cRxLP2XQ5zdPtzirHzIMI6f59uDj+d748YNWW8mxiQ8PDxcKCby6KOPSBwHj9f1fvA1VmPa7bYc5ryBx+OxzIUPfD5Au92uMDQX4ZjXw40/aNWK8PasksSxlg1fbzC4iS9qgy04kgme4YNE/+NoqQ4saUkPOZ0ISUApjTDIESdT5DCc4Mw5wxV/7CeM8W00GONg34iZ4wG5oGYNpKnhUmvbFwEAgR/Cz8ypefmC8f8zeMTt20dYWzMi3SphwikvxyNPm5Tj7z/7mIzpgx/8IABgNiSOQ1y5EVZxep2iGSlewcs0Lp0z6gtziaAa2Sg/ajPmOgRhVURLjhdXQQ3VhuHo22epDDrFizcajYXEms3NTYu1SFzfLWHO3104a1xXBtHX3NdpmjG6iUwWKGWGGWEnRkGxbkIYhsJ5WSLpdDp4/PHHARi/mZ7PIgAAIABJREFUuTvGNE1lfizqZtoadisVKnzq+0gp+s3GCVCBz2qITtgutBv6lQUAFs/zFmociAF5Y0PGZo2HcylTxqpHu92Ufg8phZ3H88QTb8UXvvAFAMCNG6atrbWuzOtoz7g7mYu3alXMSDJnSSCARo2LlLDbGBo5wW9knApNCMqdTkvwL8OApAXPBzRX2uFkqKAANeZ+lv8+jpaSwJKW9JDTCZEEfFSrTSjlQ9GQGg0G5KCyV16Ieo3cKxS3vn1qKnBhd3aNfnd0uIfXrhsj3bve9e0AgO/4TpPPtNpdk6ivj33sjwAAm5vr+OyffwkA8NKL5oS/fPkyuh3j6mPwShc/n3VgvvbYY1ek+k2rRS6umi2lzYCTbhALc2AOMnnuuedsCWvKK8i1TW1lDsVZbYeHhwV3F2D0TNY1WffNSRo5OjoSjs7cbTKOBT7LNbQxWMqcUIbDqun79OnT+L7v+z4A1vj3yiuvCJdl/dgt7+XaEUz7mdgm3HTaMrgJ6+vValWMczy3m6/dsvkJTrSiC4gCWPuCW+LNBW7h5+emKpfBWHldptOpGKkvXDAu4v39fRlnGbjj6OjI5nY46egsSfFaRVEkQK42Dd1mhfJv2c0YhiEqUbEvN1Do9RgGl5LAkpb0kNOJkAQABZ1VUI0qqEYUu00uvMnUcBVfBRh7hvukHum9UAABgbQ6xv2W5htIKBDoj/74NwEAn/qUOfH/wX/6fvzgD/01AMC3veMZAMCnP/1pHByY03w4MJ+f+bMv2Jz3G+b0Z6niybc9he+m05w5yNbWBiiNAEMKLurvD8SazCGuL7xgAqCeeeYZOeE///nPAzCcld1pHNp89WvGTdXtdoVrclsu0IjLUcv4AOcosKlWbYmlu0e2jDiOhVsNh+Z3q6urOP+IkX54/E0GfZ1M8OUvf1nGCxh9ly3eLJEIyKkTHMNjVX6wENZr6hNYeHXASkh5ni/AkIdhKP2zR6DZbMr6CZwc6+JOoVY3V5/H4WIdlOtH8j1pmsp9DDjaqlUWYOVZQnGxHVji2N3dtRWKuIpRFCFJi+HLbsAR3+8GHJVtHzxf4PV5B07IIWCJS3UpxUYbflB2oooLMQYZMoqum4svtoKIHsSVR8xmalDxz9/48AdRjcwD+Vt/+z8GAPzkT/8MjnpmA5w9ZV56WzseACV1sD/9/PmzEtHHRq/RdIgNKmpCOR0IRqGIxWwE/MEf/EEAZrOwuM7i/dbWVqEAKWDjCqbTqbw07C68efOmg0RjDoHxeGzLfZVKW7344osL6ETnzp3DD//wDwMoGuRYvP/d3/1dswSOyO3WJQCM2MvGUG6DN59SSjYfv8zTebzw8o7HY3E58m95I+zs7Eh8gODtVRuOAc9GUPJG5HWR4rDjcaHUGGA2q1uiDSiiQXGMgRuNyaqhIBxNhjJ3dmO6BV74ubgp1rxJ3cSjMnqQ1haRisfLaqbneVBesYSd+c2iQbDc/r1oqQ4saUkPOZ0ISUApgOx/YkyzBh/DuT0o4cCJxym3c6SUdlsnd1OqM2QpoRFTQc/xhEA9dISDnjmx/9EvvR8A8Nd+4Idw7WXD+b797e8AYDh2JTJLw6L5F0kMrrfqEr2VgcpzNZpIck61Mx/VaoQoMiItSwzM/YfD4YLRaDqditjI4vX6hi3PzVICGyW11mKgYnddtVpdqE/w6mvGEPqzf+/v4NIlk1PhBukw1x8MDUf98Ic/LOL3AQGr7B8ROMdsJkY6NohduXJFxsRrxRJBq9USicQVf5nbc1udTkdEbJZ03AhJlhxYahr2RyJZuGI4r0PZRaiUKrhWgaIq5BaC5fGWJYdutyvtuwZWvsbPgp+Tm0rsVmEql03XWosrmNeIA8hWV1clYpDLkCulRBJmyvP8vojCy9LkS1rSku5LJ0ISADSgYmitoFEEppC6AlETWc71ASguPpuJDjSn0NzAC6ACusZuJ2ojmU0E4z0amGsvvfxV/OUXrwIAJpSJ+MlPfgrvf/8vALDuOtbrh8Mhul2jo9qw0KEUDOVr26fOCyY9n/qs2x4cHAjXZ667sbEh18o18k6fPi1cjfXMo6Mj4Z4ucOh3fMd3FPrsNAxna7VaMgfOxlNK4bOf/VMA1tj1/PPPOUAjVFEI1iZQht1ywUTZBsL6rud5C/US6k0rHbjuQ5YKygjNnU6nYEAEjI5tsw0VPYPxQi1H7tMFqXVtAtyXi5JcrmLEnLtSqRRqOAJALQpEYmCbEbeZJMnCuPnfbrtaa3h5URKo16sL6+eCt7KdygVxeSOSwIk4BJTyEFbqmM/nyCm/VIXmodXrRtxLkgSasNXEch90EAhijRG55/M5ZnOCfyYxS3lsXAkxHBLU+Ny84Ddf2UWNio3e3DWHwZUrV/CH//a3AQCf/NTvAwB+8j/8CQDAaqOGF/7CoB6FpJbUqzX0yEDVPyID4lt35CGxkenJJ01knZ6PkflUBHNmxjqeaoQgAxvZjDRtvusvviIqxd0dI3q/4x1vx1vfYpBz3vHM2wEYhCZGJWLjX5obsfmjv/uH4p3g9NdarSYvNm/Mp9/xHrn2Z3/2ZwCAoWP04nbZc+DCaJfLrs1mMzzxxBNwiQ15gFtQI0XIKcp0mLP47qICMcb75csXZT1mMwuK4hb5BNw8BGug5I02m8bI8yKeYKPRQI+eHx8C+3tmvO1WVyL0xKA56WN1zawVqwVSeHVtTUomcxXrRrO6gLTseT4yev/Yw+9RuEO1HcAjVGxNjA9KwW5bWpcMyBWpo96iEfD+NYmX6sCSlvTQ04mQBAAtePf38nP6vr8gvgGOATE2HKFR1xiNCf12QlFzjN4bZwC7XzIuIT6H75PxhSCcXn3lNWysGQNSRLh2f/gHfwwAWO128Z+97x8AsKd/Mp3hmW9/N/1tONjNox3UqGSXIr/hc1/+qplLoJAkhkuxCO37SsRFibwb2ohANmi5WIPf+73fbcZNh/9wOMSdOybzj6Pb/uCP/gSAcWGxQY458Orq6kJ5riiKxLjF3JDX2y2HzmN1pQN+di7sFnNnvlatVsVQJoVj8lw4Ixv8XKMac96Z4wbmcTC3D4JgIb+C5zmbzURysAa/dKH02Ww+gSZjb5XSe7srNn05Tkz/fk7jOcYly/8eDoditHQjO8vlwuI4hkdZgRz/X1aJ3HGbtWFXIqUXKyUS9OuhpSSwpCU95HRCJAFl8gaUQrl+qWsgjCK/cK1atVV4ulSaDACOeoZDZ5nJ9huODLd94fmrGA4ndM+Ueq5Ak2EmmRluuLGxgbXuJrVhOMPtu6bNOM7xS//kvwYAtBpUSNLz8JYrpggqc+DW5ppEsB0cmN9evWpsDuPxUPTu2dzCorFksbFRLFv+oz/6o1J9h7n+aDRAvz8stPuZz/wJPv1pg0UgwSi++XSDV9gNl6ap9Mnk+75wIJYExNi5vS1SCksLs9lM2mUuyHpvtVqVObDEMxgMpA2WCMIwFGmDg27431mWibRnIcWOCgZBvp/n7CIy8zyZk8rYwkheNZ7fwe6e9LFDSNXc1qg/QLNWL4y7Xq8X/gasAXk+ny+AlqRpupBL4XkeMqpdUKtHhXWv1+uoVKyh8X50v4KkD6I3dAgopboA/gWAp2CW9O8DuArg1wBcBHAdwN/UWh/dowm3NSjlgfMfyhFQxgJaNHoEgY+AkIWnXCHY99FZMZF2164Z9OAXXzSGuVu3e5hMCODDqe7qkXjVrJsX4Pq16/h826SN8ub7T/7+z5l7mk38+od+DQDw/NcM9PhKp4M9Em0FU+/VV+F5f1kYb43AIxrNFWyeMj719XVjsHryySflRZ3Pp3S/Lf911DOqzdeoz49//OOygacTt04ivdmUnlo30iza7ba8qC4aMBNvtMPDQ/FilKsBA3Zz8mbp9XoLyVB8KIRhaAuNUFu9Xk/mKUa62Uz657Z487lIutxGENgUaBc7kMfNqoobxlwukaaT1IYGE3BHPJtiSNDKUgqO1MfRoI+Iw6jrBPqRjm35MQdmnftxEYUBo+rwPFmFmk6n8FAECXGjCXn9pByZ5zk1Ec09aZJL7MpfRSrxBwD8G6314wDeDuAFAL8M4GNa60cBfIz+vaQlLemE0uuWBJRSbQDfC+DvAYDWOgYQK6V+HMD3022/ClOj8Jce0JYTN318DPSDTraQIvx8B6AioQIWc0o9znIF5VGCh88lvzSSjDmHOZ0feeQyhkPDaa5dMxF3V18yHPidzzyDn3//z5s26OTu9XoSNcen/t7uoXCHS5dMNBm71VrtptRLYK41HA7FL88++zg2YvPHP/5xEW05gWg2tT7nKLJGqXUyaLJLLGpWaZ550ddM13gtedz1en2hEjO3NRqNFiDBKpXKAua+i3TM47Zc3OLs8Xe1Wk04I3+6Yj736UJ+cR9u3L07JpdcbESZZ9XWYUhJHN86tWGRiglYhXH8/EBhMi1iGGZZJuvnSjVMbtIPrye37+IaBhVb/ARwqhPXVxfQid1U4WKRl78aw+BlAHsA/i+l1F8opf6FUqoBYEtrfQcA6HPzuB8rpd6nlPqcUupzPOklLWlJ33p6IzaBAMAzAH5Ba/1ZpdQH8A2I/lrrZwE8CwCXLl3UHIghyQMlbh/4/oIE4HKyUA7/HNWamRafoswtgqCCMKTTNjecJk9SaCr2aPW/Q6xQlaODQ+Ny+9//j/8VgMGa53afevptAMwJzsUqWVe99MgjYgxjDnL1ZXIR+gpf+pIBMrl92xgSb968iRnZAgSoIre4+Fyznt2YtVpg7Q9j4nJhHUFgOH+PMiPbJPHEcbxQQlxrvVBRSGstHF3KrFN+QZqmMnf3Gbhlzdw1SJKkEPTj/sYdhyn7VuSQ5TRpoJjeW477d3H+y4Aj8/m8UPcAAIKoApRqESDL0CBXX87SBHHgiu+j6aRsA0Du9MnkZuy5EhdguD6vEX8qpRCqSqFdd/yuxGDJQRkG4IUeoGxpefez/Pdx9EYkgZsAbmqtP0v//jDMobCjlNo2g1TbAHbfQB9LWtKS3mR63ZKA1vquUuqGUuotWuurAN4L4Hn672cB/DP6/MiD2lJKLQQKlU80N466XPgSAGYUyNFotDCk0M8XXzZw233iTFoBfkA6JNUa9MMItZqxBM/6hiNMpiMcfI1cgsQ93/Oe9wAwcOBnzxu48Nt3DYe8ffs2/uQzxjX3yU9+EgDwUz/x0+LuevllE6vPwTFPPvm4BK+MJ1bPZC7CwU0Bcb5Go2EhygJ2daUIfLagGw5Sq9UkX0Hi83PDAbMsE47kAl+wJZr1+p2dHVs8tLTO1WpV5uAGC5WBNThAKEkSaYu5rVJKJBJ2k45GNiuwrNe7+r3FSLD59Nyu1rpgY3DJ9/2Foqlu4BPbGrIsW6jN6H66dgoAyD0793INyDiOpX0LPW9zXVxrf2fFvH8rq2Y9CuHUYdGOcxxXNyXjv3FYMaY3GifwCwA+qJSqALgG4D+CkS5+XSn1cwBeA/BTD27GJkDczyBYNo64UWJVKs00G83xta8Y1+DOLbMh4gkBj0zmSH3z92rbIu6CjCrdttlgg/4I0ZgLdJrv7u4YN+Op7TXklKcwnlKiTz7GV0i8J80Cf/Lpz8pLk2Vcxsu8bDdu3AAXkW21zLgPj/bFJwxFPmFKo/b9AHWKYHNThSVJqGtesiiK4AdFBGKtOe1ao1plkAvzolerVcc1N6I1tZuON+vwyGz8ZrOJOqHfKnLJJnkCn9y0e3eKUXmh8lBrGbdduEqp3tlcnrUUMokaMpcmzdM9sORwpIM+coyLa127wep1TtQpGhkHg0Fh0wHAxPOQai735qAU0fkSEc4/v2tZniFTZGAmoy4y65rj8XIMhFJKDgRW18x1in9I6YANFFbXzRxWV9t2HCimCD8IGISBSF4PvaFDQGv9lwDeecxX730j7S5pSUv61tEJiRhcpPsZM44zftg0Ul3AlgNcDD694OIyOQtFkSuKqsgzNlCaa12qSFSv11GpMj78iNoC9vaMAdH3mJNlUnmII8E6HY4ln2I8KQa7GNGvKLJyWvVgMFhwibmx5K6RieclkGNUcandbouhkqsfeZ63AIvl+76AnzAIieLa5E5f3P90OhWXVplbmZJt1cI8EVtRnucbBNbIWS7iydKfO6fpdCrr4UYpllOwWaxut9sL+QfHGRcrlYoECXFbPA7fMUxz+57nIQy5ZLhZd1ftKee6FFGBzafJI7Fl3nm8hTVDCfLuGHrQ9/ejZe7Akpb0kNOJkASUKsItuZ/3IxeX3fPYzTIXDnbtmsmb5xO2VqvJ6S/6N2w8viL3W7fTQCVgV4459R97zFQnOn9hG6/eMCjAARkX744PRS/n7MThqI9anesI2Np1gCk5vbm1Qe0bztFurQqn5uxDnVqjqAuVBRThyJj7uAFBLk49YAJQ+Bob98bjsXBLrll46dIl4XRsf3AxB5jr81jDMJR4eakyRL93g2lcDl++5qINM7n2H76/DFoCWInEBQ4tG/VczAN3HRnIlTk16/PuteNw/OUZTGLEfrEepKACKLUQvlyrRTIvDsBaXV3Fqe1iXQXb1uJ63IteT70BphNxCGhd9De75Io5ZXHT/Y4f4HQ6l/j6MjTzbDZzsO4sFDanjSYkquY5oMloxKLZY48ZQBA/SLG2bl76w0NOf61hNChCZhuQDNMvJxC5xi4+EHhOYRih0yki+tRD87IHQbDwEjSbzQWU2iAICpZlAJjO5jTGhtznouuwEcpN9eVNJ4cnibyrq6sLVYnn83khBsAlz/PkgJLiIr5eKDSSpumCOOsi6vB9bs6Be9Dw2vIGd9F9eG7HvQvlEmwAHGNusZybOw4mLk0HYAH3T+scDD3NmIFZljjJUGb9Gs1IrlnvkF2LMlrSvaiMQMTPX2u9xBhc0pKWdH86EZKAUoSieh/Rq/x3+d8scu3vH4rYyGTj4psLLpc0TdHrGVExDAxX1LktHcYuMxZ502xs/6byUXfv7DmiMEsHHetP5ogxOvHb7TaytBifPxmPLAfQRXgsV43hE14pteCjzrJMjHpi7KoXo/8K43FcbS5GPv/N4vVsNJR/H5ayJUej0UIGnWsQKz+zeWzx/qQgiVILEoabSszk4hq6pdd4TlKw1IntB4xEUB5Ht9uV+13VoxxV6baxoCKo0IlYZD8+SYRZLLBiDBaS6xQpGZzbHZbAOgUDqTt3VyV+kLhfNqy69y8lgSUtaUn3pRMhCQBvXBJgnTZJMsnWOzw0EsGc9OJWq5hdVm6HucCgP0RUMfperdoo3NtoNHDYJ/BHPqlVjpAgoipg+KqZY+ApSgSz2UwkAeY05l6WUsh46VmE3HIk3Ww2K0gAPB6Xu9If8m/u33UHliHH3ExBaZfy7d0Co8yBGRbOHZur05YNvK7Ry/3ObQ9wSpM7wUISuJNlC/UM4jhegOXi8aRpWpAieP3KklqWZQuBTK47sGxrcMefpvwMWBJIyS4AKG2fT52wCBhROMsSeF5R+jnunf96DX9lSfdBNQmApSSwpCU99HQiJAGlPIRhVACcZOwnVz9yOQFg9HX+my29+/v7C9DTnmd1vnKwUBiG8CnzbjaiGPxKDapi+jp/yVS90XRPnANRzQTbtFocrnuEqbpL4zY6dppGSDRLDLb6DgDMpvMFva/ZbDo592Q1p6UIqjUbqMKZaZ6P8aRYANT3fficYUafNYo9H40GwhkZuShJ5sIhmVnE8czhshTEomzQVTox4xgS9kKz27Gutdzqz7zebsYiAHh5fmzJ7nLtRDczsezeiwIl7tOEcwfyHCrgwB0K8KEYYD9QmE+K6eqpVy3UATC/qyB1OL8ZB7muASQ52T4IfDZR8cI7mVHmZ47cup7Jc3Dx8qOCJLW6adCaoigCvCK3P84mcL+8GuMaLkq5XGuj7LU4jk7EIaC1Fp9yuejIcQYiJleF2NkxEXu1Wk2w/VgdcNNTrchoxM00TaG8IqDJysoK7pJbj33kNqUzFP+8r+wGpupmBfdaOfZB8BC73QLwBmBcU+5DNb+zvnXeHLwe/X5fxuGKjPeKUkvTdMHt5YJtuBh2vEnLEYxJkixU7R0Oh2JAZJWMDzs36Usq7SJbiH50Ix3///a+PUiT66rvd7u/9zevnZ2Z3ZmdfUq7klYvP5AsCckQbLARxsYgquxQYBIClRSpJOSPYBd/OKkKVZBQhKJIAa5AMCmwMcbBjsAxfgU7jiUsJFvSSivtrvY1+5qd2ZlvZr53d9/8ce+59/Tt+82sdtnRwPSp2ppv++uv+/bt7nvO+Z1zfoeHtgDlJrhhz34/NtdJwC3Pkeh0CNTNZtFx8hrXfUjYAuWS3PCyaKOEimHGhOcvMi2s1EpsdnbWZI3ybMXQIR8hkVKmCujcueL7DeIg5HkWgyR3B3LJZZvLlrAESINxkhA3T9sHlvCw14MPKt7/s2fP46lvPgPAah8OClnKJxsitI0g1Yod9S0nPYXc7jfJMe1M8kqpVMqGAwuFzH6kyTgARVqu1+tlykwpWzFJErONyEVHR0cNqMfz810NxvPVXTIPKaXRbnzcNL/kVnGtRefiRKB0DT6KrQxQKa25zunIuFvE9+fzYkC9XoQi0tV7SZJAaNZoSZV6rLzWaE9dvlkQhVSeP10LXQOfNxKXtozagfFrT1ud6pwUUq5Wq8yCYRmdgR/049YvDw37gL5BwCG3rgdJbgnkkss2ly1hCUgpjQ/tpgbz9FA3GQWwmuDUKUUI2mza9tLG79YL6thYyLQa85O05iCap163ZQgyiECUJ7j0+to3Zas+aVc6Z2O5zXx769/S/+layFrhVYGknSlUyBODyO8ulUqp0BbNC82N8cEZ2YWr4VXIKh2e6vV6xvpx05KXl5cxOzur59mmPXMaL369YRhmePYJrANsqncQBOYzXZ8vNEcAYbFUMcel/RXdehpUJOGAMEmv1zPXznELt7KQ10O4xy+Vi5n5pqpCwOJJ99xzDwAiXbEWF507dnAWX1iQWyHXQyHGj7WRJbAlFgESHxDCSznpxvsekAMHDgAAWq0OrlxWD/HZs3Op4/Ne91FkO8Ymuk6g1+mZc3acWLAFpbqmVRUfK281BQBJYhF9F6zj7gM9nO1221yXNddtTNu98e122/Ir6gc3CALzoFrgMTL70HF5wY+7UAkhMhlsxFZUr9czLce63W4GGKQ54EL7TE/tzJT1JkliXAMS2qfVaqU6AwMqMhIkamzNjj1XnNjFkM9BGIZmQeVKxQXTeE2Ci9DXarXMPej2OpkXl5cx0yLAgVISzj/osgb5mLO4+BYJF8TlwPNGxUe5O5BLLttctoQlEAQBhoeHU8CgW1UWBEHKZAbUqueGlAALOBnzTZtg3NzjQN5aU5mifa1UyqWq4SKkY5DWqterkHrtLOsY/K5du3DpvKo2pFWXt/Ny4+K8qw435d2xdbRlwsEgHjIl4gvOkcfLYdUxlOYeHR3NVN4VCgXzW65B3L4DVHJbqVSMK0GlsI1Gw5jVbn4GB2Kpi1HI4tac65AsDNdE524MmdwyKKJWTd/jIAjQ72kauYha0Q+bcbhav1wuZzRuuVxOaWiaD/q/mykYx3Gq1RkAjIyo+ZydncXs7Iw5Lp2Humjx569QzDYgpX3ca+e/JRGsbNnN3qTw+3qSWwK55LLNZUtYAgICAkUEQhpOBsryIyBF4QXpcKFEhJomhFxt6Hz7YglL15Q2LIdKW9R149C1pTWjHQqkkZIIZd3zoKv950q1hOaq9qUD5Ud/8X99HQDwxBNPoLGqMIeWIf0sYI0AJF1NViwFhqS0sXJNj0ONp92RmXAT1/YioNx3CzqFYTrc2Gq1TAiKQE4pY9PvkLSVtWCGUwQjgCJAjaKV1Dh4nv3qqgL/duseDJ1OB6N6LqFz5UtBCKk/F/TNGx+12IAJPervulGS7R4EgTXdUSmSa6nv1HUQsGp7HPoSn1wiFR7uI6vG8DcULAZR0VhJt9dm5yWtL8x82+xKjRdEXbTbulegrgkY0eQy+w/OGmvJVxNgwNNCCYGg+54Oi1NnJACGWXqQuFYyCbfGBsmWWAQkspliEulFYHh42IB5NJndXtvEzY+/9DIA9aAeO3YMgGXQoZswOrUbjYYyWaMeZcp1TYORSC8yc3Mhrs6rbMPJKdU4dNeUShX+g4//Lh55VNGPHz6iGIxKjQize/YDAK7Mq262om+zuFyqat6Fl4Q/IBacynLw0UM6PDycyXjjFN8k9OCS6wDYB6ZcLhszkhYoDhaScAZdFw3nRUu0H39BfU1CSMgF4G6JW7jD8y14HoILHPMIAKdDd8doXLM4MPsZ4pN+L1V0pI5hn8uufmYMuJz0zXHvvvtuAKpzM6DcJTfrlQsfmzvfnCTGBRwHyk0wC+XuQC65bHPZEpaAgIdj0GR7qVVSFQhZYA0AiiXbd2BuTvUFWFhYxOI1ZR0QSEOr//LyktGIKzrZf2ioZlbxnZO6sUciMTqie8RXFeB39aoyoRcXl7Cyon7bWNYx+2IRhUBTX2n8hmdqkUVA18jDTVyjuSEimajvKpWKl2aKg5BAOvToi3NbDUM5AR1Gu2VdCjsmW0JM5+FgHh2XZ7Pxv/y3huW3WslkgfIWYu618TAwt0J856LfkMvHqcJcwC9O+iY0nEi6lj4oUZCuHdCUZcUwkydQLBZNGHDfvn0AbG6Amss05Rff5svn9xGDuOMeKLklkEsuudyobAlLANqf46tj4qyYKkNOLdOUvPKlL/+VwQQSrYKba20D1qzp1t6EDSRMG05OKrDrjjsP46d+6ifVcRcUlvDqqyfx8nFFVkp9BH7kRz8IAOh1I0DQtKmxDY+NYXKnCoF1WhrgGrVakIA4upa1tbVMs1ReRWiy5rRW8lXvcd+fjtVut00FJc3LHXcqluSTJ0+mMAlAhfdIf8TU+oxpvCFdKl0S1koz802dnyoVo3ECBIrcAAAgAElEQVRd/z8Igowvy+sEKHmp2+2mahGAdPiQPhPmUK1WjS9O546iKNWXgB+j2+2mfqvOUzQYE5VM12qWZLWtQ6s2qUuYcCsBtjPT04bAhjAVbrW4GAUXbtENqvLjyXPrdSASQhir5nqyCTNjWffbDUQI8QtCiGNCiBeFEJ8QQlSEEAeFEE8LIU4IIf5ECLE+rJlLLrm8oXLDloAQYg+AfwXgqJSyLYT4FIAPAHgcwH+RUn5SCPE7AH4GwG9vdDxKnyQtUgiz1X7UVpzy19///vebFf7MaaW5z58/b33vslqdFxcVDrB8bclozZ0TStueO3cWJ06qyMKdRxTCP1KfwJ133A8A+M63XwAAfOVLXwAA3HvPfZiYUtq211MapHFtEYmuJ2ivKc20uLTKqhMVQk9aq9frGUTarV+nuVBicQCXurtWq5kQFB1/dHTUzN/DDz8MAIgTIhItG+T69OnT+rj7zGeeIESkmYTBkKysrBgrhWtdmlNL+27bkRvuBUoD7lmtz1txEykMaVaSTqdjrB63ghGwiVJJkmT6HnAE3g3JlkoFJEmaDi1OImZ5pjGqIAD27lUEM7N71f2/8667MlqWRzVc622QXA912HpYAq9FuRFL4GbdgQKAqhCiD6AG4BKA7wPwj/X3Hwfw73Edi4ALDllGFDWRKpxlc80B9QDQQ3Dk8AEAylX434UvAQBe+PbzqWMMD9dRr6uHl4NSxE784gv2YaOH9sD+2wAAK7rh6IkTJ7B/vwoN0sN5+fJVnD17FgBSBTNmQXOyuBqNRoZjnoN/JDyrkI5FGXX1ej3Tz77T6eBtb3ubvlb1Yp6fO6Pm58gRUzNApmuz2TQvDi1Q3C2hF7PVVWYwz7KjxWtyctK8/G724fLysg3n0qJXKmbckn6/b/o70F+an0ajkWEWXllZyTRekVJmFxwWgqRz0bZOp4OEuP9AmYMFxhpMZCJ2saauwbQQ8ixWusc0nn6/n8kAHSQbvaT8GNxF4L+7mUXght0BKeUFAL8G1Xn4EoAGgL8FsCypcwcwB2CP7/dCiJ8TQjwjhHjGpQjPJZdcNk9uxh3YAeB9AA4CWAbwpwB+0LOrdxmSUn4MwMcA4MiRO6QUAgGzBjKkIkHB8LdTLQAPmzTX1Kpbr83iR39UAX0//uPpTKzjx1/Ey8cV+FfULcTqQ1WgoqbhT//88wBUw84HHngAAFDTWnPXXqX9L126gK/9v28CsF1kms0mri1foHnR4w7R7erQmgYXh+pKk3Q6PZRLNT0Ode7h4Tr6uo9Bs6lz8AN17tW1FWMBLC6q78rlKnbv3g0AuHBBJSgdPnwYr712DgAwvkOFOG87chcAYM+ePSYMWNAceYuLC3jLW9V1/t9vfA0A8PB3P2IAsAsX1DUtLMyb+T506JAam+mcVMSuXfcCsBRvVIo8tLNqNO90ZQoA0F6LjdVBYbW5uTlzXKpTIHDy/Pnztv8B9SaolwHdJrxas4Aiae1O1zIVA7pUXReGlMrU5jxKtWgHlMlPVkdATWp12/UHHnoYu2am09derhhyRqHd12rdZiu6FZqcbo2DpzJO7+eGj/l8SKn+qWMQaBkgDNLAIT83VVcOkpsBBt8J4LSU8qpUOZafAfAIgDEhDHw+C+DiTZwjl1xyucVyM5jAOQAPCSFqANoA3gHgGQBfBfAEgE8C+BCAz250IMqb9yVEcAJKdxUtFm0HmKhnE1DcJB0Kn9xzzz24487D+rfquGfPnsVyQ4UQb7tN+f9JkhitQ761TWsWLLGJkT4U00QmpVLJAJmmsZD+W61avv+6qJmxRjomSJopDGx3HTou+b2NRsNU7dXraowLCwvG36/OVFPzx1NtaR8hBM6ePQPANlydmZkxIVVKfDl/fticm4A7muOxsTFzvFKJGmpaOjXS4nRv98+OG21LGEWSJAYLmJpSFgNhFfPz8+bayd/mlYW0LYoiYy25rdJ9VZtBEJi5pPvZ6dv+Dvv3K5B4hwZfd+/ejTE9XpOuHfUGgno+GjBO+sktgSTx++zr8QVw4e+OL4lqI0zihhcBKeXTQohPA3gWQATgOSjz/i8AfFII8R/1tt+7nuNRnoA7Sdw9cC+GU5RzdN3upo9l4vMtVpSjHoaJiV2YnFQx/iOH7jPnohcRQh3/4O2H9Xlsq6q2pt2+cuUK2jpScPmyoh7v9vsqpwBAHFOsl4qcqujq76j8tdXqmAIpapDKATGTD6+Ptbi4ZF5Iuva1tTUzbnqRe9rF2L27Y4CtiYkJc527dysT9+j4UQDqZaLvSQ7qLs9BEKRqF+gvAYP0O3qhebkzLViILfsRbWu1WubFfe6551LfDQ0Nme8oGnJt6aox9SlKsbKykokicHITN4eh0+0yghmd8VgIzZzefvvtAIBJvShVq9VsA9ggG/1ez/QHspl/UsoML+R67gBXcrzs3n1feAbuRtmGNxUdkFJ+FMBHnc2vAXjwZo6bSy65bJ5sjYxBLbxqygUGpbQ88TyP3uzXz5KLWDIHbVbLyIBjZEaOjgwZ01xCaYtarZxpUU188XEcI06UximVlfm5a3oa+3U4TejKv1MnTkJjShgeHtMj0lz9Ky3Dl29CikKCQpm2Eak65+qqzTnoabBxcnLShPDIwqhUKibcKXRb7LmLqqZieXnZEHsY87fTMZp0aIjcnn6qXJnvXygUUkQddO6pqd1mnIB1TzqdjnERymXNlnx5EQsLC/q3NqPu5ZdVrsaePXv0PVBze/Xq1QzHoJTSWB9kHdRqtUypNH9e6DPPYCTLgZ6nnWOTmQxAX6zftDkrhClt7IrLQO3bT1U/+l9Dn0k/yBJwf/N63IG8diCXXLa5bA1LQK9u3W43Q8nFOfVdn4mv6mk6JX8edRDYLC6ZaD96tYdKRWkuCUrgASrVdOJLt0fnEigUdf55QefA14dwz71Kc03PqLDX4sIVLFxVfnmrtaavSWnY4eG6IRyxpJg9E/IpOuQVURTZ/HNGckEam3xfThI6N6dIVsta0y8tvWLarS8vKwui0VjC/W+6V4+DQm3CAFV9bV3RuYeGSgh04Ic0sawJs40iUVK360pioK/njf4uLCxk6v157QDVJvBEItfX5/UEvG8CbaM5pe+klMbioe+WFhYz1sHRo0cN/lEb0rUAjHS13UuzKfOaABcv4NRghDlwTIVECIEkSofwfJqbA4OudeLbn1vEfz/YhjUgyMEXulCaaH6hPtbWPrshLrBCL1c6884i5LZ82YIp9CBDg3UUhxWBRBTpqENC5wlNdGBslMzTislPkImNXNC1kZlMD2C/37edbZvEWGT57cw1S3sMvrjRuAkQpPHfpl2AK1euoNlU5vT58+f1GGu4clm9dPQil8oFlErqpaMMTQ7M0TVbWvSC2UZuzJpOnVaAHxVxLelj2vvEs+vcF8tEdth1Gj7BUKbKimmu6EV3SUh4tIdzDdIzRkzVMzMzmdRkwZ61DGtwkm1QwsU11we9jG5K83oZfrxEnST1DDu/vZ6U5NwdyCWXbS5bwhIQzLxzgROX7onvw1c9zlJrv0+fRxV1qM8WcLThlYhZEMVKMfVbKjtNkgSBRvwSyh0IQoiCOkZ1iPog7DNaau68yqSDJq8YHqp6CCrKKBbTrlC3pzQ370lQ0CBgtVpkFF+6kKnRMGE60uyvHD8BABgarhkXgbT4ysqK4SSkOdu1e9Kci4A43u+B3AD6y8O0BBoSOLm2tmZAQGricvXKfKZ2oFgsmjHZ/g5WY/PeEwAQxd2MdpVSmrCiW7glhDDXYiwYIfDEE08AsLUAteEh23OhpM1vPQYhBCKZbfZCkiGEYQ8fWShCiExxkxACSZx+5n3PNw8juqHHmy0gyi2BXHLZ5rI1LAFkfRcX9HBJR4D0qhjzlY+OJex+gE6q0PUHoQ9Miax2TiLHlyIwho2pyBheY6ci7fbDd6GxovzQK/NL+lrUvp3+GvPjNYVXbLPPmiu63ZZmGBYIIJD2i6OokVn1e70eLl9Oh73KVZ08tNTIsM72owALi+oaCOQMQpudaAhGS+q7hcY8xsbG9Vyp6z1/4TxKGlQsakbcZ555FoAqqybGYrIIWt0V41vzbEzXAqSxlsvlTDJNEASZhqG8twD9JcuAZ9SRZfndb38Ms4cOpI5bqVQsDuN51uiJod4BfMy0jZ65VNhO/zKJE4Q6hMzrX3ifBpoPe9y0hg/DIPMeqNb16eaqr0dySyCXXLa5bA1LQAjTYNPVCNw/GmQt0DFov0FI6aC0ZPpsEGEPP/x6fpqPKmpiYsIkvryk6dDNCi8SkyKcMLJQ265chSejnkXP6be+Bpn0XafTyfjPsfZjO52OSYAhHzhJkkwzUUUqkm3eCSgMgTQ7WQKXL88jANVvqHFQCHJ58ZolGC3afgg0XvLT+fncHHnVcyFMfZdI23yUh1FdGjeuRd3mraOjo14/nuf0vx5Zb39fog//G3hS5N3f8qQ5HjkBiLtgMP3YRrIlFoEkSdBqtVJFF27Ml4eRSFLuAGOwdSeauxbuNn5OvkCsB/S4N1xKmVlAisVhUxZLQg9/IbT5CgQWlsvFjInLx+Orm3DDXjzeTi8MlfXW63WzCOzdu1efs2zKeWnchw8fNoVDdPy17prZ34gGs44fP46zZ84AAM7qugky/REnWG4spY5fKNleB/TSEnBG4wTSrcx4KBGAaTgDWOKTOI7N+NzWYFEUmXoGuieHDx82YDIHIdeLva8n6+3P+0O4z1qSJIbncb1FgCscl5k7DEMTzr0Ryd2BXHLZ5rIlLAHuDpC45jdfRX350W6SEf+er5icVoz2cTOw0mHGbHjFBaq40LZWq2Xy0Inbj0g6on5iQpUUHiqVZIYCa7iuNFW73TbaijcVdU1cABmtGbF23WQlPPbYYwAUcEaaka6pWq2aOTJZdlXLCVirKaCx31HnmZmZMS7NmddO6TkggFUiCNOZkb1+3xyfgEHAhngpvMjDiK47wFu18249ZGHQuHliEvFSEnlJrVYz4+ANQ3lC10bCQ3O0P69qdQE/n6sqhDCxbJ8b49uW6dHBLFEfv+JGklsCueSyzWVLWALQPi8niyAxfjSrMPStrLzJJQeLaBvtT8KTNXwYwqBUTg7M0KrLe/qRJq5UKiacRjRgxleWsSUaCbKax62WBJBJplpZWcngIXEcZ6wlOtb4+DiOHlWcAZQf3+12M0CcD38A85Op5oH87rEdIwiE0rLTMypFmXo79todSKh5CXVHn3Jguy9RCFJRg6XBLt5M1MVxiqXAfCaQM4qijDYk0pBDhw7hPe95DwDLdYAwSIFt9NfUiuj7yDEq10rgIdf18vd9WBPX1IV1egq4x/eB22EYotttm898bEmSbNjHcEssAgK2LHhQ7rMvA4rnlftuCJl5rqnmfnbBGgADQToprdnOc8ldQLPT6ZiFgcpd6YE9e+YCiErdFN1ImydASDoxf/MuvJx63L25vMjKuDiaK49HK2iMlUol8yJw8NTw2gX2oTPXrKMOUdxDr0Idf2kB1/MopMmNoO/a7a45J6dbJ/IRenF9YC53I8hl4pERd7GnRe+BBx7I1BWA5Q7wa3eBOBLfsznohQTS7dk4oYmrtJIkQaGc7iTte9Z9io8vjq6LwJUcnX+Q5O5ALrlsc9kSlgBgzdBBOdCcJ44kDMNMqA0AJHG20Uqp8+jDAgv9Bfb4ArTK0uqZJZCgjLAgDLKmnxSmaq9cUhpntVVFk0grQrXSj4zu0OOYg9Rt00KdFVgQBQSCylH1ePTfREr0dDZjqOPBYQEItZaPdbZYoVBAos11U+sAZX1cW1pFrBucJlIfIwjN/hCUeZkYoEro84eCtRPXFY6UJVgolCBG1XEP364auz7/nZf0vMSmsavRTEETlRL1YaCS3yaGRxTg2NP1EqTlRqoj5r7QvPcjiaKe50BnKQZhYvL8Z/ao5iDveOe7AKSbhMLcW4FCIavtB0kcx2YcdM+4q+JmYwZBYJik0y3k1TnKZba/sXT0b7nb4ea1IDHZhqbCUYQIgg1al68juSWQSy7bXLaEJUB+iw+44+CXC451u13rOzLt7UsS4sca9Jn7gT4Qks7thmG4L26pwarGHyZgkLTzqZOvotvu6OOm54GOpwcEACiGlpyTtEuv27ZkItKGAaPE+rf6g/eaaR+zH8Nj3fTzYtlyH5gOPpHN2KP5oPHQWEWlYnoYED4yOjpqvicCEf4bHq4D0gSfdIx2u220O2cbJsbkd77znQAsmzEHm+lzq9POJKTxcDFPUiNxMSb+zLohRR6O9vnzXHyJYABZH9Kci/b1ZR0OCltfT4hwSywCJBzo8wEuhhXWEINYpDlgnXNdINCNtbqffTfLXUg42QXn3ANUbJvi3CamHRZNme6IblIyPq5M82/9zVNoaeKNfl9zByY9VDRnIaUNJyzKYZtPkDlZtuXI0rLfCOMJ6fnTL/DU1JQBKPlD5i4C6iFLz9GKzuwrFovmOgPYhTOO0qg88TMmUYSCjgrQS7u41MgAZv1+fyCYyxmU7QtazrQ+e9vb3oYf+7EfS+3HF3X+Mqs5rqUWBzVnImPW85fPPS53B9yXkOdx+J47N4rDP3OWIt9L7ComKbOMxXxR2mghyN2BXHLZ5rJlLAHiTndDM2TuJUniZRs2v48HZ/b5ikJ85j2JTyPwVdc9/8TERCbUJoohEk0/RXReV6+q+PnQ0BCWSyokFsfanO1HqXAXACTUCotdGi8gcok1wjAECjROfU16jDt27DB5+fRXSmtuStjxu5YUZfa1221jCfDipqbWytSU1fA9hqHxRmiMQ0NDqfAYoLStmx/AtairxQuB1dA/+7M/C0CxFLsWH58rV8umXCEtXKPSb3ncnTcuoe98ITm+Dx2X7+N+7wrX3K614nMpwjBMFaLxcxWL2ZoUV3JLIJdctrlsCUuAgEFfJxWeaOF+l/Z7suW/rviyz3wagZ/DTQIKwzAFJA06nwLM1HZKEiLtzDny6RJEIlKrNwD0DddpkvGZO+2m0eg9Db4FQQCyaYzPqTXD0NCQ0eJ2Htl1pzROWnP1GFkHAYNCh8uq1SriyJYaA1abF8MwQ1/W7Vuri1t2PEOQj5+Db6YNOfq47z7VLYpqAQBrQbnMvz7futvtZolD+didBBuOE/lKj93MS1/bvEE41PWAdxuJDyy8XtnQEhBC/L4QYl4I8SLbNi6E+KIQ4oT+u0NvF0KI3xRCnBRCPC+EeMvrvJZccsllk+V6LIE/APBbAP6QbfswgC9LKX9FCPFh/f9fhGpNflj/exuA39Z/NxRK/Bm0evJV17vaeUKE7l/Xt3SPQZ/jOPb6f/R/X9TB5RPoS1vBRscglHvXrl24OKcqClstpb3K5TLiyEkp1UkplXKZoeW2nbbbIahYLAJJGhMo6nHV6/VUSrO6JnvtxI6lxpquSSCNybVyr6PCgXNzczhzWlUPzs+rFuam7oLdT1+tBu8pwUlN+NzyCIZJd67W8O53vzs1Vzyl2RV+TpJiuZSpAExFS4DUd/z8/FoGhQh9JKSDMAGfhbHeb10JggCJHMyhsRE3woaLgJTya0KIA87m9wH4Xv354wD+D9Qi8D4AfyjVyJ8SQowJIaallJc2OAe6nX4KIKLMNP5ikvkbsD4CdIE8d9o3mUB6Qvji4k6S7wZycRcBbjoattw4QaD55Oo1BaxR3Lr35jZefP55fS4dBuz2TLgwXlOL1U7dKFWIBNQYVa8LaLdtQ81eTNl+EQolqjtQO66tqPDexPhO1CrV1HfFQsjmwRYhmcxJfemRaawaA7rDM2WtIemg3VrWY9Psx4wZudfRmY4GcItgOfrUIbrdPsgobTZtE1YAWF1dNnn/FGac2jWNHeMqEzEs2PAkkfZmzG8hjLtjQ8oB2q100U0QhJYP0MlEVdeeDhH2ep0MkO3rFeFTIHyM/S6xRmfrYOjpozmT0jIz8UXddDbWfwJBXIYBhnUYdZDcKDC4i15s/XdKb98D4Dzbb05vy4gQ4ueEEM8IIZ6h4pFccsll8+XvGhj0oRFe1ENK+TGoVua4++57ZRiGqQwpMu04oQTnvweoj0C6tNUX3uOAm2sWcl5Dn2vgS+pwQ5W9Xi+TSFIQBcP71uprmi4WSuPjBRRY2On0zPEAm1E3MzNj9iPSjVKpZNwBAvyAbAksafhms2nm1oTwEGesJmU6p62lXp9x5GuN0+urMS4sLODSpUupeaHeCKEoAMiWXdN+ppUZC82RBcArMOna3/ve9wIAHnrke4x14APyXJeSZwLy7FB6xriZ7x6Pu3zuXHH3wwV1+fnXyxIMgiCT6LNe2XAcx2aO6HemqS2yNQxE3bee3KglcEUIMa0HNw1gXm+fA7CX7TcL4OINniOXXHLZBLlRS+BzAD4E4Ff038+y7f9SCPFJKECwsREeACh3jVZa12fnCTRuwocPZOLCyUcBv59G1Yt8P54wwwEq+r+bSMLzuTmQkyTpWoBC0RJhWO2jwcBuZM5hiDcDm5ZM+xOuQBaBe52uVqnVlLZaWFgwpKNErFEscUwAZtxkvNE1mVBkr4fGstLejRV1/nPnzuG1115Tx9NaMNaViTLJUmEFkJn071KpZMKLZNXwZqFEDfboo4+qeS9aa8KEMXu9VFNafnwgm9bbarWMNUa/K5VKmSalPi1urYmCN7mJ/+Xf+b7nlsB6FqnvOwK6y+VyhkDHB8QOkg0XASHEJ6BAwAkhxByAj0K9/J8SQvwMgHMAflzv/pcAHgdwEkALwD/Z6PiAegCTJEl13zXMsvqhKJVKGaSULxqcgtp9IX0mPb/JNIE+rjlfXUHF6RrsMxWLlbJF6EP1Ukdx2tznUqlUUC6r/egF70XKzJuYmDDn4hx8NCZaNNrtdoZCnObl5MmThk/w7rtVyW+rvWbmlxYj9RKkr4XPI+ciBFRuAG8KCsCAa+rlCszYACCBYKDfqjkG1QC4jMGzs7Nm0aJtEyM7M66Nr+6ER4NcevhSqeRlj/Jlj/K/vu/4Ofn/fS+u6zaGYWi6ErsA9aCsRh8jkrtY+J7NQXI90YEPDvjqHZ59JYCf3+iYueSSy9aRLZExCKjVrFgsZsw8np23Xh71eo1A1svn5p95jvV6JZm+1dmXkUaWQKmQPv/OnTuxf/9+AMCxY4qAo1wpm/CY64IsLi56r8EFx+I4NpaAdY/U/q1WC6+88goAGCqvStWCi6bqUAgTIrQtuQJzTWVNBEIt0E+cOGHulWke27fZf2GYpmKLe/1MM9YwDDMNSWkObrvtNpNxSWzNhVLdWDC8Z8Egk5hbCSQ+Vmoe7nPvMc8dsZZGnDoO/44LVVUODdmGp7zxaiFIP7scBKTjcSDZ51L4rI7rlbx2IJdctrlsCUsgCFS2F/fHaFV2200BafINt2KM7+vz591j8P05YHU9viDHKNz9VKhSrfrNNeXHX7ykWoM/9dRTRlMfPnwYAHD65GmjLV2tyJmFOW+Bq8GKxaKZLwteqkSl6elpsx9p1KldE6ZCsFxWWrzb7Wbag6+utc3//+oLfwkAOPWaankeRz1jrZV01WNfU4RBSnMtnA/Bzdzkuf30DBARy3333We6JM3MKNqwKLHcEjwkyvsS8Hnh2pNko74CrrXiHg9QIVZe28LHz581SnLilmYqpBk7lhcLN9I5CTPhmECKsXidepacTyCXXHJZV7aEJQCoFazX62XCb4QMt9vtjN/f7/fNqkhhLC7u6h9FUcZKSJLErPpuiGnQON1Vn28zOESQoB+lIxwHNd//zvERfOHznwcAXF24rPfvIU40dXdRaTJKKY5je53ttsUvaD5s78AW0+xqPlYbKuFoYV6C2qH3+8pH7bSq5hydHqXL9tHuKe39/AvfBgA89/S39O/6JsxIvvj45CSmplTC6PHjx9XY9PT1+7a5aUun6HZbbVNdyXUx0UHsnFDHOnznXWouKjVc001QR7o6BRmJuVdkCQghTPKRj2Lbve/9fj/zPPHEMXomOIrvYg4iyPIfkHALgqwhnqzGrV7CBNzITqfTMRbjes8k50vwWSYb8QlsiUUgjmM0Gg2MjIyYF8ZttunLCOONRgh84bFy10Ty0U35Sj75MfgY6dzuDfdxzSk242zIB1CMxLt2qbqAM2dVjL250rA3HJTlR3z+diz8YfDlK1DYjVwL+ttqtVCv27ZfQLqhBs3Vc899Gy+9osDKZksd68CBAwCUif6Vr3zFHI+u9/Tp0wAs4EjHUuCoGi+9COViEQUNlK7pY0gpUa6q+04mP7kDd955pzGFjenPmKW5ie62K+Nz5ob+SqVSxu3hIVD3ZeJiQDjYELVbvMTBYlqYfQVyAAzfpHsvyuVyisqM9vFRlNGzw5uwkvhyaLjk7kAuuWxz2RKWgBDBQGDQBQjV/tmMKm7Ku/UE3HJwV3iecMQJLV3wihNOugCOECKzLQgChMYd0au//l+9Xsfjj/8QAODtb387AODPP/NpnDx5EoANv9EYOakoaX9Ot0Y1BoVCwWgdU2lW0WG7KDFkrEPaImg0VnHlpCoDntKWyaOPvh2PPPao/l5p9tVrygU4ffq0sbhoTk+dOpWpBeD5/26mnro/6Wq5YrGIsXHVvPWHf/iHAQD33nsvAKBar2fMWT7fdIwoimzGopMpCmRdQ04Yawlekky4k5cZu+HrJIm9ViTt4zPhfUlo5Mr6AD9fmNuXRejWopAkSeJNTuOSWwK55LLNZYtYAqo1eafTyRBIkC/JtTjXLm6ShI98hCdcuKm2/Hik5cIwzKSU+kgreQpoJlkpCEDQl4xJkxE2UUC7TeCP+nvt2rJJCXajV7zTEteoLvU5xwRoHF09fzPTs4avgLCBqakpHLlDAXAJKMGnj1AnBBEoO1xR/i6nBqf7Mjw8nEkDpu+klBmylV6vZ5qalvU9qNVq5n4QeEqYyVJjJVOhF/ds4g7v/edqdksGUxkAABczSURBVI7TuKG7UqlktvkwAZL1ksQKYTaVncQXluTVjJxAt1JK91rgVYE+sNolZY2iyFgTbrp4EAQbYgJbYhGQMkGn00mhpy5xAuBvLOoKj9n7Ou7Sb+mB5aAKPYiDYtmAn3WWA09mAQpCU5QjnArrKIoR96nwRV3nzPQeU0SzsqK79bIOwHQtBJJFUWSuhb909OIalFuTejQaq5icVMj77KyKu3e7XVBjVGp9FYYhYp3pSKxH8xfOAbDmvjsvtN09N52Dz1W5VDaLUVnPuxDCZAUSCMnPRb+lbdVSNWOu+/ImCKjkyoVHkVwQkJvfbrm4L2OQiD74fj4XwO0ZwfcPgsAoGNctHZT96ssYJKDWVaLcfRgkuTuQSy7bXLaEJRAEIer1eipX2hdPdc18vlK65anub2l/zmILKE1ieP4ZqOe2w+KgjS870M0mS4Qw9GKBbgBKob8kYuGjIRXjn56eNqE2qsKLY5u15rYmr1QqrH+ArZpz3YHhYcpWi7G6otyd5WVFB1atWNCNyJrDUEKa61PHoJbmly9fNtYKaUqyQgCrZVs89OfMI+IEUmbDWCSmexFp+IJty24qHvuJF3B0W4dRxyUpZQY441mK6fJvv5XJnx27f5R5Jkk4MMjBS193LHIHXOHvA3d73XH43C7uCucZg7nkksu6siUsAdLG/X7frGDr+UW86s/nw3GiCWDjKkKf/0caiYT7WC5Rhg+gTBAgCF1NA3P8YrGsz00kJ0WMjCi/2M1g5ASspAGnpqbMOCiLb3h42JCOkIZeXW7q8xRN6PH4y68CAO655x5Uikq7StPmSJrqRzrnX3/9rwEA3/zmNzExMZG+ziQxvjpZCWRllUqlTEefuNc3OAinHKOsR7eis1quZDP1QpEhBCkUCpk6EzpnoVAweA8Pl7nPE/+tGw70cRPw3/l6EboVgENDQ94KRzdZyPeckkXlS1bjNHuudeUDuV3ZEosAiY+1lxNa+MpB3YeGm23ujVFlsmmiEb5o0M3iv/UxEblADx+3LYFOkGhDK9LAYKLLahGGiKUuzmmqF+jVUydx8aIqMCrqjLoYlkm321UvdbVa1+MIzcs0Pa3M9ZWVFc3cC5OaqwmGkSQxiiU1nr/+2lcBAKVSGffef58euTZng77pJNztqWjF3zz9rB5XFYUwzQHY67ZRLqkx1aojqXmJIsuWVCzosueuRK2qwM1mh4qLJNZWqXtxem6bzTYD5NQ5K8WS92UaZJpzUI9n5bnPGG/86i48btdsAKlO2D6iDxIOYrovq5QShZJ1TQEg8hQhGZdSSsRJepFOkgSlQjZyRt/dKo7BXHLJ5R+IbAlLQAirkV0gxMcU7OZY8228YMLli+NFN7x8mM7JQ4Q+fnj+f9rPPQYvUEGoTUoC7nSD0l6vg3Ixra0mJydx5aIq8SWArVxTWXTLy8tmPJxIhCwQMvPHxsYM6Gfy9/vWWqlok/KFF15Q4+5L3HHXnQCAmj5ns71izPurC4o/9tVXlfswPj5uQEK63m63m7GWeFGPD8SisVHhUafTM5mO5BZYOjJr2ZkSa5FtJ8eLuDYqE6ZjudYB5xjkeQ2ACim77eejKNvo1GfS+wg/+LPrunr8GaLvuKvFW+K5x70RyS2BXHLZ5rIlLAFfco67wvpCHTwEyDWC9SebqWPwLDFOX0bbOBmFC/6RFuK871zLueNNZamZMarvarUa4r6uqivbhp2k0U22H+uzQFqftNHy8rIZG2nUbrdrqu9ovBebKmEmiiIUNUAwNKSOsX///kxtxs6dO1Eoq3ON7aiYbXRtly9fNscDFIDrct3zMGzGR+3bMBlde70+bBiLz5w5o8eocINY2vAoEaUm/cE0cDRfGwm/x/w+0jzQ3NO811kNA69FWS9ESOL+ju+vyGfSFivPhnT7Mfj6ZIRhaNrP3YjklkAuuWxz2RKWAK2GvkpBzq1Osl51FkeJDfEl613gppt2u12z2nN/0M3V59qfV/LR/q4/KqWEcNI7E2G7ApHfPTqifOHV1VWjvYeoqgxVMwc0D5yggsbLLR6qP3DnoNXqIYnVfj/w7u8DANxxxx1W++hxLy6uoqeTlPqRGiOFBefn5zMWT7lcNlrTrWUQQmSQaV8EKI4tTvD0008DUMlTAHDfm96SSuyi3/kwGhJXs/J+E5xAxK0tkdJ2QuK1Je53JEkSZ87vswz4eHy1BoNozjlfhi9pznfNLrFKoVDYEDPYEouAlNLcWHfAblsqLnxffoPcSfUVkvB4sC8ry/2t7/8+ggj3mgALDMqAyqOtCfjcc88BAJ599llzrQQCycCyJtGLRsDf8PCwmRNunroszZQ1Vy53sdJQLyQv+TWmsB53pVqF6KttJ0+pbvSUh9BsNo07wkNi7kvHcyzcDE1Vr6BzQerUaKRk5uirX1Xhy0OHDgEAbj9yp5kXWuDGR8cyITmetekuSjw7kJvmmZAfCy9fD9gWxVlA2PdMuM8cF1+5MD+W6776FE4URegn6lngeRN0DF837tR1b3ilueSSyz9o2SKWgCWFcLWyL6nHF5rjmVq0evpWRZ+p6IaFfFrARz3Gz+1aH0mSAIFrPtqVmwCwb3zjG2aMJd13PNadh5oddcylpSXjBpAW54lNXNu6WqJct2HEQKj5IEtjdXXVVNpRRV+r08GleQX+nTp1yoyXxmjaqzMrxC1tpXnv9/uYn59PfVcuFG2lW9U21ixQmFFbDAsLCwCU9ifrg4DBfqfr1Zqk8dz7yT9zTe8Swfh6Eawn67mlHCzmZCc8XE3ndPP+Sbj7wJ9hN+EtDEPT3pyE19L4OBe5bGgJCCF+XwgxL4R4kW37z0KI40KI54UQ/1MIMca++4gQ4qQQ4hUhxLs2On4uueTyxsr1WAJ/AOC3APwh2/ZFAB+RUkZCiF8F8BEAvyiEOArgAwDuBjAD4EtCiCOSktEHiQBEIUTMuphHOjWy07K9CV1SkWKlnMkTl4GA1CVxke6kE1JKrAB6cTq3WgQC/cQBZsD9N0rh1dZHnK184yu2sUgigWpNh99aypft9pSv/Jd/8Vm8pqnEDFmoEGjrVN8rVxRdWFCwICZp/rU10uIyFdZTcxSaZJsw1MkuiRrD2M5doJbjRGPWbDZx/31vBgCMDlOdfYJaXWno+TNKi4cFNa7dOyfQ00zEjRWFTSwvrZix7dw5qY9rrRYKeyb62jqRZSCeWVVWzY6RMdx+UPVfMIQaevpPv/oahnSaMaUeR/2+2Y/z8bvAHYnPIuDgoi9X3xfW87UrJ/F1LHLrDvg5uXb2VbvS79wQLg8pkkRRhGo9jdXw6k7eut4n19OL8GtCiAPOtr9i/30KwBP68/sAfFJK2QVwWghxEsCDAL650XkAf1NJknK5nAFteHYgPYi8CYWbreZ7GLjwba7rwYEo3qUXUGY1vYicRMPHdQeoG+Rmtc3NzWHp2rI+rq6DKNjMMLo+MpN5fgOPadM2IvgQ+qWNI2le0uUlVW587twZXL6sOscTy+9tB/chitR1XV24AgAYHx8z5yQ+Q3Ip2u22GRvlEFBEoNeLbOYfXW8IJLrZxvnz59V5ilcQ6gWqXtOMyIGas7948klcuqQaW7/v/T8CACiXi+Ye+5qE+FB/9zvOROSjHHdZfn2LBo86+Ex5F2iuVCoZQJODue4YOVDO93cXqHK5nOF+5FGim3YHrkP+KYDP6897AJxn383pbRkRQvycEOIZIcQz5Jfmkksumy83BQwKIX4JQATgj2iTZzdvKpOU8mMAPgYAR4/eI2kVdk0t3sDRtQ54uISDK+7qTL8b1KrMxwXHxgkgDRoROEf71ev1TBlr1E/grrGU6zA7O4tLuhUYHX94eBjNNaVBGw2lqYdG1P4LCwsZ5mReoUeLaBAEqToCALjt0CwAoNvpYe6cOu7+fbeZ+WhqjsP9B5Ql8MhjDyFK1LU0v6S0CYFOCkQlCiw1351OB7Hev6ddN95YlfYnFy1B31CZDQ8prR+KAEuLyvUoE0+g5jUslQJcmDsDAHjluIKl9u47YK6Pa0g3FMe1rptnz3NBfLUG7v48O5DOWSqVMiY/P5ZbU8EtBxpbr9fLWBE+C4ZbJu5xuVXjZldyAHSQ3PAiIIT4EID3AHiHtKOdA7CX7TYL4OKNniOXXHK59XJDi4AQ4t0AfhHA90gpeUrY5wD8sRDi16GAwcMA/uZ1HDcT4toos8rdn+/jZpr5fH4e8uMrvbsa+37LyVBda6JcLho6MbIAQu3jP/bYY7ii/dxjx44BUP4iATh33aVqARaXlCZeWFjIEmswTcYrI90swiuX1Bo8O7vPNkjVnYUCUcDEhEomOnDgAACgWq+g21PXPDauwoGvvaqAxFqthiAgYE1pvr1790AbNcaCSRLL7UDAnWGP7qwai6ykKymDRGCoruZoeEiBkh3NKxAgxlpTzcPEhMJdFhcXzXVyMhJ3Pnz9BEh8/BQ8Wci1Jn39JuLYhobdtmU+0lweSjZNXFknJPeZ84GHPquFWxi+Vn0bVVVuuAgIIT4B4HsBTAgh5gB8FCoaUAbwRX2hT0kp/7mU8pgQ4lMAXoJyE35+w8gAAAm5ocnCC4N8C4SbE0C/AbIgD/+OZ/b5wCU3vsw/+xqSGHdGCBSKGtnVhCARi6NzKnUAKDH2G4uRqPPs3LnTPOy8wIVeMHIV4jhOFUsBgNQvdGe1g+ERKkJR19TqtfETP/nTAIDbjyh0vlQpABpk/6H3qsXo1Muq9PjZZ5/FweJ+AMCuljI3L128goMHDwAALlxQC87+/WqfcrlsxkELYb+7Zq69sahcl3KhgpZetCJdWFUqEgtyjBHtNjz55J8BAI7e/YChJidORV4G7C4GQBbgHZS95xbxkHBXlZ6JdrvtdUcBBY7SvaLFfVBG4iAw3OcO8O0+NiHuqtB1DIqakFxPdOCDns2/t87+vwzglzc6bi655LI1ZEtkDEJac249UpH1Qj48ROiCL77Vl2f9uZx+/Bw+U8rVKs1mMwNojo1OGH59U6dQ1CXCnS4efPBBtU1rr5ePHUuFfABAaDqyarVqVnsKzfFrWE/TjJeVFh0bnjC8hp2uGtfs9DT2ziqQsKS5BntRH4HJjVDHf/Ob7wcATE/vwte//nUAMM1TpqamcOJVlVk4PKwsk71795n5XNIujSkAk00EQlkko1UVOIr7EcQOBfQtrazqY+nuysUQ+/cpcPMH3qVyzyLUjUtBx+10OgawpfvIi75cy45blvxeu/tx4M+1BCqVSuY5pfmvVqvm/NyqcEHqQXUn/C8XX1iSN+ZxQ6Y+4NuVvHYgl1y2uWwJS4AwAR+IQdqu0+lkkjtSq2hB+z1BgJjovJyMwYCt/kTWKIRAWNQc+n0LaJmwjicsabbp2oD66FiWGippmyw56FbaYUwr9xB2zaoqubHzCiDcva+B5WXlIzdWVNVei8pCwxIKodY0db1udxMIzRBc0lqgWCmhS9ZJW4cbNWlp1Ab2TSoNHXbU7x55x0MYm1Tam0hRy6hC6s+ksTu6keno1Bj+0fcrLODkcQVovvSdb2FqTGlt0dUlzdBVayLE+KQCHons5PjxPto9Zc30dfZlqVxAEqlxj+9WZctBQOecwtAOhU0sN9X+ozuKgCnPVqeq1Guo6W0UJqXsUK4pOYDmamVlVegQrFN5FxRC02DW3OM4MVmYFByPErIWYL7r9on1WNj9WfWmm5hmHzmRsUwQBEjst3psBXS71hLmx+LXOUhySyCXXLa5bA1LIJHodrupyis35AFs0NNN0zbzhCBOHMp/z3/HQ218TXR9Pe7z+XzJTBhS2DGa/cz+wNCQSut9/PH3AABeO3kIr50+AQBYWlKWwKrOz28srWDhikqmSXTobHR01PiaFU1DXhseAuHEU7oisd1UGqJYKpmU4ze96bsAqKiD6cwTUq+ACtycr1ZLWST9bg8TuorwrW99KwDg4L5pXL2i0oUvXVaxwmMvvaSOWSjgtttvBwCUNbVZpVLB8pLS1JfOn1PHb65idFwTjGrKdKJWp/kFgH37lCXT6vjvI80zpXDz++RqwyiKUlz+gEoC8+X20xhcTICnbrv3n4+HW7BuwhG/hvUwL3csfD+OE7j7+MKjrmyJRQCwAMagOC3fxm+GC+BwoM9tJMGPxyfN12CUxLcYuAUc7m/UeWDcAHqpZEKLQYSiZiJeXVWm8YMPPoiJSfXwfvnLXwBgi2N27pjASF19vnpJvXBXLs2bcxJT8O7paZSoVRclamp7eXpmxoBtlYo61vz8PA4evJ1mAYBeKEU61kxjFSX7QPU06LnvwG3Yu/+Aur5YLcBHjt4NALh48SLOnVcLA5GhSAgD4BF70NpqDT3dgOP+++/X41Hnntg9g6ldCkCk3AcRWgDXxyfoywB1t4VhaGouOJDoNlD1CQeB3dJgH4vweuAyV3zrLQK+TtypEGLBX8PA35FBkrsDueSyzUVsBBpsyiCEuAqgCWDhjR4LgAnk4+CSjyMtf5/HsV9KOelu3BKLAAAIIZ6RUn5XPo58HPk4NnccuTuQSy7bXPJFIJdctrlspUXgY2/0ALTk40hLPo60/IMbx5bBBHLJJZc3RraSJZBLLrm8AZIvArnkss1lSywCQoh36z4FJ4UQH96kc+4VQnxVCPGyEOKYEOJf6+3jQogvCiFO6L87Nmk8oRDiOSHEk/r/B4UQT+tx/IkQorTRMf4OxjAmhPi0UD0lXhZCPPxGzIcQ4hf0PXlRCPEJIURls+ZD+PtseOdAKPlN/dw+L4R4yy0ex63p90F51W/UPygem1MADgEoAfgOgKObcN5pAG/Rn4cBvArgKID/BODDevuHAfzqJs3DvwXwxwCe1P//FIAP6M+/A+BfbMIYPg7gn+nPJQBjmz0fUOzUpwFU2Tz89GbNB4C3A3gLgBfZNu8cAHgcimlbAHgIwNO3eBw/AKCgP/8qG8dR/d6UARzU71N43ee61Q/WdVzswwC+wP7/EajGJps9js8C+H4ArwCY1tumAbyyCeeeBfBlAN8H4En9UC2wG56ao1s0hhH98gln+6bOByxt/ThUbcuTAN61mfMB4IDz8nnnAMDvAvigb79bMQ7nu/cD+CP9OfXOAPgCgIev9zxbwR247l4Ft0qEaq7yZgBPA9glpbwEAPrv1CYM4TcA/DvAlIrvBLAspaSiwM2Yk0MArgL479ot+W9CiDo2eT6klBcA/BqAcwAuAWgA+Fts/nxwGTQHb+Sze0P9PnyyFRaB6+5VcEtOLsQQgD8D8G+klCsb7X8Lzv8eAPNSyr/lmz273uo5KUCZn78tpXwzVC3HpuAzXLS//T4os3YGQB3AD3p23Qqx7Tfk2RU30e/DJ1thEXjDehUIIYpQC8AfSSk/ozdfEUJM6++nAczf4mF8N4D3CiHOAPgklEvwGwDGhBBUl7oZczIHYE5K+bT+/6ehFoXNno93AjgtpbwqpewD+AyAR7D588Fl0Bxs+rMrbL+Pn5Da9r/ZcWyFReBbAA5r9LcE1dD0c7f6pEIVWf8egJellL/OvvocgA/pzx+CwgpumUgpPyKlnJVSHoC69q9IKX8CwFdhezxuxjguAzgvhLhDb3oHFHX8ps4HlBvwkBCipu8RjWNT58ORQXPwOQA/paMEDwFokNtwK0TYfh/vldl+Hx8QQpSFEAfxOvt93DKA53UCII9DofOnAPzSJp3zUSiT6XkA39b/Hofyx78M4IT+O76J8/C9sNGBQ/pGngTwpwDKm3D+NwF4Rs/JnwPY8UbMB4D/AOA4gBcB/A8o1HtT5gPAJ6CwiD6Uhv2ZQXMAZYb/V/3cvgDgu27xOE5C+f70vP4O2/+X9DheAfCDr+dcedpwLrlsc9kK7kAuueTyBkq+COSSyzaXfBHIJZdtLvkikEsu21zyRSCXXLa55ItALrlsc8kXgVxy2eby/wErKTdYB4FPSgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# nuclio: ignore\n", - "# Select a sample for the test.\n", - "# Set both the local path for the test and the URL for downloading the sample from AWS S3.\n", - "DATA_LOCATION = \"./cats_and_dogs_filtered/\"\n", - "sample = random.choice(os.listdir(DATA_LOCATION+\"/cats_n_dogs\"))\n", - "image_local = DATA_LOCATION + \"cats_n_dogs/\"+sample # Temporary location for downloading the file \n", - "image_url = 'https://s3.amazonaws.com/iguazio-sample-data/images/catanddog/' + sample \n", - "\n", - "# Show the image\n", - "img = load_img(image_local, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n", - "plt.imshow(img)\n", - "\n", - "event = nuclio.Event(body=bytes(image_url, 'utf-8'))\n", - "output = handler(context, event)\n", - "print(output)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "%nuclio: notebook infer exported\n", - "Config:\n", - "apiVersion: nuclio.io/v1\n", - "kind: Function\n", - "metadata:\n", - " annotations:\n", - " nuclio.io/generated_by: function generated at 02-07-2019 by iguazio from /User/demos/image-classification/infer.ipynb\n", - " labels: {}\n", - " name: infer\n", - "spec:\n", - " build:\n", - " baseImage: python:3.6-jessie\n", - " commands:\n", - " - pip install keras==2.2.4\n", - " - pip install tensorflow==1.13.1\n", - " - pip install 'numpy<1.15.0'\n", - " - pip install requests\n", - " - pip install pillow\n", - " functionSourceCode: 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\n", - " noBaseImagesPull: true\n", - " env:\n", - " - name: IMAGE_WIDTH\n", - " value: '128'\n", - " - name: IMAGE_HEIGHT\n", - " value: '128'\n", - " - name: version\n", - " value: '1.0'\n", - " - name: MODEL_PATH\n", - " value: /model/\n", - " handler: infer:handler\n", - " runtime: python:3.6\n", - " volumes:\n", - " - volume:\n", - " flexVolume:\n", - " driver: v3io/fuse\n", - " options:\n", - " accessKey: 1e52ff93-a541-4880-abf1-d9b948af77de\n", - " container: users\n", - " subPath: /iguazio/demos/gpu/horovod/image-classification/cats_dogs/model\n", - " name: fs\n", - " volumeMount:\n", - " mountPath: /model\n", - " name: fs\n", - "\n", - "Code:\n", - "# Generated by nuclio.export.NuclioExporter on 2019-07-02 07:06\n", - "\n", - "import numpy as np \n", - "from tensorflow import keras\n", - "from keras.models import load_model\n", - "from keras.preprocessing import image\n", - "from keras.preprocessing.image import load_img\n", - "import json\n", - "import requests\n", - "\n", - "import os\n", - "from os import environ, path\n", - "from tempfile import mktemp\n", - "\n", - "model_file = environ['MODEL_PATH']\n", - "prediction_map_file = environ['PREDICTION_MAP_PATH']\n", - "\n", - "IMAGE_WIDTH = int(environ['IMAGE_WIDTH'])\n", - "IMAGE_HEIGHT = int(environ['IMAGE_HEIGHT'])\n", - "\n", - "def init_context(context): \n", - " context.model = load_model(model_file)\n", - " with open(prediction_map_file, 'r') as f:\n", - " context.prediction_map = json.load(f)\n", - "\n", - "def download_file(context, url, target_path):\n", - " with requests.get(url, stream=True) as response:\n", - " response.raise_for_status()\n", - " with open(target_path, 'wb') as f:\n", - " for chunk in response.iter_content(chunk_size=8192):\n", - " if chunk:\n", - " f.write(chunk)\n", - "\n", - " context.logger.info_with('Downloaded file',url=url)\n", - "\n", - "def handler(context, event):\n", - " tmp_file = mktemp()\n", - " image_url = event.body.decode('utf-8').strip()\n", - " download_file(context, image_url, tmp_file)\n", - " \n", - " img = load_img(tmp_file, target_size=(IMAGE_WIDTH, IMAGE_HEIGHT))\n", - " x = image.img_to_array(img)\n", - " x = np.expand_dims(x, axis=0)\n", - "\n", - " images = np.vstack([x])\n", - " predicted_probability = context.model.predict_proba(images, batch_size=10)\n", - " predicted_class = list(zip(predicted_probability, map(lambda x: '1' if x >= 0.5 else '0', predicted_probability)))\n", - " actual_class = [(context.prediction_map[x[1]],x[0][0]) for x in predicted_class] \n", - " os.remove(tmp_file)\n", - " result = {'class':actual_class[0][0], 'dog-probability':float(actual_class[0][1])}\n", - " return json.dumps(result)\n", - "\n", - "\n" - ] - } - ], - "source": [ - "%nuclio show" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Prepare to Deploy the Function\n", - "\n", - "Before you deploy the function, open a Jupyter terminal and run the following command:\n", - "\n", - "`pip install --upgrade nuclio-jupyter`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Deploy the Function\n", - "\n", - "Run the following command to deploy the function:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[nuclio.deploy] 2019-07-02 07:07:08,424 project name not found created new (ai)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0702 07:07:08.424754 140252009395584 deploy.py:317] project name not found created new (ai)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[nuclio.deploy] 2019-07-02 07:07:09,507 (info) Building processor image\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "I0702 07:07:09.507237 140252009395584 deploy.py:274] (info) Building processor image\n" - ] - } - ], - "source": [ - "%nuclio deploy -n cats-dogs -p ai -c" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Test the Function" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Run a test with the new function. Replace \"function URL:port\" with the actual URL and port number.\n", - "# To get the function's URL, in the platform dashboard, navigate to the function page - Functions > ai > cats-dogs - and select the 'Status' tab.\n", - "!curl -X POST -d \"https://s3.amazonaws.com/iguazio-sample-data/images/catanddog/cat.123.jpg\" " - ] - } - ], - "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.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/demos/gpu/horovod/image-classification/horovod_train_cats_n_dogs.py b/demos/gpu/horovod/image-classification/horovod_train_cats_n_dogs.py deleted file mode 100644 index e2b3ea2c..00000000 --- a/demos/gpu/horovod/image-classification/horovod_train_cats_n_dogs.py +++ /dev/null @@ -1,178 +0,0 @@ -from __future__ import print_function -import os -import sys -import json -import keras -from keras.datasets import mnist -from keras.models import Sequential -from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, Activation, BatchNormalization -from keras.preprocessing.image import ImageDataGenerator -from keras import backend as K -import tensorflow as tf -import horovod.keras as hvd -import pandas as pd -from sklearn.model_selection import train_test_split - -# Get the images path -DATA_PATH = sys.argv[1] -HOROVOD_DIR = sys.argv[2] - -epochs = 6 -batch_size = 64 - -# Define image parameters -IMAGE_WIDTH=128 -IMAGE_HEIGHT=128 -IMAGE_SIZE=(IMAGE_WIDTH, IMAGE_HEIGHT) -IMAGE_CHANNELS=3 # RGB color - -# Create a file-names list (JPG image-files only) -filenames = [file for file in os.listdir(DATA_PATH + "/cats_n_dogs/") if file.endswith('jpg')] -categories = [] - -# Create a categories and prediction classes map -categories_map = { - 'dog': 1, - 'cat': 0, -} - -# Create a pandas DataFrame for the full sample -for filename in filenames: - category = filename.split('.')[0] - categories.append([categories_map[category]]) - -df = pd.DataFrame({ - 'filename': filenames, - 'category': categories -}) -df['category'] = df['category'].astype('str'); - -# Prepare, test, and train the data -train_df, validate_df = train_test_split(df, test_size=0.20, random_state=42) -train_df = train_df.reset_index(drop=True) -validate_df = validate_df.reset_index(drop=True) -train_df['category'] = train_df['category'].astype('str'); -total_train = train_df.shape[0] -total_validate = validate_df.shape[0] - -total_train = train_df.shape[0] -total_validate = validate_df.shape[0] - -# Horovod: initialize Horovod. -hvd.init() - -# Horovod: pin GPU to be used to process local rank (one GPU per process). -config = tf.ConfigProto() -config.gpu_options.allow_growth = True -config.gpu_options.visible_device_list = str(hvd.local_rank()) -K.set_session(tf.Session(config=config)) - - -model = Sequential() - -model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS))) -model.add(BatchNormalization()) -model.add(MaxPooling2D(pool_size=(2, 2))) -model.add(Dropout(0.25)) - -model.add(Conv2D(64, (3, 3), activation='relu')) -model.add(BatchNormalization()) -model.add(MaxPooling2D(pool_size=(2, 2))) -model.add(Dropout(0.25)) - -model.add(Conv2D(128, (3, 3), activation='relu')) -model.add(BatchNormalization()) -model.add(MaxPooling2D(pool_size=(2, 2))) -model.add(Dropout(0.25)) - -model.add(Flatten()) -model.add(Dense(512, activation='relu')) -model.add(BatchNormalization()) -model.add(Dropout(0.5)) -model.add(Dense(1, activation='sigmoid')) - - -# Horovod: adjust learning rate based on number of GPUs. -opt = keras.optimizers.Adadelta(lr=1.0 * hvd.size()) - -# Horovod: add Horovod Distributed Optimizer. -opt = hvd.DistributedOptimizer(opt) - -model.compile(loss='binary_crossentropy', - optimizer=opt, - metrics=['accuracy']) - -model.summary() - -callbacks = [ - # Horovod: broadcast initial variable states from rank 0 to all other processes. - # This is necessary to ensure consistent initialization of all workers when - # training is started with random weights or restored from a checkpoint. - hvd.callbacks.BroadcastGlobalVariablesCallback(0), - - # Horovod: average metrics among workers at the end of every epoch. - # Note: This callback must be in the list before the ReduceLROnPlateau, - # TensorBoard or other metrics-based callbacks. - hvd.callbacks.MetricAverageCallback(), - - # Horovod: using `lr = 1.0 * hvd.size()` from the very beginning leads to worse final - # accuracy. Scale the learning rate `lr = 1.0` ---> `lr = 1.0 * hvd.size()` during - # the first five epochs. See https://arxiv.org/abs/1706.02677 for details. - hvd.callbacks.LearningRateWarmupCallback(warmup_epochs=5, verbose=1), - - # Reduce the learning rate if training plateaues. - keras.callbacks.ReduceLROnPlateau(patience=10, verbose=1), -] - -# Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them. -if hvd.rank() == 0: - callbacks.append(keras.callbacks.ModelCheckpoint(HOROVOD_DIR + '/checkpoints/checkpoint-{epoch}.h5')) - -# Set up ImageDataGenerators to do data augmentation for the training images. -train_datagen = ImageDataGenerator( - rotation_range=15, - rescale=1./255, - shear_range=0.1, - zoom_range=0.2, - horizontal_flip=True, - width_shift_range=0.1, - height_shift_range=0.1 -) -train_generator = train_datagen.flow_from_dataframe( - train_df, - DATA_PATH + "/cats_n_dogs/", - x_col = 'filename', - y_col = 'category', - target_size = IMAGE_SIZE, - class_mode = 'binary', - batch_size = batch_size -) - -validation_datagen = ImageDataGenerator(rescale=1./255) -validation_generator = validation_datagen.flow_from_dataframe( - validate_df, - DATA_PATH + "/cats_n_dogs/", - x_col = 'filename', - y_col = 'category', - target_size = IMAGE_SIZE, - class_mode = 'binary', - batch_size = batch_size -) - -# Train the model -history = model.fit_generator( - train_generator, - steps_per_epoch=total_train // batch_size, - callbacks=callbacks, - epochs=epochs, - verbose=1, - validation_data=validation_generator, - validation_steps=total_validate // batch_size -) - -#save the model only on worker 0 to prevent failures ("cannot lock file") -if hvd.rank() == 0: - model.save(HOROVOD_DIR + '/cats_dogs.hd5') - -print(pd.DataFrame(history.history)) -