From b4974eed163bd4d487ae4eb51567f690379a57fc Mon Sep 17 00:00:00 2001 From: Raghu Date: Sat, 8 Feb 2025 02:45:10 +0100 Subject: [PATCH] Tensorflow TRT Colab fix Signed-off-by: Raghu --- .../Google_colab_Tensorflow_TRT.ipynb | 1968 +++++++++++++++++ TensorFlow/TensorFlowTensorRT/README.md.txt | 45 + 2 files changed, 2013 insertions(+) create mode 100644 TensorFlow/TensorFlowTensorRT/Google_colab_Tensorflow_TRT.ipynb create mode 100644 TensorFlow/TensorFlowTensorRT/README.md.txt diff --git a/TensorFlow/TensorFlowTensorRT/Google_colab_Tensorflow_TRT.ipynb b/TensorFlow/TensorFlowTensorRT/Google_colab_Tensorflow_TRT.ipynb new file mode 100644 index 000000000..d4302472b --- /dev/null +++ b/TensorFlow/TensorFlowTensorRT/Google_colab_Tensorflow_TRT.ipynb @@ -0,0 +1,1968 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YXmsSXM0LoIo", + "outputId": "462a58a1-889c-43a8-e50c-e09dce32952c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Tue Feb 4 13:31:15 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", + "|-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 71C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install pillow matplotlib" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8z_SmgFyLsSG", + "outputId": "1c23176d-ff04-45c2-b457-70ea64f34016" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: pillow in /usr/local/lib/python3.11/dist-packages (11.1.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.55.7)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n", + "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.26.4)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (24.2)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "#!pip uninstall tensorflow\n", + "#!pip install tensorflow==2.17.0" + ], + "metadata": { + "id": "90X3o5YJLuIL" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "print(\"Tensorflow version: \", tf.version.VERSION)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t0SWjJHdLv31", + "outputId": "b6bbdf2f-6a96-4e75-cad4-f5addf7a4250" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Tensorflow version: 2.17.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!apt-cache search libnvinfer" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tYNiN0FYJGzz", + "outputId": "f30b58b6-5de5-46eb-d255-72e8b0376d6d" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "libnvinfer8 - TensorRT runtime libraries\n", + "libnvinfer-bin - TensorRT binaries\n", + "libnvinfer-plugin8 - TensorRT plugin libraries\n", + "libnvinfer-plugin-dev - TensorRT plugin libraries\n", + "libnvinfer-samples - TensorRT samples\n", + "libnvinfer-dev - TensorRT development libraries\n", + "libnvinfer-dispatch8 - TensorRT dispatch runtime library\n", + "libnvinfer-dispatch-dev - TensorRT development dispatch runtime libraries\n", + "libnvinfer-headers-dev - TensorRT development headers\n", + "libnvinfer-headers-plugin-dev - TensorRT plugin headers\n", + "libnvinfer-lean8 - TensorRT lean runtime library\n", + "libnvinfer-lean-dev - TensorRT lean runtime libraries\n", + "libnvinfer-vc-plugin8 - TensorRT vc-plugin library\n", + "libnvinfer-vc-plugin-dev - TensorRT vc-plugin library\n", + "python3-libnvinfer - Python 3 bindings for TensorRT standard runtime\n", + "python3-libnvinfer-dev - Python 3 development package for TensorRT standard runtime\n", + "python3-libnvinfer-dispatch - Python 3 bindings for TensorRT dispatch runtime\n", + "python3-libnvinfer-lean - Python 3 bindings for TensorRT lean runtime\n", + "libnvinfer10 - TensorRT runtime libraries\n", + "libnvinfer-dispatch10 - TensorRT dispatch runtime library\n", + "libnvinfer-lean10 - TensorRT lean runtime library\n", + "libnvinfer-plugin10 - TensorRT plugin libraries\n", + "libnvinfer-vc-plugin10 - TensorRT vc-plugin library\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!sudo apt-get update\n", + "!sudo apt-get install -y libnvinfer8 libnvinfer-plugin8" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5sSDYXlML1UN", + "outputId": "2f03c819-bdbd-4ef0-c685-e5d60359dafc" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\r0% [Working]\r \rHit:1 https://cloud.r-project.org/bin/linux/ubuntu jammy-cran40/ InRelease\n", + "Hit:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 InRelease\n", + "Hit:3 http://security.ubuntu.com/ubuntu jammy-security InRelease\n", + "Hit:4 http://archive.ubuntu.com/ubuntu jammy InRelease\n", + "Hit:5 https://r2u.stat.illinois.edu/ubuntu jammy InRelease\n", + "Hit:6 http://archive.ubuntu.com/ubuntu jammy-updates InRelease\n", + "Hit:7 http://archive.ubuntu.com/ubuntu jammy-backports InRelease\n", + "Hit:8 https://ppa.launchpadcontent.net/deadsnakes/ppa/ubuntu jammy InRelease\n", + "Hit:9 https://ppa.launchpadcontent.net/graphics-drivers/ppa/ubuntu jammy InRelease\n", + "Hit:10 https://ppa.launchpadcontent.net/ubuntugis/ppa/ubuntu jammy InRelease\n", + "Reading package lists... Done\n", + "W: Skipping acquire of configured file 'main/source/Sources' as repository 'https://r2u.stat.illinois.edu/ubuntu jammy InRelease' does not seem to provide it (sources.list entry misspelt?)\n", + "Reading package lists... Done\n", + "Building dependency tree... Done\n", + "Reading state information... Done\n", + "libnvinfer8 is already the newest version (8.6.1.6-1+cuda12.0).\n", + "libnvinfer-plugin8 is already the newest version (8.6.1.6-1+cuda12.0).\n", + "0 upgraded, 0 newly installed, 0 to remove and 20 not upgraded.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!dpkg -l | grep nvinfer" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ocS3qpmAFvH_", + "outputId": "b750257e-e0be-4d97-b70d-97244c1cd464" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "ii libnvinfer-plugin8 8.6.1.6-1+cuda12.0 amd64 TensorRT plugin libraries\n", + "ii libnvinfer8 8.6.1.6-1+cuda12.0 amd64 TensorRT runtime libraries\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.python.client import device_lib\n", + "\n", + "def check_tensor_core_gpu_present():\n", + " local_device_protos = device_lib.list_local_devices()\n", + " for line in local_device_protos:\n", + " if \"compute capability\" in str(line):\n", + " compute_capability = float(line.physical_device_desc.split(\"compute capability: \")[-1])\n", + " if compute_capability>=7.0:\n", + " return True\n", + "\n", + "print(\"Tensor Core GPU Present:\", check_tensor_core_gpu_present())\n", + "tensor_core_gpu = check_tensor_core_gpu_present()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AxHJGo6NL3B4", + "outputId": "ae3c6b78-c6f1-46d4-aef8-b32549108abd" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Tensor Core GPU Present: True\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from __future__ import absolute_import, division, print_function, unicode_literals\n", + "import os\n", + "import time\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.python.compiler.tensorrt import trt_convert as trt\n", + "from tensorflow.python.saved_model import tag_constants\n", + "from tensorflow.keras.applications.resnet50 import ResNet50\n", + "from tensorflow.keras.preprocessing import image\n", + "from tensorflow.keras.applications.resnet50 import preprocess_input, decode_predictions" + ], + "metadata": { + "id": "k6na5IlaL7TB" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!mkdir ./data\n", + "!wget -O ./data/img0.JPG \"https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\"\n", + "!wget -O ./data/img1.JPG \"https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\"\n", + "#!wget -O ./data/img2.JPG \"https://www.artis.nl/media/filer_public_thumbnails/filer_public/00/f1/00f1b6db-fbed-4fef-9ab0-84e944ff11f8/chimpansee_amber_r_1920x1080.jpg__1920x1080_q85_subject_location-923%2C365_subsampling-2.jpg\"\n", + "!wget -O ./data/img2.JPG \"https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\"" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RGBi1RgeL9n8", + "outputId": "dcffe139-48ee-49f5-8f28-4108abafe5b6" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "mkdir: cannot create directory ‘./data’: File exists\n", + "--2025-02-04 13:31:49-- https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\n", + "Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 3.163.128.12, 3.163.128.2, 3.163.128.5, ...\n", + "Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|3.163.128.12|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 24112 (24K) [image/jpeg]\n", + "Saving to: ‘./data/img0.JPG’\n", + "\n", + "./data/img0.JPG 100%[===================>] 23.55K --.-KB/s in 0.001s \n", + "\n", + "2025-02-04 13:31:49 (20.0 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]\n", + "\n", + "--2025-02-04 13:31:49-- https://www.hakaimagazine.com/wp-content/uploads/header-gulf-birds.jpg\n", + "Resolving www.hakaimagazine.com (www.hakaimagazine.com)... 164.92.73.117\n", + "Connecting to www.hakaimagazine.com (www.hakaimagazine.com)|164.92.73.117|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 452718 (442K) [image/jpeg]\n", + "Saving to: ‘./data/img1.JPG’\n", + "\n", + "./data/img1.JPG 100%[===================>] 442.11K --.-KB/s in 0.07s \n", + "\n", + "2025-02-04 13:31:49 (6.38 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]\n", + "\n", + "--2025-02-04 13:31:50-- https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\n", + "Resolving www.familyhandyman.com (www.familyhandyman.com)... 104.19.144.18, 104.19.255.17, 2606:4700::6813:ff11, ...\n", + "Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.19.144.18|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 85986 (84K) [image/jpeg]\n", + "Saving to: ‘./data/img2.JPG’\n", + "\n", + "./data/img2.JPG 100%[===================>] 83.97K --.-KB/s in 0.03s \n", + "\n", + "2025-02-04 13:31:50 (2.81 MB/s) - ‘./data/img2.JPG’ saved [85986/85986]\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.keras.preprocessing import image\n", + "\n", + "fig, axes = plt.subplots(nrows=2, ncols=2)\n", + "\n", + "for i in range(3):\n", + " img_path = './data/img%d.JPG'%i\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " plt.subplot(2,2,i+1)\n", + " plt.imshow(img);\n", + " plt.axis('off');" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "_HaRWHDKL_cv", + "outputId": "ff5de3e0-6762-4355-8220-64870c4dedf3" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "model = ResNet50(weights='imagenet')" + ], + "metadata": { + "id": "kfRg4qleMBd5" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "for i in range(3):\n", + " img_path = './data/img%d.JPG'%i\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " x = image.img_to_array(img)\n", + " x = np.expand_dims(x, axis=0)\n", + " x = preprocess_input(x)\n", + "\n", + " preds = model.predict(x)\n", + " # decode the results into a list of tuples (class, description, probability)\n", + " # (one such list for each sample in the batch)\n", + " print('{} - Predicted: {}'.format(img_path, decode_predictions(preds, top=3)[0]))\n", + "\n", + " plt.subplot(2,2,i+1)\n", + " plt.imshow(img);\n", + " plt.axis('off');\n", + " plt.title(decode_predictions(preds, top=3)[0][0][1])\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 538 + }, + "id": "IMMbhqzHMDt0", + "outputId": "a0cbc834-b2ea-4983-bb8f-b6b5eebf37b8" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 5s/step\n", + "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.5568134), ('n02109961', 'Eskimo_dog', 0.41662613), ('n02110063', 'malamute', 0.021314166)]\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 39ms/step\n", + "./data/img1.JPG - Predicted: [('n01820546', 'lorikeet', 0.30117285), ('n01537544', 'indigo_bunting', 0.16982141), ('n01828970', 'bee_eater', 0.16135603)]\n", + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 38ms/step\n", + "./data/img2.JPG - Predicted: [('n01729977', 'green_snake', 0.41348848), ('n03627232', 'knot', 0.10407336), ('n01749939', 'green_mamba', 0.06852533)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Save the entire model as a SavedModel.\n", + "model.export('resnet50_saved_model')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XtZE3mE7MFfJ", + "outputId": "0b9d6412-7f11-4ecd-f542-3511c0e975a2" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saved artifact at 'resnet50_saved_model'. The following endpoints are available:\n", + "\n", + "* Endpoint 'serve'\n", + " args_0 (POSITIONAL_ONLY): TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='keras_tensor')\n", + "Output Type:\n", + " TensorSpec(shape=(None, 1000), dtype=tf.float32, name=None)\n", + "Captures:\n", + " 136262133787408: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258444079568: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443821328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443822288: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133790672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133786064: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443824976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443826512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443827472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443825168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443827280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443825744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443826704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443829776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443829968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443829200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443826896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443829584: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443831504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443832080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133786256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258444083024: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443823248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443821712: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443821520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443822864: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443832656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443830736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443832464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443828624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443834192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443834768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443834960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443833808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443830352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443834576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443836496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443837072: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443835728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443835344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443832272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258443836112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442035664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442037200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442037392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442036624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442035856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442037008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442036240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442039696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442039888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442039120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442035472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442039504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442037776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442042192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442042384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442041616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442038928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442042000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442043920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442044496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442044688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442043536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442040272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442044304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442048528: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442049104: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442049296: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442048144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442042768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442048912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442050832: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442051216: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442050064: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442428880: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442049680: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442051408: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442430032: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442430608: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442046224: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442046800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442046992: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442045840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442041040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442046608: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442430800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442428688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442429264: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442430416: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442432336: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442432912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442433104: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442431952: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442429648: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442432720: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442434640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442435216: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442435408: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442434256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442429456: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442435024: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442436944: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442437520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442436560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442438672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442431184: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442437328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442433488: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442439824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442440016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442439440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442438864: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442439632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442441552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442442128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442442320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442441168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442438288: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442441936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442443856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442444432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442443088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442442704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442439056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442443472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442789328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442790864: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442791056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442790288: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442789520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442790672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442792592: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442793168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442793360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442792208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442789904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442792976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442794896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442795472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442795664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442794512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442790096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442795280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442799504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442800080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442800272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442799120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442793744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442799888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442801808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442802384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442802576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442801424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442796048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442802192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442804112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442804688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442797200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442797776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442797968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442796816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442791440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442797584: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442802960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442800656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442798352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258442803728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373403472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373404432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373404624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373402704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373403856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373404240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373406160: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373406736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373406928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373405776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373403088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373406544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373408464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373409040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373409232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373408080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373402896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373408848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373410768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373411344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373411536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373410384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373405008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373411152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373413072: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373413648: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373413840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373412688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373407312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373413456: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373415376: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373415952: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373416144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373414992: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373409616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373415760: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373417680: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373418256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373418832: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373416912: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373411920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373418064: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373414224: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373813840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373814032: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373813264: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373812496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373813648: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373815568: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373816144: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373816336: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373815184: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373812880: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373815952: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373817872: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373818448: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373818640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373817488: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373812304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373818256: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373820176: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373820752: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373820944: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373819792: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373814416: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373820560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373822480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373823056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373823248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373822096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373816720: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373822864: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373824784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373825360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373825552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373824400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373819024: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373825168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373827088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373827664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373828240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373823632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373821328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373827472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258373826320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374157712: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374156368: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374157136: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374156560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374157520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374161744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374162320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374162512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374161360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374157904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374162128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374164048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374164624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374164816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374163664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374158288: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374164432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374166352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374166928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374159440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374160016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374160208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374159056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374156752: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374159824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374167120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374165968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374160592: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374166736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374168656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374169232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374169424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374168272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374162896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374169040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374170960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374171536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374171728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374172496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374165200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374171344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374169808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258374167504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314782096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314781136: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314781904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314780944: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314783632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314784208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314784400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314783248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314781328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314784016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314785936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314786512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314786704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314785552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314781712: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314786320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314788240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314788816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314789008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314787856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314782480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314788624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314790544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314791120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!saved_model_cli show --all --dir resnet50_saved_model" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4KYPCCXoMHlB", + "outputId": "96873161-5fbc-43eb-8866-85a4c58c5a63" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2025-02-04 13:32:11.550958: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-02-04 13:32:11.568904: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-02-04 13:32:11.574397: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1738675934.966948 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675934.976920 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675934.977140 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "\n", + "MetaGraphDef with tag-set: 'serve' contains the following SignatureDefs:\n", + "\n", + "signature_def['__saved_model_init_op']:\n", + " The given SavedModel SignatureDef contains the following input(s):\n", + " The given SavedModel SignatureDef contains the following output(s):\n", + " outputs['__saved_model_init_op'] tensor_info:\n", + " dtype: DT_INVALID\n", + " shape: unknown_rank\n", + " name: NoOp\n", + " Method name is: \n", + "\n", + "signature_def['serve']:\n", + " The given SavedModel SignatureDef contains the following input(s):\n", + " inputs['keras_tensor'] tensor_info:\n", + " dtype: DT_FLOAT\n", + " shape: (-1, 224, 224, 3)\n", + " name: serve_keras_tensor:0\n", + " The given SavedModel SignatureDef contains the following output(s):\n", + " outputs['output_0'] tensor_info:\n", + " dtype: DT_FLOAT\n", + " shape: (-1, 1000)\n", + " name: StatefulPartitionedCall:0\n", + " Method name is: tensorflow/serving/predict\n", + "\n", + "signature_def['serving_default']:\n", + " The given SavedModel SignatureDef contains the following input(s):\n", + " inputs['keras_tensor'] tensor_info:\n", + " dtype: DT_FLOAT\n", + " shape: (-1, 224, 224, 3)\n", + " name: serving_default_keras_tensor:0\n", + " The given SavedModel SignatureDef contains the following output(s):\n", + " outputs['output_0'] tensor_info:\n", + " dtype: DT_FLOAT\n", + " shape: (-1, 1000)\n", + " name: StatefulPartitionedCall_1:0\n", + " Method name is: tensorflow/serving/predict\n", + "The MetaGraph with tag set ['serve'] contains the following ops: {'Const', 'Pack', 'VarHandleOp', 'ReadVariableOp', 'Conv2D', 'Sub', 'AssignVariableOp', 'ShardedFilename', 'Squeeze', 'Mean', 'AddV2', 'RestoreV2', 'Relu', 'DisableCopyOnRead', 'Identity', 'MatMul', 'Softmax', 'BiasAdd', 'Mul', 'StaticRegexFullMatch', 'NoOp', 'Reshape', 'MergeV2Checkpoints', 'Placeholder', 'SaveV2', 'StatefulPartitionedCall', 'VarIsInitializedOp', 'MaxPool', 'Pad', 'Select', 'StringJoin', 'Rsqrt'}\n", + "\n", + "Concrete Functions:I0000 00:00:1738675935.414723 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675935.415040 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675935.415202 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675935.496493 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675935.496768 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-02-04 13:32:15.496923: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:47] Overriding orig_value setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n", + "I0000 00:00:1738675935.497000 13337 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "\n", + " Function Name: 'serve'\n", + " Option #1\n", + " Callable with:\n", + " Argument #1\n", + " keras_tensor: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='keras_tensor')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "model = tf.saved_model.load('resnet50_saved_model')" + ], + "metadata": { + "id": "yFpe_FSoMKiX" + }, + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "infer = model.signatures['serving_default']\n", + "print(infer)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6uCsU048PadX", + "outputId": "423ffd31-e286-4134-ecd9-96c9328ef73f" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "ConcreteFunction Input Parameters:\n", + " keras_tensor (KEYWORD_ONLY): TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='keras_tensor')\n", + "Output Type:\n", + " Dict[['output_0', TensorSpec(shape=(None, 1000), dtype=tf.float32, name='output_0')]]\n", + "Captures:\n", + " 136256819922704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819922512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819921936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819921744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819922320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819922128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819921552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819921360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819855184: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819854992: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819921168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819920976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819854800: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819854608: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819854032: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819853840: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819854416: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819854224: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819853264: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819853072: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819853648: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819853456: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819852496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819852304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819852880: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819852688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819851728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819851536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819852112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819851920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819851344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819851152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819850576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819850384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819850960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819850768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819850192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819850000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819849424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819849232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819849808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819849616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819849040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819848848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819848272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819848080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819848656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819848464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819847888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819847696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819847120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819846928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819847504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819847312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819846736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819846544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819845968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819845776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819846352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819846160: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819845584: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819845392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819844816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819844624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819845200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819845008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819844432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819844240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819843664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819843472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819844048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819843856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819843280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819843088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819842512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819842320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819842896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819842704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819841744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819841552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819842128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819841936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819840976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819840784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819841360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819841168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819840208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819840016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819840592: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819840400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819839824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819839632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819839056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819773264: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819839440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819839248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819773072: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819772880: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819772304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819772112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819772688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819772496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819771920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819771728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819771152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819770960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819771536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819771344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819770768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819770576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819770000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819769808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819770384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819770192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819769616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819769424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819768848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819768656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819769232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819769040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819768464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819768272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819767696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819767504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819768080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819767888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819767312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819767120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819766544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819766352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819766928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819766736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819766160: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819765968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819765392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819765200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819765776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819765584: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819765008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819764816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819764240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819764048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819764624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819764432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819763856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819763664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819763088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819762896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819763472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819763280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819762704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819762512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819761936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819761744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819762320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819762128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819761168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819760976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819761552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819761360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819760400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819760208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819760784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819760592: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819759632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819759440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819760016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819759824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819759248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819759056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819758480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819758288: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819758864: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819758672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819758096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819757904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819757328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819757136: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819757712: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819757520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819707728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819707536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819706960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819706768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819707344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819707152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819706576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819706384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819705808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819705616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819706192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819706000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819705424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819705232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819704656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819704464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819705040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819704848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819704272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819704080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819703504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819703312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819703888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819703696: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819703120: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819702928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819702352: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819702160: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819702736: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819702544: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819701968: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819701776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819701200: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819701008: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819701584: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819701392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819700816: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819700624: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819700048: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819699856: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819700432: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819700240: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819699664: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819699472: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819698896: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819698704: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819699280: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819699088: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819698512: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819698320: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819697744: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819697552: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819698128: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819697936: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819697360: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819697168: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819696592: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819696400: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819696976: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819696784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819696208: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819696016: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819695440: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819695248: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819695824: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819695632: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819695056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819694864: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819694288: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819694096: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819694672: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819694480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819693904: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819693712: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819693136: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819692944: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819693520: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819693328: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819692752: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819692560: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819691984: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819691792: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819692368: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819692176: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136256819691600: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133791056: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133781456: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133781264: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133790480: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136262133786640: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513833424: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513832080: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513832656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513834000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513833616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513832848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513833040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513833808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513835152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513834960: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513833232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513835344: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513834768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513834576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513836688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513836496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513834384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513834192: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513836304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513836112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513835536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314791888: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513835920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258513835728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314792848: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314793040: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314793616: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314793808: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314793232: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314794000: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314795152: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314792656: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314795728: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314795920: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314789392: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314789776: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314796112: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314795536: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314791312: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314792272: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314790928: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314791504: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314792464: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314794576: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314794768: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314796688: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314796304: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314784784: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314794384: TensorSpec(shape=(), dtype=tf.resource, name=None)\n", + " 136258314796496: TensorSpec(shape=(), dtype=tf.resource, name=None)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "batch_size = 8\n", + "batched_input = np.zeros((batch_size, 224, 224, 3), dtype=np.float32)\n", + "\n", + "for i in range(batch_size):\n", + " img_path = './data/img%d.JPG' % (i % 3)\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " x = image.img_to_array(img)\n", + " x = np.expand_dims(x, axis=0)\n", + " x = preprocess_input(x)\n", + " batched_input[i, :] = x\n", + "batched_input = tf.constant(batched_input)\n", + "print('batched_input shape: ', batched_input.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "y9ogK96aMMI5", + "outputId": "fd4af66d-bca9-4fb4-b282-f08295af6df6" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "batched_input shape: (8, 224, 224, 3)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Benchmarking throughput\n", + "N_warmup_run = 50\n", + "N_run = 1000\n", + "elapsed_time = []\n", + "\n", + "for i in range(N_warmup_run):\n", + " preds = infer(batched_input)\n", + "\n", + "for i in range(N_run):\n", + " start_time = time.time()\n", + " preds = infer(batched_input)\n", + " end_time = time.time()\n", + " elapsed_time = np.append(elapsed_time, end_time - start_time)\n", + " if i % 50 == 0:\n", + " print('Step {}: {:4.1f}ms'.format(i, (elapsed_time[-50:].mean()) * 1000))\n", + "\n", + "print('Throughput: {:.0f} images/s'.format(N_run * batch_size / elapsed_time.sum()))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "N4CQtwVFMNiB", + "outputId": "3a0d87eb-73bf-4ffa-e2f2-c962ce079620" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Step 0: 32.6ms\n", + "Step 50: 33.5ms\n", + "Step 100: 33.5ms\n", + "Step 150: 33.6ms\n", + "Step 200: 33.6ms\n", + "Step 250: 33.8ms\n", + "Step 300: 33.9ms\n", + "Step 350: 34.0ms\n", + "Step 400: 34.1ms\n", + "Step 450: 34.2ms\n", + "Step 500: 34.3ms\n", + "Step 550: 34.4ms\n", + "Step 600: 34.5ms\n", + "Step 650: 34.6ms\n", + "Step 700: 34.7ms\n", + "Step 750: 34.8ms\n", + "Step 800: 35.0ms\n", + "Step 850: 35.0ms\n", + "Step 900: 35.1ms\n", + "Step 950: 45.6ms\n", + "Throughput: 230 images/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#TF-TRT FP32 model" + ], + "metadata": { + "id": "5bm8Pd4vQYNm" + } + }, + { + "cell_type": "code", + "source": [ + "print('Converting to TF-TRT FP32...')\n", + "\n", + "converter = trt.TrtGraphConverterV2(input_saved_model_dir='resnet50_saved_model',\n", + " precision_mode=trt.TrtPrecisionMode.FP32,\n", + " max_workspace_size_bytes=8000000000)\n", + "converter.convert()\n", + "converter.save(output_saved_model_dir='resnet50_saved_model_TFTRT_FP32')\n", + "print('Done Converting to TF-TRT FP32')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6iwbgHQoQJTr", + "outputId": "f07c3cf9-3f79-4217-9b03-6ca2ed2da71c" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Converting to TF-TRT FP32...\n", + "Done Converting to TF-TRT FP32\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!saved_model_cli show --all --dir resnet50_saved_model_TFTRT_FP32" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rSimJ1EmQitb", + "outputId": "ef355c25-e1f5-4227-d7df-8a1b33a3a69f" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2025-02-04 13:33:12.553029: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-02-04 13:33:12.570988: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "2025-02-04 13:33:12.576333: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1738675995.982303 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675995.992746 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675995.992988 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "\n", + "MetaGraphDef with tag-set: 'serve' contains the following SignatureDefs:\n", + "\n", + "signature_def['__saved_model_init_op']:\n", + " The given SavedModel SignatureDef contains the following input(s):\n", + " The given SavedModel SignatureDef contains the following output(s):\n", + " outputs['__saved_model_init_op'] tensor_info:\n", + " dtype: DT_INVALID\n", + " shape: unknown_rank\n", + " name: NoOp\n", + " Method name is: \n", + "\n", + "signature_def['serving_default']:\n", + " The given SavedModel SignatureDef contains the following input(s):\n", + " inputs['keras_tensor'] tensor_info:\n", + " dtype: DT_FLOAT\n", + " shape: (-1, 224, 224, 3)\n", + " name: serving_default_keras_tensor:0\n", + " The given SavedModel SignatureDef contains the following output(s):\n", + " outputs['output_0'] tensor_info:\n", + " dtype: DT_FLOAT\n", + " shape: (-1, 1000)\n", + " name: PartitionedCall:0\n", + " Method name is: tensorflow/serving/predict\n", + "The MetaGraph with tag set ['serve'] contains the following ops: {'Const', 'NoOp', 'RestoreV2', 'PartitionedCall', 'ShardedFilename', 'StatefulPartitionedCall', 'Pack', 'MergeV2Checkpoints', 'StringJoin', 'StaticRegexFullMatch', 'SaveV2', 'Placeholder', 'Select', 'Identity', 'TRTEngineOp'}\n", + "\n", + "Concrete Functions:I0000 00:00:1738675996.603641 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675996.603948 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675996.604111 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675996.681363 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "I0000 00:00:1738675996.681653 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2025-02-04 13:33:16.681819: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:47] Overriding orig_value setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n", + "I0000 00:00:1738675996.681908 13642 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def predict_tftrt(input_saved_model):\n", + " \"\"\"Runs prediction on a single image and shows the result.\n", + " input_saved_model (string): Name of the input model stored in the current dir\n", + " \"\"\"\n", + " img_path = './data/img0.JPG' # Siberian_husky\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " x = image.img_to_array(img)\n", + " x = np.expand_dims(x, axis=0)\n", + " x = preprocess_input(x)\n", + " x = tf.constant(x)\n", + "\n", + " saved_model_loaded = tf.saved_model.load(input_saved_model, tags=[tag_constants.SERVING])\n", + " signature_keys = list(saved_model_loaded.signatures.keys())\n", + " print(signature_keys)\n", + "\n", + " infer = saved_model_loaded.signatures['serving_default']\n", + " print(infer.structured_outputs)\n", + "\n", + " labeling = infer(x)\n", + " preds = labeling['output_0'].numpy()\n", + " print('{} - Predicted: {}'.format(img_path, decode_predictions(preds, top=3)[0]))\n", + " plt.subplot(2,2,1)\n", + " plt.imshow(img);\n", + " plt.axis('off');\n", + " plt.title(decode_predictions(preds, top=3)[0][0][1])" + ], + "metadata": { + "id": "EN5vyItSQmKy" + }, + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def benchmark_tftrt(input_saved_model):\n", + " saved_model_loaded = tf.saved_model.load(input_saved_model, tags=[tag_constants.SERVING])\n", + " infer = saved_model_loaded.signatures['serving_default']\n", + "\n", + " N_warmup_run = 50\n", + " N_run = 1000\n", + " elapsed_time = []\n", + "\n", + " for i in range(N_warmup_run):\n", + " labeling = infer(batched_input)\n", + "\n", + " for i in range(N_run):\n", + " start_time = time.time()\n", + " labeling = infer(batched_input)\n", + " end_time = time.time()\n", + " elapsed_time = np.append(elapsed_time, end_time - start_time)\n", + " if i % 50 == 0:\n", + " print('Step {}: {:4.1f}ms'.format(i, (elapsed_time[-50:].mean()) * 1000))\n", + "\n", + " print('Throughput: {:.0f} images/s'.format(N_run * batch_size / elapsed_time.sum()))" + ], + "metadata": { + "id": "_uv9B7xgQ43Z" + }, + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "predict_tftrt('resnet50_saved_model_TFTRT_FP32')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "9i54SKDeQ5om", + "outputId": "5155fab5-538d-4922-beac-15d59b851b10" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['serving_default']\n", + "{'output_0': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='output_0')}\n", + "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.55681354), ('n02109961', 'Eskimo_dog', 0.41662621), ('n02110063', 'malamute', 0.021314066)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALwAAADSCAYAAADwt6qBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjqhJREFUeJzs/Xe0rcld3wl/quoJO++Tb+y+HdVSSyggRBQvIIIIAzMYjAkG4QB6wWZ5rXfN8uv5g/GseT2MCcszLMbIYWYxs2xwAA/BFrKQbZkksAGhVuzct7tvPnnn/YSq94+qesI++9x7zu2gHtO/Xqfv3s9+Qj1Vv/rV9xdLGGMMr9Pr9GeE5Oe7Aa/T6/Rq0usM/zr9maLXGf51+jNFrzP86/Rnil5n+NfpzxS9zvCv058pep3hX6c/U/Q6w79Of6bodYZ/nf5M0f+jGP6+++7jB3/wB4vv/+f/+X8ihOCP//iPX5Xn/+AP/iD33Xffq/Ks4+jy5csIIfiZn/mZV/W5r3Zfv1L0mmH4T33qU3znd34nly5dotFocOHCBb7+67+en/u5n/t8N+11+i+Igs93AwA+9rGP8TVf8zXce++9/NAP/RBnz57lxRdf5A//8A/52Z/9WX7sx34MgCeeeAIpP39z9B//43+M1vrz9vzX6aXTa4Lh/6f/6X+i3+/zR3/0R6ysrNR+u3XrVvE5juNXuWWWxuMx7XabMAw/L89/nV4+ek1AmmeeeYY3v/nNR5gdYGtrq/i8iOE9TSYT3v/+97O+vk6v1+MHfuAH2N/fP3Lehz70Ib7yK7+SdrtNt9vlW77lW/jMZz5TO+cHf/AH6XQ6PPPMM3zzN38z3W6X7/u+7yt+W8TwP/MzP8OXf/mXs76+TrPZ5J3vfCe/8iu/cuTZQgj++l//6/zar/0ab3nLW4jjmDe/+c3823/7b0/QQ8vpH/2jf8SDDz5IHMe8613v4o/+6I9qv3/1V381X/3VX33kumXv8c//+T/nne98J91ul16vxxd8wRfwsz/7s7d9/v7+Pl/8xV/MxYsXeeyxx2i32/yNv/E3jpx35coVlFL8z//z/3zqd3y56TXB8JcuXeJP/uRP+PSnP31X1//1v/7X+dznPsf/8D/8D/zAD/wAv/iLv8h/89/8N1Qjn//JP/knfMu3fAudToef/Mmf5Md//Mf57Gc/y7vf/W4uX75cu1+WZbz3ve9la2uLn/mZn+E7vuM7jn32z/7sz/KOd7yD//F//B/5iZ/4CYIg4M//+T/PBz/4wSPn/t7v/R4/+qM/ynd/93fzUz/1U8xmM77jO76D3d3dU7/zL/3SL/HTP/3TvP/97+fv/J2/w+XLl/lzf+7Pkabpqe/1kY98hO/5nu9hdXWVn/zJn+Tv/t2/y1d/9Vfz+7//+8des7Ozw3ve8x5u3rzJb//2b/O2t72Nb//2b+df/It/QZ7ntXP/2T/7ZxhjCsHxeSXzGqDf+q3fMkopo5QyX/ZlX2b+5t/8m+bDH/6wSZKkdt6lS5fM+973vuL7L/zCLxjAvPOd76yd+1M/9VMGML/+679ujDFmOByalZUV80M/9EO1+924ccP0+/3a8fe9730GMH/rb/2tI+183/veZy5dulQ7NplMat+TJDFvectbzHve857accBEUWSefvrp4thjjz1mAPNzP/dzt+mdOj333HMGMOvr62Zvb684/uu//usGMP/6X//r4thXfdVXma/6qq+643v8jb/xN0yv1zNZlh37XN/Xf/RHf2SuX79u3vzmN5sHHnjAXL58uTjnwx/+sAHMhz70odq1b33rW5e24/NBrwkJ//Vf//X8wR/8Ad/2bd/GY489xk/91E/x3ve+lwsXLvAbv/Ebd7z+h3/4h2v4+kd+5EcIgoDf/M3fBKwEOzg44Hu+53vY2dkp/pRSfMmXfAkf/ehHj9zzR37kR07U9mazWXze39/n8PCQr/zKr+TjH//4kXO/7uu+jgcffLD4/ta3vpVer8ezzz57omdV6S/8hb/A6upq8f0rv/IrAe7qXisrK4zHYz7ykY/c8dwrV67wVV/1VaRpyu/8zu9w6dKl4rev+7qv4/z58/ziL/5icezTn/40n/zkJ/mLf/EvnrpdrwS9JpRWgHe961383//3/02SJDz22GP86q/+Kv/L//K/8J3f+Z184hOf4NFHHz322ocffrj2vdPpcO7cuQKqPPXUUwC85z3vWXp9r9erfQ+CgIsXL56o3f/m3/wb/s7f+Tt84hOfYD6fF8eFEEfOvffee48cW11dXapv3IkW7+WZ/27u9aM/+qP8y3/5L/mmb/omLly4wDd8wzfwXd/1XXzjN37jkXO///u/nyAI+NznPsfZs2drv0kp+b7v+z4+8IEPMJlMaLVa/OIv/iKNRoM//+f//Knb9UrQa0LCVymKIt71rnfxEz/xE3zgAx8gTVN++Zd/+SXd05sS/8k/+Sd85CMfOfL367/+67Xz4zg+kfnzd3/3d/m2b/s2Go0GP//zP89v/uZv8pGPfITv/d7vrekPnpRSS++z7Nw70UnutWzSAUcw9tbWFp/4xCf4jd/4Db7t276Nj370o3zTN30T73vf+45c++f+3J/j4ODgWIX2B37gBxiNRvzar/0axhh+6Zd+if/qv/qv6Pf7J321V5ReMxJ+GX3RF30RANevX7/teU899RRf8zVfU3wfjUZcv36db/7mbwYoYMTW1hZf93Vf97K171/9q39Fo9Hgwx/+cM1k+gu/8Asv2zNeCq2uri6FOM8///yRY1EU8a3f+q1867d+K1prfvRHf5R/+A//IT/+4z/OQw89VJz3Yz/2Yzz00EP89//9f0+/3+dv/a2/VbvPW97yFt7xjnfwi7/4i1y8eJEXXnjhNeU8fE1I+I9+9KNLpZzH4I888shtr/9H/+gf1awTH/jAB8iyjG/6pm8C4L3vfS+9Xo+f+ImfWGrF2N7evqt2K6UQQtQk5uXLl/m1X/u1u7rfy00PPvggjz/+eO39HnvssSPWl0UrkZSSt771rQA1mObpx3/8x/lv/9v/lv/uv/vv+MAHPnDk9+///u/nt37rt/hf/9f/lfX19WIcXgv0mpDwP/ZjP8ZkMuHbv/3beeMb30iSJHzsYx/jX/yLf8F9993HX/pLf+m21ydJwtd+7dfyXd/1XTzxxBP8/M//PO9+97v5tm/7NsBi9A984AN8//d/P1/4hV/Id3/3d7O5uckLL7zABz/4Qb7iK76C/+1/+99O3e5v+ZZv4e/9vb/HN37jN/K93/u93Lp1i7//9/8+Dz30EJ/85Cfvqi9eTvrLf/kv8/f+3t/jve99L3/lr/wVbt26xT/4B/+AN7/5zQwGg+K8v/pX/yp7e3u85z3v4eLFizz//PP83M/9HG9/+9t505vetPTeP/3TP83h4SF/7a/9Nbrdbk0p/d7v/V7+5t/8m/zqr/4qP/IjP/Lacth9Xm1Ejj70oQ+Zv/yX/7J54xvfaDqdjomiyDz00EPmx37sx8zNmzeL844zS/72b/+2+eEf/mGzurpqOp2O+b7v+z6zu7t75Dkf/ehHzXvf+17T7/dNo9EwDz74oPnBH/xB88d//MfFOe973/tMu91e2s5lZsn/4//4P8zDDz9s4jg2b3zjG80v/MIvmL/9t/+2WexawPy1v/bXjtxz8Z3uRN4s+dM//dNHfgPM3/7bf7t27J/+039qHnjgARNFkXn7299uPvzhDx95j1/5lV8x3/AN32C2trZMFEXm3nvvNe9///vN9evXi3OqZklPeZ6b7/me7zFBEJhf+7Vfqz33m7/5mw1gPvaxj5343V4NEsa8XpfmdXr56du//dv51Kc+xdNPP/35bkqNXhMY/nX6L4uuX7/OBz/4Qb7/+7//892UI/SawPCvkzUV3kl57nQ6dDqdV6lFp6fnnnuO3//93+d//9//d8Iw5P3vf//nu0lH6fONqV4nSx6b3+5vEZ+/1sjj/Hvvvdf88i//8ue7OUvpdQz/GqHZbMbv/d7v3facBx54gAceeOBVatF/mfQ6w79Of6bodaX1dfozRa8z/Ov0Z4pObKX5pd/5OJPJBLBBSVprhBBFgJIQAill4WpflvtZPVcIgTGmCCkwxhz5XQgBUtS+G23QuSHNMlQY0Gh0kEphTA4YAhUQxy2iKCKKIqSUSBkQhqH7LACDVAIffyWEOdI+VQkZKI+Xf4EUSAESg3QxWrcNODMGUQGPywK7NEDlsHHHdBV1GlE/6chjFoPHnM5bvcQI/GnGGPscA0aDMf7PFO8khABh0Nqgc02WpvbfLMMYQxAEqCBAAEZr8iQlSRLmeUaWZ3hOOL7Vx71M/Zrq+CzSe9544US3PDHDCyGKCD3P3FDpkBM0apGhPWmtMcYcuZc7uXhrYwwCgZS2LUraWBYlFQaQEoIgJAxDOwhKOSZXxb2FkEihUVIgACHLx4BwDC3cu1nGKNtrEMI+Rwh3vfDX3rEHLa86+n+K4lQVRPaA/dNak+c5WZahtSZ2golco405VujdLZ2Er05CJ2Z4yziyeIDvCP+wqqT25y9rWPXa6r2r96v9LkUxIQCUVEghEVojpED4dglQShAEQfEnpXQBXuCZFQxKCqQQCGkKZq1PRiflsMws3ZwT0kq64vvCtbelhVOWMbw/pZTS4sh1rzbZtvjlgGIJMLlGZzkmy8m1IZMS6VbgNE3J8hzzMk3r2zH77Y4vo1Mx/DJJvuzhx02CxWPH3cNPFmNMISWklAXja22lRyAs4yolEVKilCAMrYRXShV/QlrYIgQoBUq474DAgDAFo3sJXx0sIUAag8DUkQFWyttV4Pb9d3dDbziO449Cl7Ktp7a7CeybiOWx+cZhHp3l6CyHXGPyHOMgn9GabJ4U8Cg3mtyjqZdAwrXrdry2FBXchk7laV2UwtVjvgHLrlls5OJgeaauQqXKDYr7KKUQSAwGRTkJPbMrJQsoo5QiCAL3e9lu6aGMmwAIC12qUMaDR/+7/Ue479r+a8QRflx8t7uhl34PcUKIdfJ2aK0RBkyuLUZ3UMZCTEt5lmEMaGEZXhfCwa6Ki8x/El6pdu4yvlmExiehU2H4Rcm92NDbSe3FewFoIxwjqYqELa/3HWpXUQ0IhHSSVSgwCmM0QhiUkIQyIEAiMQRKWEnu8bZjYLd2VN5psXUOkhnH6cbh/ELLExhjFVav7PqVXiyM6t3wXb1vBcI4fjHls44+RC8cWHyyOFbaet1k8efqmBpjQBtyrUFrdAWfF8YHrAzQmELJNrCU2f11RSsddjQ46Go4wszLBOdpmR1exliaRUl/3JJbpWIC4aV79SWs+JTCSnTjWDXPc4wBqSKUCgrdQgqJpFQ2hf/XK5s4Nijwh7E87Du+gtndC9n7uWXVFJYcp6yfWFl173ryU2v94i0VhZCo2y3KEzwtnxFLnuFON+UydTumz7PMSvXMSvcjDCkg19quBgv3WmxBMWYLElxrp69R5507MfsrBmk8afdi1QcuU1LvxPSLpkkhSsXYmj2tFK1i+fJa91xllSV/0HdmHWbdRkX0A76EaY7r1OqK8Wo6qkupWJoVXylaNBn7PwtXFvQyrclxK8Bt9A5Piwy/iBxeTiV1kU7M8J7htC7tr9UGaK0rpj9RnOslfzXpuNADMLWORUgHV6S1wACYvLhHHTpZC0yggoryAlLcwZfm7MwWGlkpb+eYf0axACyl2ynky857OclCh9vf1/il6jZtOAJJXT9Upf2xk11KjMzJc22N9zgBKCrAqKrXLHm+55XjLHnLJHr186vC8F7Kervr4kO91D8OdxVKZ5VhKjPZmxCVCtDGYIWFLi1iCwxW4P3qPYS11hyH/wql2/iJZS/X2iCkRmgLq+QJOtQzVrU9d4faPz9UFzTuf+Y2Fh7fJ1KAkpjMwjxjTKG/nxTjVSX5SZjZj1vVLH63dCpIU/M8ekSAHfwS+i7vMT8ZFm359rNEqZCo0UQqRZ7lpFlmGV4LQBbQxlpdrGUGsPZ0B2OllChnD66qbsa3yxkM0BolJN4caW9Q8eb6drnluZT4pVrqbufe3CCMQFLXAYyfjKfp5IV+NJW/40+uMA3UGM/fxb+Rv5kxoHWpPxXvyXKmNxj3GDuGQRCQ57nTqUzNqXZ8O52gcg8pxtK10zr6xBL4enRs7pZOBWm8VCjgyMI5x1lxFn933yhfVSBlgBDW7CglKGnIhQKRI4S10IBBo62UkdIpdZVnOU3SW03879qrvUKWiqnAOZJwzO6VXQelhO90rzzXmc/ULB8ls0hDYb3xv1XtK6dh/uJZd6GUVi/w/VG9RhsXTlBYRMDasOrTq+r0809TQmKktsYh35d3aEXxuylXYxUolCqNEUIKyI+5/ja4/jST4MQMX9hdC6auyA03bW9nRjraSI21cmmCIKpJWKUUWmsbMiCVhRxCOBOkBKfcVlcLL/G1sQMhVBnvs9g2KUumtKsOlVWhYj8umL2cmlWG0xUBIB1j58IQGDDCTp1FZjnOufNKYH5cez1GL7576V6Di0dNtB7GVv8t/Rmy8JCfNoRACOH8JbLQ7RY999Vzb9c3p5X4J2b4+XyOUqqy3NcfJkUdOy9Wt1o2Qwvtf+H3gulzRS5UhTmtEEdSwfwhUgUgFNoIa9sXpVRcpua5OVOYLaUwSGEK6V7CoeWQxBiHtrQpjBJaAAqEEWhhloShmuLak1J94r008gq5Z3bblpMp3NVAweo4eYb3XvDb3ad6Rz92PsapatNfNHCc1LdzUjoxw0dRVIMs2minXFqNW1VMir6Ry17Ed5KNspNoLQu7uT+3+FcIpFIoBFrnlouFjaEJAmVDCALL8EJJpAqQSiEVXqstlutCycVK91JS4UGlnVA1Q0NFURF1ZjUVrFFKSqcEu+NygVFLG8idJboQojj/VJNkoZ2FH8Fj94VzFg0NZX8JfK1dP5bV8a/+Vce9vMeCgCswZsUsuTB5rNDUBY9Ur19mNVq03p2ETszwVQuL1hopVMH4AJJ6XEOe50eCwvw9ymWwjHxcxgBSSnItEcp1oDEoacNRozC24b/OsiOVtCZK6aGPxei2Iz1Utx8UulgtBE4lgLrSuSDXzcKnUk/wETVOerr7LcPNVWxfWkgWlvDa73cj2eqDX3N0ugnt7ehVy1rVoFCOi3THBXm+PEaqan07YkGjDMQTvmmCIrDPe8GLa9wztTELr1FBAaacUDVL0wnp1MFj1Y6xDyylwCKuzrKs+Lw4U/1S5jsUYaia0ItlD2/ndddLSRTHRFFcdJyUwllnLBZHSIJAFVhdFZYW2znKHZdOYZWGmvOqJDfAWMVXW1uCe29hlWHjVgbAaLuUGGXQC2MmBCiOgpPbsfQyw8CdyE9goISLAC6MwwjbNo0N4TXaFJYdowxCSZS0LS1XRrsMLjJZVaGt9m/5zr5PF3QoJSph2QYbNmJKpmdRatdX0pp50gmxk9KpJXz1pasvXyxTtclgjkiQxeXIu+qFsKG/gVIY7VhLKVJ3vQ8Eo1B4VHFPpere1VBKK7EdQxeY3HW8/V63mpTwwXd0RdegkDHuvaixoqmYIHEKohNG9WcUFq7FJ7y6JBy8EcY5FIv2m8K8u6j5eKldXaGrOH7ZCr0MhvjPpWVoQcrXVoqjbcDrWU7Q2dDwkyfunYrhq56xquZu8XhwhKGX48O6hLe2c0UQhCgpEU4qSSnBQC7TSmfYSVCNiFSBf3EA4/wifrn0UMZ2U1Ug1JTnQpIfj5cLI6VxTK/LCV8wgXHt0KArYyCEgxYVYVQMcuUZtc9HwPhRup1HctlSXz0kChBv49eNMcgwIAgNRkqMWgy7tRPCP+fIim/cDDqmPXUrWf3aUvE1SFmxfN3GE1vVCYUUR847jk7M8EWo7QJDe6aurgBgJUfVquMbW5UQpaXFQhCH+lD+Hg6Le1utfY6V5j7mXSoAU1hcLDO7YDFjcbNXTj0TLTI8wtvuS2xq14CjAMRoCgfwEQwpnNfWLe+iWGFcMFvleUAxuf27HaETMH2dvPnx+GuMm9VG2yQOH/2YZhnKOKmtcitcagy3XOoWTfWKS4WW5VD41doKyLqUl1I5K1K5eizqDV5oFfc7ZRTfXSmt1ReoztDq757Zj5NCXvMvs5JkDQfY0/RChxwNDCtxplsBKr8VsbX2CLdlBKykL5jdLJzuLtf6KJwzxopvjV1dC6+u8+P4SVcsx5VnUlkhFtXUU7F6oeQuNtw33t7Rmibd6ly1sWubwZSrDBUotKz0I1VLVKW9VWG24H3y3thF3c0zvJXOlRa68a1aN5cbMqrvixUor4iEV6rozxoLuYFSUlXBKroyGaq0OOOl8vEvVajhULPRCGnAWBNWmZ9axrzIhbAAD2HqA28AjTEVB9KiydBUTXWWgevS20pbU2N6d6FfkTDWQSuEXR+0ZXY/gYSss7TGxt1Xjy666O8gsEvdAqwC6jqyuI27v29qwaja9m9V8TRaY1xGk1ZlplnZR6Wy6sevqpf48VOOoQMvJCsz3K7YQc35J4Vwwsb6CISAPC+z0Oocl7t2iaX9dSc6BaSpOwMwZWz2ooS3XtIyX7SqCPpOklJihIt6dBjQI2lDjjE5iBxhjJOQEoGNVwmkTe6QwlYCkH5lcJJVF04kJ099R3pOEAtOEsfsNmtfWA9wVYI5HcCbYS2Gr76XQYi6z8E4TOsVMSlLS4cQlvnrzC6wk7JsltN2jh0Te661FmkbrljAKP9e1XO1djA012Q6R+ucPE+tYHHtzvOcPMsh8DalqnKurTCo8IQx1ivu31UK5zuRVr+yTVlEBhYCFWmTleYKJZ1OWFsHi88Fzy3c76R0YoYPw7C2hFtpUn6vDrRnfk09DsPUBsCBCOGktsO9xhsBPQamIr3FYpLIUToqEd2SJCwmL3BfVdYbUStRobVNZlhcnQoLjTnqVawqsLYfvKnNfZdgpCwSx4V2K0KhTJtam4BipagcOPJc7Saf92tUqRQ4JYzJ8xydm4KxF0uRaGNLoJCrI/eqelOrtndjnOFAYK0nTqort3IXb1AR1MKNr6gIwXKF9vH+iyDPg8LFvj9y6Fg6ldJaNTWayuxfpphqo22y3ZHWVOPaXWwMFANvcFrhESxamjGr+kTVjOVOKyCLV1RlsSw66ZDXcaVtSynldW7xvJdmnoH9dz8Y9RWsbk5bVLKMMeS5tnE7ysXuOPjmB7EmnY/0mpsUFYTgg790rh3MKqV+0RmVSWSNDMYqqWlGnqZWwjpl0cOjXOfISmiINf1pVFDXnaQTHKWptxx/XHvLEMEFvE855kWf4cFZgSCPCEnhIipP63DydGKGbzabZFlW1BvR2iB1GThUl+Q2MlGbo3HzNcYousMqrV6xs51oHSReAtiVQJTYrTJpqs+tkjFeupbY3kMM+3v1XMfs/g9de7fFqEFvqKxPmnrb/O8eKggRWEbJvfK1EJ/iTKvgY5MWGKXAtCV0xJiC4S0zU/xW4HlRZXhrlcnzjGqckQiUhZZQlD6p/gnpmbyErmXdHiy0dNaySq9W+rvKpMtXfffilbGldp1FFpVsL7N4tzvTqWJplFJFDHSW5ehcF/b0aqNKDHuUCf0gu1dxDF0qNxaK2/xGUXEoWEldCSUtpGh9lbFMV5euHtt63lRKuJWgssZ6KJPbe+qKQreY0mifo4vBLJdgx/C69JHWlHSseTR3TFiFaiWVyqJS0q54HDXx+Xc22jO8Jss0eWZXEr96igrD1ywyOkcBIpCEUYRUQRFKgJO2ZSErK+E9VBG4gLvKBBUGpKlkqQowyKLP68KlWKNYJGPKyWHchaWZWCzoTmU/LIN7y+hUGN6bmmwSb0pGZmNphMCXb6vBlUVIU1tuLXlc7j+DcsxeThrwiqnAaG2tOmDLRsjcyikjAOlnjHucm3wFYzksakozYc1y4a7RC9n5JVyoS/gCkngYp0vGqsIbD/EwOYv25TpZCSmVwMgcUQlGyPNyglmpWvH6akGeGbI0J8vSIimjUIcrwXm+XVIqVGSdeEEYEQTCKtIyAO3CfnNDnkOOcb/ZVUQKSbupaISQpobMZARCIbxK6cY5r62kPjQDx7ilRcnzhoGKPcFdKygY3d/Lwl5RCLfTBGCcwg5fOga84miMgdx1foUp7HLqXI6++YX2ImrH6n/uuBQIbZm7pBI3CmEwOre38kyGdNKAQiqUgyvrz1FB8fyqTb32l2clBHAKYZ3h6wwNZdgtUGP48rs9lmXHueJl0Q9K+XIgFY4QuD41tfsaI8h1hiF3cSqq8ttCXyiJUgFRFBCGLiY9UCjpTZuSNIN5kjKfz8AJgDRLOTg4QOfueXlKms45e/YCxmhWVtqsrbaJggAl3figSrxhjKv84FY5o+0KULHN2dMqENGp9f4d/cQp9FlsZOororSCH1yDNZUFhSTR2mUh6XpGVKmMFZpJTcv2zFJUCBOAsDAiy3Ly3EMkiRRlaLGdWTnF5BECgS6UOG+18IPsIzctFpUISsvEIlMU4RKO4e0geGY9unTWHTBHlfQ61Ks+62j/2vcDyBFCWbjiJoCV6gZtcqpmRHtvqxNIGZTxJQWjlLDMP6N0/LioyNAufdNxxmQ8QeeQZilCGvI8JcsTrl+7yXg04XAwJE1yUuDKlSs0oiZxGBOEire85VEunN3knnvWaTVDJL5MYqmEag0HhzM+9diTvPHRi2ydWauZOmt9V/RvvR8LbO/yyPMTwhk4VSGm6sDYmVjNevGYuGBuczSxw6upVI4HQVDoBzZ8xg5MqSukWIeRtBIQn53kFVJnynQ5pd6+cxwZrb12uFQCWly8aE61vgGPiaUUYOox4HeSMnaBc/UWK4pz9RmI3E1sQRAKpCojFv0gK6RzzlQtJlWTrayZbquQzbfVY3MVSJSyTDMez7h5c88+Q0KrGSOEYJbn5PM5o8E+YRjzljc9ghCKp5+/zJUX5nRaLd71hW/mP/7H/8S/+7f/kSgK+Pr3fhVvePhBOu2GEzCGJMvJ05TdnV0+9MHfRck2X/C2hzgN1fQkJ9zcenfie9wVw3sM6VPxrJlSH7mgsAD4QaGEFt5e72tBBoFynkgfjKbI8wylBFnmbcyO4aVTYAX4Ms5GQy40wtRXENveBcV2QQGtBsEV9vTK9VEUImRYq56stTUHlkqtZ6jjOV9KVeDwxTIVXjJ7BrfhzVahr64q3jxaMvwCNFwoG1htkl8dLawp8XOSZuwfDBlPJvR7HXrdBg1pGE9nkKeQZdx38QJbZ84ym8x4+pln2b+5zZe87R1cuvc86ytdvuTtb+Kf/ctfJ2o0+PCHf4vR+N2cOXOeNEsZHA55/HOfoxU1iELFG95wLw+94X5arcCuTqKeHH9nckYHh/tPk2B48nh4H5PirRtCuJqOgU2t0wmGzOI0AZJ62G6pqAl/Ext77SIeVeDjYIR7CYMIHB6VGTrX9r6yjJATCIQxhUnOpJbpbQyNBmOZRcqKEouo9eqy2Bjp/hcoZaMzlcJ7Ej1UUMIqc6UH15AXmKp0i3tcbq0uZTkSz9wUJlOnw1SzsTwErK2aRzFrMTmFLwFYxiDZy6RLFhMojK3OqQRJati+uc/OwYA0S1jrtVnvtVAmw+QamWeIPGNtbYVWo8F4NuPKtSt86rFP8O4v/QpWV/rkWQJpxv2XLiJ0ws3nbxEKwxOf/lOef/4Fbu4ccuPqNfZuvMD3fvd38q4v/iLiWAEZsZJFVpiuKa91q31NhjgONziF9hT4HU4j4YvnlR5WKQVGSZQxmDBAmxwMRTSccqY1y3SO2QUVuOMmhbDhAuCsKP7FhILABpX52A4llY2/8SPqGDbPDQJpHSa+dEQFe5fRfE6ZdIwjhSlgBhWTaeBWnVLh9T3rlFcjUHm5wmm0C0co4zzK+J+ypLd1vbt7ViGg1cBrcKdILC/4vbQqLeq85TXmaDEqYSeKVBC4d5wbw2A047FPPc50PuOdX/gWOlGIEoZQKpI0J0szGo2YTqvFYP+AXApWV1b49v/6v2b32k1efP4y7U6bIJQkuWFtdY0rl6/wwuXneOrpz3Hf/Q+hVYMkSfh//9Bf4oEH7mU2HZFnitXVvhUkxjK7D5+WwoaslL4a+z/P2P47umJEeCWU1kVlTAhcPIRwTK0QIgYoY9XlQnZKxSlhjEFi49ZVtea6Q/nSMb5WVtL5QbY24Mp9lBtMr5Rm9jlWt/DnLe5WsiTOmrq1SClr0RBuktYYrLAGySKv12DwLgDh/vXvXSS4u1zbQvqbaqSMVYircMT/vyLgi/OqwyFEeXYtndHdV5nMrW2WwbLcsH8w5ZOfeYLHn3qOR9/4AK0ooBmHCPJC0ZVS0IgbTCYT5smM1Y11mo2Y3/l3v82n//STXLx0L5ceuI+VrVU+/enP8vRTT9JoBKTJjJ3tmzSE5OEveCtf863fgCDjM5/6FGfObHLu/BmaUVgUBfG6lzB+JLwgqHhK3PdCPEgbqCeLjjkZjr+r2pKeOaR00xKLbT3G9Wl31jmxEEDkJDxeAcRtHSNcTqkpmV1YYyNamsqz6yqKdrPfOM8lQlo7tvFOpFI6L5o/PXkrQrkSQSCd3dvf1p5ZPtcxnQK0tkNXHRxfHMpLbOsPcMFS0qYV4qQ8levKZ3kVpcrZi8LMVBrn9Y6jbZXCFMnpWsJsbnjy2Sv84X/+BPdePM9995ynFQXEofVjJElGmmYIIcl1zmBwyNpKj9l4jETy2//+3yEIeMvb38r65joGuPzcZdJkhjAaow2BlOhszpseeYCtzRUe+6M/Yjabcf7cFiv9HnEcWeGAj+Y03ixTFKrV2EBAzy9VEnjjCW6mvEIML0Q9FFQWOlW9dqTNM60rV6pYgYTnTTsgOIY3BcIvGFBDkRCCe7cK/5Mj0NKFIRifeIzLnil1BmvpKCVHUXWs0uZqWwNUbWIcgRCmTBK0KaALziZEsaD5CaXc6lUgKFgyTvUJvWwYy/6x30zl3Krh12sutmqOIjcwSw23Dkc8d+UqCFhf77K13iVSArQmzRKyNGU6naKNJs1zwigkz3L29nY52N1nOhyzevYc7X6PyXTKCy8+z+VnniUMAm7duEIQxjz40ENMJiMGkxEvPH+ZP/2TP+XLvvxL2Fhfo9fpFJWZveFFGYFzIZb85d/fw9GKl9Wv9lBCyJPQySuPUQYCSb+8COf1w0qQAh07ia08FBAOu3p7q2cE938v2YsXdBpJcT2UlhPqEtr4eHhjCnNprjzTVR5mW1yXun7i+V8ri5BicULU71VDOBUdoPpbufza/lJVXIrwa7gzq9bxfNEW926FFQMqOS1HRL5T+jwc8JNHY1AkueHm7oBPfvZJnn7mWS6eO8NKr4kwGUKE2KJYAck8wWAIwwYCQasRMJ+PmU0n3Lp+nZs3rjHKUj7zmc+yvbvNrZvXyQ0EgWQ6HhFGKePxgM1zF7ly7Saf+dRnMbM59913iVa76WxtbjTcOGlhrGBzXak9P4hCZKGdLuJRgv3t5NIdToPh8c+x/rEyasLFTQay9ugqZPeNFuWsACo1YCqYtQZZjAv3FxSDtyhpy5v5+AsBRlCf9HX2VAs3KWCFi+6T+NXm+M7061ndrb1438qL4NcrUZPOdsWseK5dO7z8skitEkCFKFz0FBOhqgkYvB/eu+WlttG+s1zzmadf4PkXrzEeDXj4gXdyz/kzNOIGYRDavZnSjNl8TpLOacRtGnGMMQnDdE6apXzu8SeYJCnz4ZjJPEeqNlGny3g8Yp6mkAuyZG5XiTSnT8TGmQsok9BdX6XtpHsJI/2K5WS78Za0crWy9nbjjXsVhdbPilcYw9fd5sKVni552TOmqopy4azoFfMmlQlRXFd9kChLW5SdcvTVLA60PeiVoNraWG07lT7y14sSBvgmVvMt7TsvPLNINasuV1UMtMySIstTKZfk8tlHB80PuMe6vqaMqZ9R+aYRRqOFtOZIIJEhg1HCx/740zz93IsMhwPe8qY30O+2ENoGhfltbLIsI0kSgiCk3WkCmoODIbv7e3z8U5/hs8+9wLmH38yb3v52xuMp08yQpAJNwMr6FrPRjOlsQtzs0mz3yI1gY3WT+fgAFbVotFrH8qao9IEUolafxjua6p5t14vHSsGjdCorTbVbPQzx8ECbau6/8AV5KzcoX0jgdN3ioCmgTI3JKCeBqZxXez0jiqq2/holSty8uOL75x/b6W42lCWJFjFz5dyiXctutOwRYuljS8lOTZpjSuW4hDR6obhqfVb7wDiDZJYaDg5H7BwOePrZF3juhStsbG6xttbj3vOb9DsdmnGEkpIkSSrJIJJmIwahyfMMZMB4mvH8lRusbJ3nvvsf4eqtm4yHI0IRsLq+RRgK2o0maZozGgwJGm3avT4iiLhy4xbnN9c4HMxt6JNY3g/LqSpGy9EspbzgmMiEpfSStrwR1T+HW0yhkInFqg0FE3gbdMH0/uf6O9U6pYaLq7BoETD730WFWeuXUGZ5+tPFEo7WLLv1Ionah0Vz56IP8Mh0tUerZtZKQw2G3JT6Cwi0rKu1LnGwco0kQzBNDNe3R3z28ae5cu0qN29cI44jzNqc1dUeKz3H7NiEEA+p0jSl2WjQ7LQxGAajhE988ml+7w/+kFZ7g04/5urVWyTZFIyhv9pnZa3LxtaKjacPBNeev8Z0ltBf36DbX+PF519kOMn59Gef4dFHHqTRjZxJcnnPLq6mdsIvjz8yxuUgv5KQxsexVzFDTWBTwcUVkqYiocVyl/Btm+0eWbOeHHfewsdy8pkjbauzP0e+LaPjkfvJ77HsGr+OWifW8b3h+9CAxfLaHsgRDKY5n/zM0zx9+TqzeY4Ukm63i8kThMlpNWP63TbtZoxOU+bzOUEQuBRATRBHTGdzhqMxn338Wf7wP3+KrfP3c7B/yPhwRDZPkDqjGYRokxHFAffddy+tVoPz58/yifiTHB4MeeSRNzCeZTx/+QpB1GQ4mpE5j7lfmJbo3LWeKBRw4/Wlur5TRx53ppOHB9sCaE6psNYR4+M2oGJl8YNkWBTxNka+xLyKulVdLJnCNUsJAlMJD7MWjHoE5nFUNd7pY7By7Vu1UOqRpWrhqvo/ld+qkvfOZHdP0mi3Q4kpXDOUTiqjC8Xcq7FaCsZTw3SW8fjTz7J9OOO5555jODy0lQPMnMHggI31Vc5ubdLvtYhDSZ6mTOczjNG0lSLPDVoo9sczdvf2efqZyzz51LNsnDvDbJawv7+PyXNGwyEiyzBKoKKArc0V7tnaoNdpsd9q8txKn053jYsXNphnOZ9+DA4PD7n30kWC0CXx+FJ7ld4qkJyA3FR8LH5juyUlPPw5J6W7k/DCw5IqM955UanauqvXVW+8eI+aOdBw9PpqT92hzcs+H3+B+98xt7ZyZxEsvUQyClClP0KDDZcGI2x6RSYss2tjcxD2Bgn/+U8+wyc+8Tjdfp/d/V2CUBGHAS9cfoooCjB5Sr/fo9NpoXVOoBTj4ZBeu4PBkOY5g+EInRtSozkcjUhmMxpRyJseeQNBEPHZJ55mNDokjmO0yUiTBBEGxGHEI/c/zPmNDaJQkeWaBx+4n4ODMWc3VsllgEKRzKZ809d8MSvNCIl2gPH4gTALX0xl7KsmXFnKphPRXTmevNHfwphjnmYWmfkosx6598JzMM50WeWrKtOfBGQvtAmqLrI7nHrEGlI+SjuvaenuP01Djn+qpFw1jTtiJKROcc0yyWg859lnrnLlxW0+9G8/zOXnr9DtrxA3QvqrbQbDA970pkdoNiTJfIzODO1mzOpKj0DZ3fMCqQoldTyZkOV29Y0bMc0ooLXa457z5wjDiPF4SjOOCGXO+voGFy9e5OrVK9z3wP1IYbiw1acZCWQQoIQkDkMuXDjDxmqXJFe0o5i3vu1e7t3oEgrL6oWF+rZd5oLlPMcvO3mJ5/x2dNdKa9XTdRxVVTg/QYrGmRIGUR46+k5myUQQtznhto3m5ALZMXJ9DTu6OpiKmfV2Yao1eeYGe1FWSPwepwKkZJ7aMIRcw3SmSbOcp5+9yr/+1x/hYx/7A0AymYzYWO/Tb8f01trWXNrp8PQTj7O5scpsPODWrW3W1/soBe1Wg0AJkvkcJSXj6YTxZEaz3SZJ5gQ6Z7XXJQ5DWs0WURCiV/uc2Vjj0TdcQipFo9XibW99mLjRIlDQICNQhlznpPOUmzdu8NAbHiJSdty/5Iveyte8+23EkU0D9Mn5xw5FxRTp45aq4c61sG/jLTaviNLqg5tYyjhGcMS+bf897m5L+dv+W1VwF6bWkUmypE7Mneh23ePt3kdspLXrvR7hfhalVaocAK9k2eOymBsefZcDaAwuRlaQ5obEZHzsPz/FaDzk1q0drjx/leefu8zNWzcYDA4JI0UUKe576Bz3PfgIYdQgalroEA8n7G3fZNfk9Lod1DlBkkyJQoXWKel8ThjHTKdTMhfLv394iAwE585u0W80iUNFFAaQaWQA7ThmvXcG7SDQn37iRT7+2Gf5gi94M2986B5acYAIXPRjntNsNpBoJDnveNsj9Pohubdje/XuNg6jWuhAgWhFxSpzd3Sq8GCBhQPL1MSqtCoZVVeY/nYq3XIy2Az/wq5+7JknL5d85ycKNybOdmPsu/nqOZ6K0hdgw3ZFaWHBnS9NXiiftu55hjGQ5jlCKSSSeabJUsHVa7c43J9y/fqQy9euczA4oN9v8+xTTzA6PGQ6GvLMM08xGE84e/EiUbNBu9flvgcfYnVjjfl0ws1rVxEGRoMB/V6X/Z3rkCc044DD3R2uXb1Ct9clkBIZhAwODwnjiOFkwmQ+o9/t0AhDWrFEGoPUtp6IMQahDYGCTEMkJYHQ/Mav/Cs++Kv/hu/9i3+B7/yOr0cYw3ymuXDhElIJJknEzq0x5842iFXFE368alSiAGN7TgvhC6IUapUUuDTO00PIU0h4n6BQadltz77D8QKGl2cuMzAZXA3G41t1+4aciKqJgV5yp0U7bUfL2qyWWhVbVWoo9yq1l9iw4bLqP1oLjA4REvI8QGp48snn+f0/+GO294c8+/yL7O7v0Wx1QCmm0xEBGdPRiMuXL5NnKc1mmwcffoBMG+65dC9nL1xEC0GoJCIM0OmcPMuZTsc0o4A4jjnY30X0eyglmEwmTCcTojDkxs0bSCkZjIaFc0ui7Iton/juKsj5DCuvTAP33nOGd7/7i/l3//53+fjH/zPf/Re+kWSeMTg8YGN9DZ1rPvHxzyJlzEMPPOBWP7+yLWeimlJKmQklXLhBuW6WuPi0sv5UkKb0CL4cTHbcvY/77ZV7ZlWvQGDTBHXEon6wAFQwoqyfYgzk/rOrS5PmFoNnWc7u7oTpCNJkzuOfe5x//+//PU9+9gkOBwfc+/D9nLv3PGvrXcJmgzBqMB0LLj/1BNl8Thgrzl44y+aZc2TzOYfDAZuba3Q6LSazGUrC4XAAecZkOMCkM/aHU7rdDnEcsbe7zcr6GjvbN9k7u0UUhRhtSKZTZvM58ySl1e5xOByyfzig29gsDKLC5I75FAaXMGM0q6td/tJf+l6+4Ru+nmeeewowCKO55+JZjAoYjkdcv3KNr/iyt9FuKnR+Z6NFlQqjBfitvewYvEQ2EGYxs+MYujyzuFUJjgRfQUW6OR5RdgfgI5CmemXVS1gwzjJFnEporXj55putWmZXLl9VQLikM+1yR33GFr5tBuapZjDKefbyC2ghWVtf48Urt/iD//QJkiTh6pWrDAcj9nb2acYNXnzheTY31jkcXmEynhCHCp3NuH7lOTAZqJitMxd5y9veQaoFQaPF2soqe7euETXg5vYuDzz0EJ/+zGcZHBzyFV/xFTzwhkfYPHeOq1evcuPaNbZv3OBgZ5udWzfRecrK6iqNRsx0MmY2HbO5tcXq5gZvedsX0F9dI0tzprMZRmtUGNHtrDAcTWg2Ir7w0Tdy/71niQJFIEFJYXcv11bN0G7dtbvPS6azGe12jDCCJM3JC7OpZKUXEgQZxoTOqmXw2yTlt1Fcq8nxufvzEZO5wdbiyU1RqeKtq6+I0krh8TrNbD3xve/mmsp8PW2balGawtaB0cbWfsyN3S0wyw37+ylPPn2Nxz/3OIeHA2YzzfbuIf/+P/wHzp49z6UHHuRgsM/NvRu88U1vIteCB9/wCM3OVaIwQASG9bUVkucGrK1vMB4cMB/nrK2vMTzcJ0sTZsNtPvmHv0OiJW9/15cRb65x9foLTCYjWq0Wzzz+OSJhOLO5xvrmGmvrKzSaEVpnjIYHjAeHhIEkUoL9wwFSGJJmk1a7zXwyYndnBy1hNBrSaLVpttrc2tlmOp0iUUT3tml2upg05fILV1hb67C+0iPXxjm9hIV1wnvZZZHnHEchEukq/mqEDF3xK0OkAB3YRI6Kon87L7IfG2/y9Ui6upoW9+J0fHPXZsl6/HbZAIpmHPftyJ1q5x074/05puozrf1SYf4SAmkDmctxlZR1aPxv88Qwnc5RKrDRjMawvbPHn3z8CYaDEUlq+NQnP8fG2VWefe5Znn76aUbjCfPZiHNnzpKlB3zqkx/j4qX7aMaKdD4iTWZcv36Zg8M92t0mIsq4uf0865tnaDdjRsMBKohptjbo986yv3uNyWiXJB+gheLaC0/x3POPM53NuHjpftLZnPHhAc12A4MiikLyLGN4eMBsMiZLM1qtJtvXr2F0TiAE2XxO1OsRBAGdTodbt26xvrnBC5df4OyFe0iShNFgyGg8RqCQwTXOnL+IyTIGgwG3bu0QhwHdZuxq45giGV4InEXJMmNYbHdkCF0esFW6tJXhRnLUW307tbV+jkfvnumtKbJQAk8Fdu8yPPgorJB+m5KKKfJ2CmWdWanZ15eBLG94dDvcYIRBuURIW4pNF6U7RsOMF65uc/PWPtdvHPDvfud3uXbjGt1el+vXr7F7Y5tms0Wnt0LcaiKDgHanzXh4gBSSPEk42N8lSWbMkymdTgceN7S6XS4+eJG1rS2m0zEXzl8gmSfOS5kTNCXz6Yhuv4cMFLlu02g3uXDhPGSaa1euMxgMOHP+HrJ0RhiGoA0XHrifpx5/HGVSktmU55+/zIV77uH+S/fR7PV49voTtBoxK6urdDc22TyzhRCwc/MWg8NDstSWvm42W0wGAyQKnWqmowlZmhHEAYEQDHf2efANj5Klmt3dbZ576mnW+6sMxhOCMAIp6XZaRO0Gw9GMW9sH6NU+/W4TZE41rxihHPyzGFZoW/7OJ+hILZAiBKylzY+6nSb1qNf6cB+x/7k0PxygL2y7FQed4WTuxJcYLVlrZiUsoHCEnkpJKT5ReGb88Wqcr7Pfilw7c6B1uRstmUwzfvu3f4f/9CeP87E//FOeevpJVlZWWV2/CEpzfedpkDn3vOEiSgoefcujvOGRh2g0mqRpRq/bJk9TQhXywQ9+hAsXLnDjxjVGkxGj4YiH3vAGWp0urU6HXq/DeDQhy3I6oxHXrl5l58Y2+Twlm83QCvb39wjiiMNOh/2dPVQUkSQJ6+trGK3YPRggpeKRRx4ibLW5ee1F8izlXBxx5swZEDAej1hbWcEYzXA05k3veDsrK30OD4fMZlP2d3YZHx6QzeeMhkPr+k8SZrMZCkEkA9vGTpeDwwOeeepJOqs9Lj9/mTPnznLr5k3ms4TVJKUZN8iyjGazTW40SZowHI0IA0Gn1SjyHgQUcU/1SE9Tzy0wbuwKGFQye3U5X874FarYLIoaNncJqU9XiGlJi0oYUXFKcXSeLr3n4veK2asGW46shhZoJ4kGBUmW8cnHnuIffuD/4sknn2Q02WFvf4fZbEwyu8bu9otcvPQAF89t0en32Ti7xf0PXmJzcwUVgBKKs2c3abeaTEYjbt66xdu+6G30+j1WNvtorblx86aNOBSwsbVKt9uhv9Jjd3ePqBHz7FNPkk0nhEJy8/pVmt0O6WxKns5phwF5OmdlfY3caPprq+zsai7ca813e4MBZy5eoLu+wv7ODv1+l16nw/Bgn8lwYCHJ9i3uvXies+fOcevWTcBWbc6zlNHBHkEQ0mw2SZMZrW6HeZqSZilBGjDTc7rNNvN5wo2rV7i0cx/ra2sEQtLpdplPbnK4v8fZ8xdpNBvkxjAcDjl3ZpNM52zv7hCF52i1Ilu2sCbc6gxfS9AQFeFVtXaZ2ujW9LBlhsaS96pTo7zpK5IAUn/wMb/ZT3ecfEU61zGgZzFvtf6bfVhqDFf2hjz3wh4///P/kMPBgNFwRLyyyoP33ssbA8mLly+TpnNUw3AwukVr2qLX71lTs6u2MB6MCMOAoRoxODhA5zmz+Yz9w212dm8wHk/pdnuu3YYzW5uMDnc52L2J1oIbN25gjKTZDEHkxK0G2TRjNNxjfXWN61eucHjrJo1Om8tPP8X9DzzI4HBAt7fCmbNbzGdTwkjRbjbodlqsra4w3N/jiU99khcvP0ccBqytbtDp9/mCL3wnW2e22N/fJ5mnHBzs8cKzz7B79Rpxu8PaxiatTodOt0Wj22E8GpG5QrBpZuh2uhzsbHP12Wfpr28yHA2Zz+dIA7PhkOtXr7O6sc7ZM1uEcYQREEcR0/Gcm9vbnD93DqUUWW6IjtmJxdcb9bUrb8eMtcBAxxHL+cuFBFf4wy8edd3tznQKhr8bG8rp6bZzxa8AAq7eOOCX/81/YjydcunhRwgCyXgytOX5gogXn3+eMw88jNaaR978Rp565kkefuh+ms2Ibr9Hmo65/OwuzUaDbrfDSGrWVlYYDiZsbKyyt3/A/v4+jShiPLKWkjBQBEqwtrrCaDRmNBwzPDxkPJoyGY/IdMrN7Rusb2yQmYwXnn+O4d6+fSslaLf7TEdjUqBjBI1GTKMV0owCQiEYT6Zcu3qT3evXuHX1CvlsSk6D0WjAxbMP0Wg22N/fR+ucwfCQZD6n1Yi4MZ/SaDWZzqasbm3Q6LSJmw0mozHz6ZTBwQF5bmi1OkwnQ/a2t5lO5zRabYQ27Ny8Rbu/wjkpaDQaTKdT1le7ZGmGasQ0m02GhyMGwzGtZhNjDGGrUSqRUOB7n0QihEALhS9qYSqKXz1ZXdTG906wxiPcu6VTxMNXCo4WCuZiLRR7rFzRlrdsWeWsyq/u4uJuNubdFd2REmYG/vOfXGU0nbO62uLchVXSNOH6NcWNW9uIdEq722V1bYPhcMCV69d4wyNv4OKFLbROePHy81w4f4He2bNO2WugpGA0GiOVYnt7hyuXXyTLMsbjKYPhiAv3nGfSanA4POTsxhYbW5tMJjOEkEzGU4IgAClo9bocHh5i8ozp8IBsPkaFIfNZwkpfMZtOCFtt5tMpw8GA8xfOoIDZdEKeZSghODzYt9lD2hC3GkxmU3q9LufOnkEKw3yecG18nSxNmYzHzCZDGu0mZ1YvETRimt0ucRASRhFXXhiSZTZfNep0aHb7jMZjorjB/v4MpUKCWDJPZ8yShOHwkI21Lr3eCnEUoRB02h3SzDCaTgmjmPl8TrMRgfKRjAA5wthyIPMkw4jc1uM0rs6QKNB7wRvS2dCrac4YZ6DwW35SQl2fNurLIenjl4Rj6aUrraKEKC/ZMr9wg3Kl0hhp65aMEsOH/sOn+NBHP8qXfvmXkCQzhDBcv36VG9e3AcV4NrZYUic04oB+r8k9F86yvtZH65SH77+fPM+5fv06rXaLNE3Y2dlHa0232yXLMtrtJldevEKvt0IUhjz3zNNsnj/LSr9PGAQcHByQ5RlxIybNE8bjKY1Gk8P9fUIpmU5GSJOjAkkQRjRbLQ5HI+K4wbmNdVY3NtB5xng4pBGHNBoxN6/fAGOIoogXd3YIpWA8GtFoNEmSGaPRkDNbGxitaTZjW8wIQxgGjIdDJuMxa1tnWFvbpNdpcdhukOuUYbPN4cEBg8GAKI6ZTEbs7+3TXVtFhQGNVo8obtNttzh39gzG5Fy9+iKNe+9B6JxAtVlZXWU0HDGZTmk1W2RZjjEKv9OIkhbqzHPDwWyOyhK2QkkYhIVlx8KQoybrKqIXoqxEVpzjj7nJUejCNR45Gb1sVppldNRWfzoS/v/CVic2RrA/Snnsc1f4oi99B4PBLtookuGQF55/jnSqCaMGZ86eIY4iup0WAlhb77O22mM+m7K20icMA/I8o91uOQxumM9ntFotbt26xXw+59rVqxweHNBpd7jy4gu2GcZWVxuORqysr9JqNTl7douDvQOmk4jVXpfNtTWuvvg85Bnz2YzxdEa/2UMFEVGzzdbZLYajIWEjprfSodftMDg8IFSKMAgIOx021te53m6j0MyTGYFUJLMZGLvFUKfTcf2rCUK72ZxOEmbjCXHcIE1TkIK+K3ZqUsPB4JBut8tsOkWIgPFsRpykXHrwQZSCTGvSZAZ5RhA0ybKUyXxGmlhTb39lhXa7jcBWjU7SnFgGLoDLgFCk2jAYz9g7HKEiRSsKiAJJIOURy4oPF1kM7xBUywi6GBqHY30etHDnUYFTJ7XGvyIMb+MgXj7MbwAjJLmW7B0O6a30WVnvMJsMOdjfQ8iczfV15uOUWZKzdfYMh/u7rPS7nDu7ZXefMxlKNJBSkiRzxuMRWZbSajURQhAEisceewxjDHEck2cp3W4HKSVZmjCfzZmOJ2S9HrP5jNxJ9+lkykMPP8gLzz+PyXNynaHThL2dm0wnY2TUJmp16fT69Dc2aXVazNKEM2c3WVnpE0cRAsN0PCKdz0mTlOFgSK/fI5SCg/0dAiVtiMBkwnw+ReeGKApZW1sBYct9Sy2RBm5cv0HUadLrd2g1Q7bOnUGimM6mjAcjhoMBcaNJ6EKCp7MpqxurKG3Q+ZzB4S691XvReUaaJrQ6PbJck2tNq9FE594eb6GLlJI8z5lnmtk858mnnuNzTz6FJufL3/WF9B990NbD5U7go87o9ogocLufMF6Hu1uV8hRmyaMmpFePbIjtzu6ED3/od5mKhBtXB6yurdBqN3jm2ae58sILDPbHnD13kdXVFVZ6Lc6sr7LS75BkU6bjDKNz9vb2kBK7fYvWtFotkiRhOBxy8eJFDg4OEMYwTBMEisHBPsPDQ6SQTEdjppMJWZoSN2OiKCLLMg4PLRw62N3FpDNu3rhGliREYUx/c4tzF+6h3emQpCnjW9u0Wg1rzdA5STJndWWVFy4/SzKfcrh3yGg0QkrJ3sEeeZLYYDRvghwNCYKQMAw4d+4cb3z0UV584gny8ZzJcMhmENBotmk0mjRbIVqndPp9zl24wEG0w9xJ+CzXrDVDNNDtr9KIAqajMY1mRKvVRBrsfq1SoMKIJE3tSjNPiKOIKIrJsgyTZVbiZ5rPPfk0P/H/+0mmkzn91VWuXr7F1vv/Avdf3CgtMMcI4mrsTJHgLTjioC3gj6CCHl4BK43FV6I69+qtqNgsy7ISC2S8WfH2C9ASSyxJqvm//vlvcWNnm62Lffb3D5hOJ2AyRgdDDncHzJKUjTPr7O/c4tI952hEksn4kNzktFpt9nb3mExnDIeHpElKFAcwNQRBQLvdIopCNjbWSeZzBvt73Lxxi3arTRQporBpc0FHY6I4Ym9nh/MXLnBma5NGo8FkMmUyGnJw4wUmh/vkRrC6tkW3v05uIMk0zW6TXthBkKN1xng8QkjD6HDA/u4eyXTOZDRia3ODWzeuMRlPCKWk2e7SXVm1cfQITJ4TBAqd5zSaDVZW19gZvcB8Pmb31g22LpwnP3eGMIpohDGYgNFwgMlWmE4nHBzY/NXNzbPcc98FVla6nNnaxOSadqtFlqXMsxxjemR5TkPZ7XeyzD43CBSNUJErxc7eAUIqVBiis5zZLCOZp+xsb3Pl+g0GhyO4sFHgc+MUTlvbXRdmNxsx4GLfF5jLrvD2YoMp4uO96D8NbD5x5oRzGiOFLDYuqP75CVG7ZuG7L+Us8ZGSyx5UPWodDMbA8y/u8Qd//Ke0VjqoMCaKQ9IsI01zdJaztbXFW77gLXS6HYTJ2N/dIQwkcRRY6TydMZ3N2d8/YDKZoYIArQ3bO7sMhwPiOEJKwfPPX2Y8GSOkJIpCoiigEcfErSYqCCw+RrC7vct0PGUymTCejGxSc5Yy2N0mmU1o91Y4e98DXLjvPjbObrF57iyrKysEStJqt1BKEYYB0+mE0WjIZDxhOByQJDMO9vaZTiZ0O126vRX6a+u0u126vR5ZmjIej2k1G8znU7q9Hv21FXKTMRkN0GlCI4psmIWRtlS3hG6/69IFNUEUIpQkzTI2t87Q6bQJwoAwCpjOpoRBgBCCvb09sjxHG0MY2m2Jwii0dealodOKuHB2zW1gZrh03/08/IZHSLXhjY++kf/v/+eHefSRe8u4dj/mzokkKgFl4BRV5730GN2UXIDBR2qWbA+vUDHVo1QaTWtOsCXkHQT1U5YvQzXIJCyYSY3kU597lov33EMjitlc2+Azn/k0Ozs7SCXodzsoBW/+gke49MD97G1vs7e3w3OXL7O5tYk2hiy1hUKbzSYHB/vkeU6jGdLv90jmc7a3t+l0OmxsbLC7u4sxhpWVFa5dvcpsMqMpA8REIJVCCMPqyhpPPPEEvX4fIQS7t66zv3OdNEmIG11WN8+wsrVJs9NjfXOTTBukSWk0Q3q9Ls1mTJalDEczfDWH0WhMEARM5zOiRgOARqNBs90iDEP29/YIlOTMmS3iOKbRaHDuQoeti+d5+jOfRmcp+9vbXH3+Bc6eP0fWiQnbHXq9kPFozGQ+RQaSMA7px02EUkynU5qtHu12m0BKAqnspBaSNM24du0aSgV0Gg3L8IEqCuXGyhDJkAcubLKzPyAh40d/+Ae4fv3r+aJ3vo1L59YIgrJQrM9aK8oUchTb18s4Ou8tBlPsFVLCnrKW6O05tUp3Hy1Z+Vxl5OXLiygQz2mMNgbIMs3OYcJvfPAjrJ3ZYjDYY/smjAZDsiQlbkdEseJrv+rruXjPBcbjMWR9trdvcv3GHvM0Zz6f0ohbzOdzwjCm3W4zHA5ZWe2xt7fL4f4e3W63yOI/c+YM48MBzz93mTiO2drcYp5m5FqTpQmTw5TD3V22NjbR0ymDwwEHN29w89o1NJIzF+6l2V8jarRYWVsjakScXV1lb+dmYR1qNCOCoEsUR1wbTxkMBgShXUGkUrRbLXaTOQTSSuM0JU1SeusrpKndi7XZbJJkKXG7TRA3mU/mpPMpw4N9tm/eotttkjn8L4Sg0+8RNRvs3NphMk1pd9pEjSaX7rsPdEqgFI0oZjKZcGt7FykVnU7o9uUVBEGAdDu2RFHgwrUMgZJc3OhxcaML928BbygYRAtna9Elc/uqY2V9IGePO8bxVDVbeuhjjCiKT52GXlGz5MtCUvLhf/fbPPH0Zb7v3e/k1o0b5HnOww8/zKc//WkefOABvvgL38q5jXWiUNCK+uS5QUnJYDik2W7R73UYHI7Ispw0zbh16xbtdgshBOfPn8fojN2dXebzOXEcs7KyQhRFdLodpuMJ+/v7NLtdRq5ei9EaYXI+c+VFlJJMBiMO9vcIggb9tXVEs0VvdZ1ms8v62jpxHDAaHNDv94njiH6/R5bPLcyaTsnyzEo2KVnf2GDmkjZarRYyUAgp6a/0rcUoy5nP53Q6HebzOUmSEAaKHIEMFIGUTEZD0mTObDpjPJ7Q7rRptVqsrq2xt7dHq9Oh24vo9deYJwmBUkQNG3IspaTb7XH2rJW/diM2CzOUstLdb7amnRSTNZ3NQQ4h3IYGHs5U5Pky0Q5uRa+HcC9hiCKU5m5KpNx9mY5lj6lq4YW3lSMvVkMtx2m37p8Xr+zxxBNXeeiRh+n1W0zHLT79yU/TbDRRSvDgpXt44N6LtMIAJeBwPMTonPX1VXJjOBgcEIZ+a0zDPEk4c+YseZ4xm864+uKLtFpN+v0+4/GYXq9n6yu2Wm43EsE0mSOSkFxbU2Qym6N0TjIdkiQpeZrRbnfpr59h6+I9bN17L0hFmsxJkzlS5EShotmMkUoynY7JdcbVq1eZjKcA9Pp9Gs0Gs9mcVreD1hlhp02aZcRNa9XZvnULqbbY3NhgPp+jlGJweMjK6hpnz53n5tVrtLsd2q0m0/EIrTXzecJ0NmU0GqONIW402NgMgYDhcErf9BiPp7Q3V2k3WkVh1a3NTTB2E7lWu43OcrTRKCSRCmrhARZbi3JjMlEdQueUrPCFhTYLPhrhJb+xVYN9Aoiz1PhjxX3N6ezvnl6ChBf1WbokXMCWhltg+pO2z7mir97Y5drNa3RWujz79PPk+ZwoVjTbEV/6pV/Kl77zC2iGgixNmc9TyA2NRki32yEII9bX1tjf26HVbjGezJklY3SWsrrSJ1QBZDAajBiOh7TbbdI0I4obiCBgb3sbKaDZ7dDur7J15jzpPGF8OORw9yabZy+yvbvDxuYmMoiJGl3uf8PDnL3nAoPRgHYcs3Vmi06nSbNpN/dKksRJ6RmbG5ts622yLGN1a4P5dEqv32M6ndBMW+R5RrPZZLW/wng4QoUKbTSZzul2u+zv79NfXcUIwZkzW+xdu8XKyioqgGQ2Zjoe02g0MeRMpzPiOKbbCRFSME9StIE0TUnmGe24S7MRkcxnhLFlizAMkVLS7/UQyIJRG37LHj/0wo+3+2AWhlsIjNvFoxDKxu76gRCFCuqL3GpR7gvgLndxBHbDttzfXFpYI+6QPVWl1yCk8VNYkueGP/yDP+XW9k2+7kvezmi0x3PPvcDVK1f55m/8Bt76lkeJoxCTJ0RRRJ7lzKZzJpMJQgi63S5raxFZNkcKxbmzfYJQ8cLl59i+NbOQYDrDYOh0ui7CT9FfWWFvZ5cszcmSOSsbG6z0esxnMzqdNvPpBC3tdpYX73uAey7dS64hTXO6vQ6GnLNbW4yHw8L232g0mM/nNk5dKeI4JggCwjBkOp3SaDRotVqMB0MLfUJV1EgP4siaIFtN9vcPWFtbY3d3t1DCZ7MZ48mEZqtJmuesdDoEQYjfQ7bZitnf18xmM9rtNo2GhW3qbMRoPEJJYctim4hG3CBLU2azWdFGu0u6tJ5dt3/XS48jOUpV44aHNlDuA+Z3BfE7Gfnvp2nLy8DwpnQUUAb6H3v2HTVqUdzz2pWb/MZv/CaXHrmfnZ3rXL16hXma8TVf+7V8zVd9JaudJqGAIIqtUmk0aZaRpXbb+DxJSNOMC+fPM51OyPOcey+eYT4eMJvP2dvb5cKFixwcHqLCgDzPaXc7xHGDld4q3X6fve0drl65QqphY3ODVrtJGJ4jbjRBwNrGBv2VFXZ3d+mvtRhNRnT6HSbjIXFsHVNhELGzvcP6xgbj8YTJeMJYja2JV0qazSZaa0ajEe1el9l0QhDZjZCTxE6Sfr/PPJkTRorr16+ztbVFGIYIIRgOBjZ7SkrCZgNUQJLnjMcjOt0202nGfD5Ha+2U8AusrvRJk5zxpMl0MmY0GtNuNlFhSJokxaSMXNKKEJI4UAQvO68v87qIghM8qcLobv8xwm0oJz4PoQXeoVCDNOKoIfKkZJsv+If/4J8yGg9pNAM6nTbd7grtnuKNb3wj66srNJQtFpTNNZPplNF0yjyzoamHB4ckWU6/v0KnHdNqNQiVREnBma1V0kwzHA4I45gkTVFhSLfXR8iANNOEjZjN8xfQQtBqNtBopITJZMS5ixe5596LIAQ3b91EKsPKWp/DgwH9fp9mIybNEhrNkHa7RbPRZjqds7O9y2w2d1aWjNlsSp6lNBoWowdhwCyZ27Z0W1y9coU4jun0ushA0Ym7tjx1FFkzYhCwv79PHMeIQGECy/DNbp9er4OQkGZzxtMxUtqEkfX1dVrNmGYcstrvEwRn2N87tF7jPKMhIuI4JgzDooy2jW+HOIyJVUB1z9q74JaCT6xyuuQ2BW+X9aKFEHY3GGMKCY+2wP8Vrw9fUjk7lymfS7NXbtewSrsnk4wnn3iWNJ2BMDz51FNcvHA/UbNFt9dDYFAYwiBkms0A7K7ZYUijAVmecf36DQCajYBmM6TZiIjCgHsuXmD/YEin07Wx3WFEEAQMhyOUCojjBpvnzrF64wbzLKHfadvYkjxna2ODNE3I5jOS+ZwL58+SpCkx0im+I0ajAUGgyPOAnZ1ddL7rLDKTQspqnVsTpKDYaiaKI0bjMVoKru5tF4wHdqD7/T6NZkgUxXYHdK0ZDAY2bj1QbJ7ZIm40aXc6bG1tEobWuWUQZFnG5uYmzUaDMAhoNRs0Gg2kUJw9e5YszcoUPVHunD6dTogbDYJA0YxCgsJDKmsj+VICTkzlX1E5ICrKgNdXhcM21Vqlr1jG0yLZ+GRja8YsqaG+WPHxZG5dTWZyPvW5p7m+f5M3v+vtyKhBr9mg1Wmztb7GufU+/WYIJmeaJKTa2GhEbc1laTJkZWWFyWTO4HBAp90gzyIaKgQJzSBkHEjuu3SRVFvJrWRImmmuXrtK7navv3DhAo+84SEO9nZpxU129nZJs4zB4ZD11VWUCsiznHQ+I81ztLahsgfDoa0wpnNarS4He0PCqMFwNKLZiAmU4GB/l9FoTKtlpb+UEiED+r1VRuMBcbNFv9tj7qBYr9cljkPCuEmuNbP5nG67xaV77mEymXHP/Q8wnUxZ3dxibeMMKytdhsMBACsrPfr9Dv1ej7V+m7Obq0RBQLfVRGsQIiQPcybjMZPxhG6vS5onLjFekGcpcaeJULaWjDxhwvQdqXC9LkJdu+OhwW7w4GeCTQ6nUFqL8ofH1u8/Si/ZLAlQ3fj3JZGw+rqUAb/3+x8jara4dP99zJKEdrdLp9PkwQfu4cxqD6NTsiwnSe3g58agtZWW89mMLM9BwOrKCmEY0mg0mc2mBEIwmYwRQJrM6PT6JCt98hzmScql++5jOp0RRTGHB/sMD/f5ii/7EpLpjI31NXb2d9nUG+hckyTTQtHa3d5mMh4TBBFBEDKeTtBozp5RtNpNJpM5wuSk6ZxbtwZ0u52ihJ1XXrW24b+9Xo8oCsjShEC2aLfb9Hodmq0GrXYHbQyNKLRVwPKcLEnorfRo97psbp2h2eogpSBuhOS5rRzW63TYWl/lzNYGvU6bQKrKBtLKbQNvCMOQNEtRgUIoBbkmUIpAyYrL/wRMcbIBBxwSqGmft3vAcRjoZPTS6tIUn0/nQb3NXTECdg8mjKaSL/3yd7O9u0uaJUSNgNXVDo04JM9Til37hCbXGQZJEIYgbJpao9Gg1WwBEMc2TS1WkjgIODzcYzQY0IxjWo0YVvokqeFwMKAVRORpzng8QUp4+MH7aMUhK+02UsD6xhpPPf0U23t7rKz2OTw8YDqdEoUh+9Mpg9mAdrsLEuJGRJYmYHKE1iTzKQ3ZJIoiGzoglIVTqqzl4oOz2m2rTApt3PcWcSMijiOCQNkdr7OMeZ4ynU7o93uoIKTX7TqLT5PROMAYW8Kj3+uy2uvRiptEYUigAowRCGE3Ic3znCgKUSpgPp4Rhg0acYzOcpQUBEIeH/90Al6xtHj1UcauOZzMwnFR/eHuGO6lK613/+ylpETAk08+w59+8nEuPXSeOApJkgnolOlkRJ7NCYQ1U82TxEp3nZNkCdlsQp5phsMR29vbaA1nts4QRdZl345b5NpmISkliYKQZhwTBgGTWcZ8HnP9xjbNVodmM4Z8xoWzZ2jGttD/aq8LUnBmc4O4EbC9vVuY+La3t5murjKbzknmqQsRkAwHQ5rNFlmaYvKU4WBGb2WVZrNJu9MlkNYpNnd7o/Z6XcLQFlvqdltks4Q4Dmk0Y/I8RSlBFCgGBwMEBilsbmwEtNpdOp0u3W4XMKjA2HAKGbCxukK7ERMGkjzLUVKiVEShGhpB4PZqnSdzglARSOu5jYOQUKqa7f3UtORaA0uV1kWm99+0rm9sVmD4UzTjNWWHF0KSa8MnH3uCtc1Neqsdnn7ySc6c3aTdbrK+1qPTjBBY82Oa5eR5jiZnnsyYJSmT8ZT5LCWKQgaDMePRiDjukyQpOzsTWnEDFQR0um1AEkprX55NR+gspRHH7O3swvoK/U6XbrtDrx2TzjOaqz1bFTjf5PyFLa71b9Jpd0iSnDhucu8D93MwGDA4GJLM59y8ehW0ZjYZMZvPyZKUMI5Is8TqN1rT7Lbo9XpMp1OUhF6vTZomaJMTBgG9dhswxHFAu73ObDan02qh0zmBsoFe8zQlbjRtGHGnSxxFZFlCHEtmU4XQglAp2s0mzbhhLRuVgC5jNEFgd8TNshQlrdlN5zlhFNkVQUgb6yJOYnx+eehEFmxOhy5eWrQk1glQFqxf2p5T0XSe8Vsf+Shvfuc7WN9oMh+eYWVzk85Kh5W+hTRCQpbkIDRSCRSSMFQYAZPphFwY4ihicyMmSRLm0zGNRsR4PCGZT+l22iSJDfNVQVhE36VZhjGaF164TLf7JsJ+jDEZjXgFY6Y0mg0GgwHr66sgIQojjIbZdI7BMM9z2q0+ndaQ4XDE4HBsw5jTGYPJiDiOWF/fIAUwGuUsMIcH+/R6XbqdDlEUMAWUEigl6XWsuz/LUlpNu5GwMJo4jBBCMJ/NaTVbrKys2NzZ2OaQyiBAiABpBJGyK5lSIUFgFfcszVFCkbk9n7yTSillKzSEIY0gpBkENJWqbK/mPaK3H+FlsTA+9qUoTr70cqvJaufVWdx3wBRnVNpyCu/TS1JafXKuEG5nuVPfoU5JqhkOU5599lk2Lm6SmSaf/sTHufDAI3z5/+vLGBwecmalb5UqIUFayWSw263MZhOQ0Ol26SvF9vY2jUbIPJnRbMa0Oy3yJEFgY8XnaULYyGk0W2xubqHZI80P6K/06fc63HPPBZqNhpVoSiKVDVFttVpMZ1POnzvHbDrn4HDAPE1RaU4W5GSpYTZNeOSNj3JwuM/hYJfNs2cZ7Q8ZT2eEUUSgJMIYF/feQmcpcaBAG7qtNmGobBx+HBTlC1WgCNq23oxXcoMgRKkQJSTdVotGswnYtD9jrNk2lIpms0UUxxgESkikNNZ+bWwtGW+KbMQxSZISqIA4iiyUQRRb+1SjRO6GTOUPKNJBq/qgPa9MNqo+UfpVyZ1zGgsNvBQJ7+yfL+fSZoTkD/7wTwnCgJvXrzEaByTJjMc/80kefcsjxNEK4/GE1XYHv427lJLZ1AZgtVotgijHiBAlFb1+l/lsxv7egHarSRgoG3aAIslSEILZbI4KIuK4abOB9g+cZUOQpqlNeJA2NlzKlHa7g5SKdruNMYZGs8G6ClDKJkaPxlPSDC4/PyTXmr29XforHRjDyoqyeyQ1mzQaDeK4QZbltFtN2m0LbYzWBKGNSmw2G8SBrwxg7eOJ1kRRRJqmzvVvVyjvFQ0DO6Raa1sfBpt47smaTqn1nzHGKs2OgkARB4o4CgikLFnOQ4iXY7BvexNnvTnOaFMJIjstvQQJ//KwemnhMRzsJ/yrf/Wb3HPpIr3VFq1WwK6AWEk+/p/+kG/45m9ASmXrokQxWttAqiAIyIxmOpsxzzKS1MbJRFGEwbhYEOEkYkAYRcwODpBhQBBbc5utv9ghjg/Z2trk8PCAILiAFJIoiuh2+xhXQkPrHCENQiqMtkFWvV7fZkmFMQcHI5SUaGNotdq0Wl20NqRMiRsN1tbXaTQbNFttOu02oVL0ex2aoVWgpZLWN6AkUaiKcFkhJTYI3NBoNOz7ZxlK2TJ7URSBMUVRWbRBuV08AHeurwhW2ly8k8l7YwOliMOQUErn6HlJPHaEqjK7Vmavau7zy8ACm9lAxM+HlaaQ7i9PNxgDn/zkZxlPUu574F7m6YgrV15gf2+XQIU8++SY7Ou/ltFwxGa/h9Y2GMrXqhfYAQuUjR8XAsbjMUopup0ON2/eZGtzA6kkg9GIeZoRSht5p7VB5zapotfvsbq2Drl1+c/mMzqtjmN07ezmofWAOG+IEIY4Eoheh/ks4/y5sxwOB9zc3sGYJsk85cb1bUKpWQ0CptMp/dUVRsMhK70erXaDRhwRByFxGBE3InSeIQOBkspxiCHXGqLIVldzCitAEITW1BlFGG3Iswyd50WbpZRFiIBnbB9e6yV7EJQhv3EY0ggCm5JZMQdWd8C+M3uUDFm/RhROpOU4v1oD3p1fubZI8r5LOjHDL7p9JeVk1Atrz8kcUG4jcWMZJjewsz8gbMbs7O0wnR4yODxkrd/HaIMObP32dqfLdDojD0JA0Go1mUynhdKVJAm5hiiKmGAYj4bkmY1jnydzoiC02Hk2x0hJnGnLyEhbymIyZnV1jdXVVZqNJiv9NYIwQAiFFAbtCg9ZRqkU7Rd2pQhURJJrHn3kEe655x6eeeZZdnZ32drc5HB/hzzTYKARNezWkI0G3UaTfqdDIG1BI4EtrmS3g8/xpcQFgkTPkVIRBhFSKBqxsNvFK+X0KgEOwvgMLhUE5FoTRiHeb2TH0+71LVyMkUDYiRMolDP3+aE1dS6sjXf5tR5sYI58u7OSa7AWJFP+4P7xVc78Jmf1fNdXVGkVlb/6oJ/kyir5l8zRRjFNZ7R6MVHcIM1GNo4cwf7+LivrayRZxv7BAa2tDZrNJpnWLqzV7qXkPYdZlpGlCWkyZzQcEMexxfrzOWEUMZyMmSUJQinW12MajaZLVs7pr/RoNiPOnd2k3WrbjB+/5COQCwESdqDsuytp81173S6NKGYl6RJKwQvNkGarzTNPPUO73abT6aDTzBY9jUI6rZaVqFJa2EIdZlR7K89NMeGUUyhzpV1yvUS7Yk2+oGmWZXayyLLMtMfjNikfpLIrYqwUkZJ1e7s5wtanGNlKH53gJl5JNVVFtEjkFvjdKovNiotp+yrF0rxUstYk2+gXruxw5eo2K2t9rl55jvX1ddqtJtdeuIyMQl54/gVevPw895zdoNVqFS5urU3BkHluU/i8hQIosK4QgiRJMQjmiU2NO3v2LEEQEIQR82RCp91FqoBWq0mWpgSB3as0UgopPLSwduu8WM0MCEnu4k4EAokmjkKyNKXTanJma4vVtTVWun1G41ERCNbttOh22sRRUFM2PfywoQe2r+z3nFznRKENHQ5UgESQaVs70lfuFS4dzyu6udZFHxSTQUqUh4HS7gQYOcZ/rVJVjhvhoCi8Ogxf7Epq7OeTBYYtLj0GjESjEWFAu9fl2u6LPPDA/cymIyaTEf3NdQ53tgFIZ7YC2GQyodENkUoSqoAsswkLWZYRBIr5PGEwGLC7u0uWZXR6fSazhDiOmc7mzGcJjUajqDKWJCmDwYA4ijFG02pEbKyv0WnbisFhYHe78BhWm7LMSO50mQyb5pblBiUFWa6LSsONZkwQ2d0+ut02QgiazSatZsOuTkKggqD47KksK24ZPssyjNYMh0PWVldtcoaQCC2ZzWa1TH8orTN5nhcrhQ2vFUhjJ4WSksglsyBK1PJy8r0Q1aKrtyFTrpjuwiOn2C1CfckOmwRiXo3wYGMWUNpd9pDFiQotsGECeYoQhlvbt1jp92h3mrbWSqPFzt6uw9BOcmUZ02SK1jlhGHJweMh0Pmc0GnP9+nVrqotjBoMRKlDMk5TpbF40NkkSJpMJ83lKGMYMBwPWVvus9Xp0220ix+yBUoUtHARGi+LdA5e6JoWNJARXNTez2f3GGMIoQANZmjEcDul2+zQaDcJAYXKNNjZ5usrwXifxzJplGbPZnNF4TJoktJpN2q02GJumVz3fT44oigoLj18BfPaScgp+IKzQECcwaZ+u+ly56+Jpc08X8Xv1qMEUeN4UK+6Jb333DK8pM8tfSpSkwSqse3sTDocDGzQ1m7C1tcVocMje/g6xUkz0jGanTX91lU67UwxuEATkOehkTrPZtAqYCpjP7UowGo2Im9az6tP+nnvmso1lceU6bBBXTKfttlwPFGGorOMlUCjpSzt7jd2aGUwlx0xIm4omgEyL4nNuNBJrYQmlotNs0Wk2LQYXEhkFGGM9nqpQhi20AVNjWK01k8nESuUowmhty/C5dqVpWtRmr9rec2NhUuD0hECpQrqHFWtMnW9eG9jGJ4mUCqpwVcuo2DdfYUhTeLkKOs5DsOy60n/mN53Ncs1zL1xhfWOFwWHKlSvP02rFBJFCCYlJM3rtFp1em8FwSJrlBEGIxA6mdgpaEIaoPCOObTJGo9Eg14bhaEwYxuS54dq1Wwgp6HQ7rKyuMplOCJWkEQfozLDS77Gy0qcRRdZqgkC5Dj9SWU2WBUAttLDKc6QkmYREOnytNVrbaMQy2tGWu5ASclu4y9q8XT9JKcm1m1gYstyW5whUQLPRoBE3UMoOvkwNGE0jjsBou2shhul86syNijhqECnrkItUQKgUcWCrslEZk2UjWOzCXdUlb88iR++B87ks8MMiFXxVgVflji2l8mrcD9aJpnnZNzUTCx98qu3tm1+no2fYAUtzu7doux0hTJ9bUeQybSLSJGMw2HNl7uYMRkOSNKOhQlQQkGV2Z2iDJMs1w+HYKagWrlgFLWA6nSGlAhdGnGvNweEBzWaTfr9LqARbW2fp93s045g4kIRSFN3oK9nern+kEta8JywjCwkBksQVZlU0XFi1DVXA7WotBEghCxt0dXsXBCRpSpZnSCWJ4wZbm3Y/KoxGC00YBnSkC4WObAx8mucMxgmT6YRe19a0V1ISKkUUBDRCZU3CeGkpivc47v1ON9qVa6s2+cr9bvekAsCIctP5Qso7GFPsS3DigpGf92hJ+xKTeerwJUymI9rtNoeHc8IgYnVjHWESDg4OONjbZzIaAzauJM28UyUkyTPCwHk8lSTTmhu3bjEYDJlOUxrNFq1Wizw3jMcJ81lCHIS011aIA8W5zU1WV/oEylksgqC+4/gxI3QcnFPOxGiMlT2hUmTSkOfarkoVSAglXPIBXB7KWGhjKQgC8kw7b6nF/MbgzLF21O2eqcoFX8He/j5KCOIoLGvQhx6zi2Olep3uzKaL71GeXnVWLRcaZhGr1yD/skTRBSfY/1PKdAgg13D91hAMjEdDms0G165NiONWoZycvXAeFQZMx2MODw9J0pQkTdEmJ9OG2TwBJFHUIEkzJvMpQkriRgzDIf2VFaSUTKc2dPjsubMINGsrfZphTL/dod1s0ggD51a3zC5Oxg31d/KS0niF3EBgY8kDIUiznNTk1u6v60pgEATMZrOi5rp2x6XD7Gmakgfa6irCOpyqz1RKWX7RmigMWV3pu1ABa3r0k1lhmd0LxlLKL3+nRShyV2RKo8tSKOOx+jLmXbjAM7u17y+uPbenzxvDGyDToCXMc7tGKSnY3dtnPB5zzz33sLOzQ9xskps5K2tr3Ly5w/7+Pre2t1nr9dCZzfwHQa5z5q7Q0Ww+s9g8iuj2ejTiNtPpjCTJEFLQbLZoRAG9bpvN9TXWV1ZoNWICJd327cqWhahl6pzO0uDRqACQILF28UAJZC4QyjKs0cYyt5Pk3gbvzYfG+Rj8n5Jus988Lywy1eTrQiIaiKOY1ZUVjM5RSrhsKllMRv9mdzGvX0Y66ZMdc1eGwIdI6PzkT3t1GX5hZZMSkhSeu/w8w8mAyWif6XRKHIfM5zNWVnrM5mObQWQ05y9cQKkAqYJiO/kgtCEGgoAkywpPpRCCNLGmvFarV5jkNja6nD9jNwdb6bWIQoWQVmG0zhyb5SMxrjSzk9K1iPDiNU5EwuFNAYQuN1RqQSY1ubbwJ9faTnqlyr1QpUDIAKMNInD5pKGV/sp5Tv3q4M2X2t0nEFbSx0GA1tYr651NVYZfym7H8OARcHFKsb+4igi0kyn2oK6E/taa4ZYggV2Zqi9gV9GTt+FVZfhC4rk30UYzGWuUknT6MYf7GWfPnkNKwcpKHzCk22OGh0OMMWxunmHrzBn6/RUCGZBhENqm+k3nM2bJnPF0ynQ6dUujpNPukmtNkqU0o5het0vbxZl3W01azYhmMy7S/pSzlGjEUsfHqV4Wrwi6+7ggxlCCQpJJaav7KrfJcK5tMrrD8FmWAcrVXrF13cEVM1U20MFoOy2lUjaBBVNUBlMIkJIchRQSZax5dfG1BKJm41iOmqu/3+a1va1+8RqnrFeZ3m5eZgrLot1ZvfIQb/I1xm1qliOFsmODq0FpBMKcXGv9/GF4AbkRzJLEZvlMrO09zVIODg44f/4ce3u7ICX91RWiOEYFikazQRzHNlowT/CVDrTOmc2mHB4ckGRz5nPrrNrd3UXPZlw8d45+p8vq6iqtOLQJIa2GTVwWyuZtBoF1JEFtxI44ZF4GE7WQkhDL/GAZItOG3Jia1K7ubl3CFsh0hhEKo0A4OCSVIte580BWzL/KwSIpX46m3zWVriPPz+WGZfoOLSva73QPjdvkDGx4xyvtaX2pJAVkAuZZRhhImo2Ig/1Du0mZEEwmE1voM03QxtDr2XzSdruDznNbZlqnpDojzVImkzGTyYTpbEKuc0AwnliLztrKChfOnqUZx3TaHaIwIA5D622UilAGRCoguINV5m7NcsvoiKolBEL5knJu+Q9kwbhGW8ktHJSdJnYLGiEUPtrLaLd5gDbWkeXeTyJdqeuyaPWrTcIVPjX4mvHg2V5T+jNEVXVavAeuxqRd2zBYw8IpBPznUWk1MM9gnlplVSrBeDxmf/+A9fW1otKuCgJW19bI8txNgoR5ktCQgslswng+YTydcDgYMJ3ZamBCSZIkI0tzGo0GW+vrbKyv2XjzyDpn4jgkUgESQxRYR4zP7VlmhCtgozPn5dy96aJc9hd0AlOBFs4rZ/wuAYqKUioIpEJIBSYD7WzTwtqtwUp4WcHDp/GGHxdCcJp4+KPXUXhIvb+hwO7GF+1yELBYZJfoTJVxUKLihDohnSoevniwgWqOoz3BLy/HXV/KFoGtHjWe5gzHY7Z3biEQ3HPPPdy4fp3V1VVsOTfD7t4uQkj29/dsheBck8xnTE3OaDxgNJvaGupxTJpldLtd6/jpKoIgZGVllfVen167jUQQhiGGnCi0kYZBEBIq616v7xVdf+mq/uHC049KoiNLwJKhWHiAjwmx9/clM8pRlP5hRd/bePBABiiROwxsdyeR0ocUWLysjSY3AiVxHtVyQt/NXF1k9pMwWnmJBTKmUEx9K7zybc8pnW6G6j8Ldy3tZstN+8fSiRleC5bUJfFMLyrMcvzjjV+P0WRGcnA4ZzQeEkUKRorxcEg2T9jZ2UFFima7RRA2GAzG3HvxPm7cuIHOc4IQknTIfDoiyzIG4xFR1CBUIY3QxsE0Xd5ot9t19nVbBUBKgyRGCYWShigMCKLj10RhlpcILI453jTiZAxw5P7OauK/1f89Sp5NFBabk9paPojctcWGN+hcoySgcxtVKlwx0rto49J2LDSxxqSe3JY0VVO5AzAL9vaKoHGzv8D5pqL0A1lFofJ+EnWK1et0kKZmsD364DteWq6vZLlhb2+fWzdvMU9G7OzskGcZjVbTxodIic5z1tbW7B5D0pak6/d6hN5vj41AjIKIOIwIApfcHEV02x0ajQbtRpM4DKxEd9u3CGywV6ACG/q7ICWWdd/RLdNLWOIl/x0F/pHflz7pDsYheycp7W6KUtmIS7COJ58LIEVZZ90nk7zsAL7a0IqyXXmTY96g6vKqfDxi2lk45D1ggsoqeKf+qtPLguGP3Ze1RuUZWhjGU5uTev78WT77+GNkeUKz2eLhR97AbD5lOpva5IYsYzgY0O/2OHPmDOfOnKHbbkMekWaGJDcondNqNDEIuq02rWbDVsmNLFwJnWJatXJEgaQRRzZR+U7NXsKtRweXBdPeyydNl5KwiqDU1jklC/+DtH/Y+jVKKbeyCfCRlaLOjMtw+WkjYI/cw698uA0mC4Qi0Jpix49iTGrRmmW8e9n/xq2idVs9xeZmJ6NX3Q5vsArVcDKj1W5z9ZrdKW84HJLnhla7ZTNZsozBZIwK7a5y49GIr/var+X81jqBTskzSbPZYT2wxT+1NjTipoUycVS4420qnBten2zhwmJDKbldrXMfb3JSqVhjoleW3QvpBhThwNXgM1tpQJWbkr2U/dpPQEcUWqegehOpKc7xtncfFEaJ2xdjatyq5PvSGIMWoqbgnlawfF6sNElmi58mScJ0OsbonHarQeZS2JSUDA4OCcIAjSSMIi7ecw/rG+tEQQBZiggC4mYDEShawtikZhnQbDZqkkPKMm3NB1mFYUAUBMXxl2uVX7TqmMWDrwBZha8SaCYkWttwZSvZVcFQr/AUPLIqFBXGTHUFcKnjS7X+o+T7UGu/XtQvM/oV2hDhaDZMVZrZeGUhXRmIOz4+IsvnaJMipC1mNE9S8hzyNKcRBwwGh2xubTDPM86ePc+jjzxKuxGBzuyOcbgkCGPjT6Iospk8vtyEMcUWi0ZrkCWWbUbR7XdvNtV/3ZcTLPGLXeQ3dfPD4b3iBRNUlLnj71LvZ9w9Cr1D2xvpvIQzucnLxHPhUlEWEUclu2pZC06BElwrRa3bCg8qgLDeUv+rrJRX9/qPND5jzJI0pSHE7wCiK++htdNTxOng16ni4UXly5F9tZ0FppqHefQmGpBkme0QKQ1nzm7x5JOPk2U5mxtnGA6HDAaHCGFIkjnnLt3HV37ZV3LxwjliZWxorVAIaSw2D2OHU1VRgwUEUoHOXeWt0MaCR6Gt+1Lfk2t5Z9V2qVty1p06uWrLLmwvzo7ms4vuRuIWqQ5OsPhk7zJntYyvLyI3oXDoaD9hTvKw20yI48hD1uqEEe5e/jrlbpsbh8kXTq5a/SqmEXcfbGwR3ll1uiX09AkgL+EMT3mekWcJrXYTPU6KQkE2v3TGZDKl1bLlLN740MPce+EcYeAYxZhaGQpjBNV4cLBBaVI4M6SwFplGGNiw36MxYEtJnxy6n4peCSTtq6qBXfT9f76eDa/QuxxHHmZ5ksWmTCX8sl8qq8LxqtRSEoIivPo0dGKnbDWm49hzoMhGuf15GhU4J5A2NoO/1eLgYJ9cZxwcHCCE5NE3vZlHH3mEZhwgTF5LjoBSUfIlKIACswtRQppGGNKIIluA9RTcZqp/lfe/Uz/c9p53ed1yKq1OZQixnfzlto/HM8XL2ZZF9CdlGdJc+aloqz9WrHROr6727TLEZ1xxGv//047FqRn+pZFtftyIaDRtRn0QBJw9e5YwDInikCSZMhwOectb3sqXf+m7WWt3CUyGFBlCGBdTIoukZL/LNlDUTQzdXxxHtFtNmlGMApSxeweJO3C9EfU/uHupXB30l5MEtvZkNTsKKHQTy3SnCDJ5qWSqTG9Z1b97IdAXAuGMrPZzfRk6jteKsIPSLlnLCrsTncJKU7Xb1r46hdYUpqiyPJup4UCLHQ2BFMSxzVFtd1qMJwOarQbxOGIwzLjv0r285dFHacax3drFv4+xIcUes0u3mUFubPy4ctuyxIEiCJWNjxFOnaq0y9/rdm9aPbeIAVk8p3pkARcvi0dZituP11GPbRvu2VJYiSWFIjdZUenAS3hRccr4IZNe6z3lDL7j6RWs5tuolzCt549lJUG8HcYUfWk7vlgPDEW5FD8+tprgyV/mrkIL7N6ZorAY+GPFua5hi7EpRcO19ZB2ui2kuy6OI7r9DuPJiK31DTrtFiZPyYUBoRBCoa0pAuG8jMKZqpSSKIMN8VWSUFnpV3uyV/AXBmUZGbyCWT1w9JxFutM9F3WsI8v1ba735xfJ5MZu26ncMemsM97LWtzflFCzLHx9l6vObS6pvttt71zY4v0qQO3FC6hSGEZKC49wAlQKUVqBlLARoyekkwePGVNs9a1e4tbjSgmacYQ0bZIsYXN9ncFwQBgomnGD9f4KsTMdCqgsg5IgkOWASkGkBYGUNOOYwJm5iroleEn7cquJrw3yyroxefGGOs8xStXrM74WqILLqX5aWHmlL8fhijN700wxVf0K4b8LWy3ipHRyCe9vTmH6vSueF9iZGgcSEQVgMlb7PVZ7PVb7PW5tb3PvhYt0O+3a/T3erzmRECglaMexTbp2HXMXyvvLTkvt3C9ju7zCrqpxMlWQZfw3K1GFWxUsg50e0hxHi6Ww76zmVbi1vAs1/sZWlLarsodl9WXWGFvcSqiTS3e4C09rofLd3gAAHLVVlzgSJBopKDyeZzbWSVxd83araYuRJglBGNZ3qRCgdY40BqRzIhXPceXXXlUj3MnJNu3uYsqPI+9MM7l2IcKl/b3ocJ9EgpsEr4Lwd8DJwXBT+6WqyIJN1cu9IMOu3IWd3be9aresCD2H+jmp/eV0GL76Moszu/pticJWdW8LAUrYxA+hJMZI1vorZEaztrpKK46RwtZY0Q7OWCVVoR1OVVISR7agqpdlpopd70CnHfPjMHsxDBUYVb2qGsJS4NNTPvt25C0h2qUTSSFL8/AxbV8WVnMifcLDjyrz1T7WEzsWJ5cffx/7bj8b7D6MFdTgYI3N2hVLBYX36BeT+IR0Yob34QIlNDQl9wp/RvXlzNFlXdha3hpnPhMGlEDmhlBJpBFob1VBW9VYBPilUmtbq0UKYS093rF0Rxa/jaZ4EvICs9bh1Lh80XJVG4LFZ75cC5DwVgO72im3BY/OhRUEotxEoGC2IoCogqZPooEXs6csA1IVL37EPEv4QLbCBOkAixEu7kcYMjeBCp+qBoEszZhQ8gr+vIryDuQYTpOp+4oEj91pxS6loiheoeYpFcLWQs/zAtKUO80Ju8NcGDppYGqD9/K0/2QS447nvQrIygbKAVKQzlMwtsrZUiEgWGoSLCxIlfOOo4KJuZM342j/LEriakVmMGROU60F9Zk6nHmpq+NdYPhyRp3GtFXElFSsJkL4shFlRr3fSidLSwa3f4Gt/66s6dHOeq+Ulfd7uWhZPufi8VfCoXRaEth6luQCpCu/rTWmapYtVZylzHzSui7lumuskaCQxHVWNsWq5/G6P7HE3wJQtVJ/wgW+lXcqLPAV2FT+dnesf/e7+InbM/1x1sCqdFeUydDCmSC9E8tG+oFxs15KaTfrFYZGEBRz3UdWv9LkB+61wOSenGAn8EoethKzUgajPRy0dMdF6w6v5VMYvW7grXYe2S7e31B6esuS16ZyXrm6FzZIQVkYtarwFYfqQXd3w/IvO6QpZvcJzq2WkBNSFCGf5DZQVGuNVDbC0jh3q928y4mqIkf2laPXEoMfR1LapBbjBIPfQLlKi8J92e/ll+WrW/U8z8D28/HnV59QKNLOklZ45J0uVEaWOvMyC2HKph52XE86Odk4ncrx5GebdrDGTvDj1knPi+XvBeam1HVtRJ8AKQvprk1KltvcTBWUUEJQehatZBEIp5CV+uPxU+1uSlWU7a5bZZbRS8WXS2+w0ORlklrY8FC7SqpyczefzgcaI0yl/+vht1U7xGJjfKiuP0/i/By3edlFoVdAHscKxaYGlbNs3XdjUxatuaJwnlUWhWJjM2+2PG2fn17CCz/rjKvdTWEa9TUU/ds5FWThcjdRtEEZQS6MLRjqNINcZ+TG7oQbqMh6d4WtNRWFEWEU4xN4a0kHd9BdTyOnj0yMI8vw8Q+oSbtTjIbwFpXiVsufdEQyG1uBGawH3Gg786X0KX82EMQW9KgKqaP8Xf1ewv7yB1H8CefcK2FeOQ6mLnWFsNXUoBYCYMAGxON5xrikD2dWFaU0r+oClcga9zxxqn4+hadV1PI7F/Vl4Rrpg33sZLbdU854sXhF8cICv0FA2WFKOcnlfg8CW/fcbatkvXE1bckPyPGK5ctRXKi2xL9MTqTFILOKtlMT65qjUr5MhHaOqEK6l0yyaJdfuph46XXM7/UG315xtM93zOsnhrvwuKt8u4zwu/M56FTAVr+y+xXd6QSvRH340s5sGVUjispWdpkzNakgEUVH+07M3RsVZic3cra4fwU6CFE4nKQoFR9fGbgInlzSc3dOLzw9LUq+V8IqtPicxaOeTbRZEBzG5+9ClqVuKx2JUKJ0zpiyQlfhrFkOs48eqL386cwD2jiGdbB1weFayLyqkPMCW1NnZuPOK7e+WT7+d6JTSXhZCBtvobG/5RXJWmwEQHle9S0LxANFcJhPfSu53tX+XtKOO1lKXh55e8y9TSmd5AmY/dic0ZPa+TEFZi2PLXtQ/Vm+No1lNjBIcm0IpJe4i+059g1qk7sY1/J/R9p2ZKXy5lxBzf7v+b26wurinU0RAOhAQ8W0iVv0TI0XT0onZ3itMaZS9EYc11FWKthQhKp2Y1PtilWgaGzFfyZcqKeQdo+kI/hfFvdf+OEYcoFTlMu7baGfjiVurkGIpWRqS759h8q1i51/bP/Un3anY/Y5x7evxLKWUWSFSfM8x0iBEupIDcYSZvsVuxRUfjxcoiDeT7r0fRaQlx9NvfBz7V/PtJU+8kzu2+mztYwR5eT1ippxG1LXHFcno1MorWWTvZKiS1aligzlYnEj/5am4qIQwiq9RqCMAaFJpUELCSIEYWPfNaCFtoELAoxeUmnqiBRcYAqvWyw4j0TFrCnKZh2h6rQtIcYdunmZZF6iC9+e8U8ykLZ1SoUEjQZ5mqGFIMlyhIAAuzO4MZBhY8k9bPDKYjVRoyqCqs8wRi+savWJ7wWYVTY50pHSLEBRA0ZWwhG8zR6D8SEGujLJikZTKynuFemTMv3Jk7iFrCw/pXXG/Wh30640oMiC8u3F6t/VLJzc5ycaSuVU6MJUqfMcJYPihfLcBo3lNS4xlXcVC8zp2+BOKKKmRPkT1U5b7LZSK1n8ZXku+B06vbhNRTE8KZa+zcpjXB2aRhyTBxFZkhQxR7aCgOUwYzTIiqWkwjTLn1eBSQsGiMWxLc4/emnxrOoKISgxvj1gJ5/PbjPGmSD9quyZ3FUa89aZE4qfgk7M8Hnuwn9EOVA+/MUq5LJYGLU3CQj/cm6ZEyWjFXFPUKko6xXW8kUlYLSdTgfDIZ1Wu7bp7hJZVOJe/3wvfRZRgWO+qqJbhE1QNNV+X3iQrojnY+H8spVo4ZpTK14VPaK4pYOPkQpIdEaKcBsi277MtUZIW2veb55Q60NTfV9T5DssvoyuzdDlDS8sLBXsb1y7F8v7mcXvlXEylb4q7lM5R1R4Rp+i1t7JrTQarNnQBuf7GoHeb2QFf1UTrxe5Rwgbw17cEFSF4XV1Jvup6600xm60e/PWLdK1dXrdHoFSTqCYojMXGa8eJFV9dkXCO9woFs6rJXVVJqfH8WJhZVkEKIt4H0ztHsatNqfldyiZyd/MW2MCg63ZIxRaaDJtrC6kNVJbc6XwEK6InbdvU7TUePS+8MyFd6lRxffi1hI7nkLUw8hvM7uPVFg4pjRgobtW/tWvjFnSALIYSPs+C1LTUMkPNkUoavme9RcoX8kvvaKYrcZtzqW1RkhDmmdEcYw2hsl8SrvVXlDjSsaXtaeJ4rFHbfCUHetXHe9NXrAKeP71UE2533ztlwpIOfJ2lU6s/aZPwfBV72W1P/0089LXJskItBHo3O6ukhmXC6wFudQEIgCXHC+krR8PJzA53uYE1y2WAbH9Z/us1Juqq6ifENV307pidqzg9MXv5kh/nFxsnFxpNaq0xQt8mXcQ1pcnXNUxPwD2XSoDbKAsk2wP+VQ8e6qLlTcCkRl0rknyDOO2SBdas9JrI2VIrnNmyYwgikCoQkL5Ds1rHWAQ5qgaBn5V8jPUW3QslQqWnUSqwr8Ga4otAjaNteCoyn2rRVoLv4P3URfNq4ApY9Cy0iHGVhQzWL2lNE/WAbJxGN0Y6/3MhUYqyBIbQCZzgyGBzCBQNrJSaoIgRAvLodpIlHDhIl4I3EG3OMJiulK/UggQqibQTWXdKJXaBf4QVmLarXsW1hmJPe4SXYTjF2GwBe1OSKez0jhoYvm+COGyL1qUubODUGSqUEzk+ozVbsnz17sZb6VVzsxtZdPOV5BI4jAm1yl5BmEYk2fGbuglLWaUQhS8ewTaHOMwWSZfC2ljdE2S5m6uCkRxP11ZdoXxE83gvcb+WuGcZ9bB5q/xK0s1D9VJvSJgxE5li6l9J4riWo9zfVyJEM4SJUOSfE42T5npjGYjRkQKkRu0ziB0e0kZjckzpIrIRYCROIfhUToKaBakM6XVzsOaEg3U8GB9BNyqYAWiAFGo2Ecmnaj0gams3Kdxh51iyxt95Malfdg5lCpeEm3sTg+Lbnifm1plwqrmHyjJKM0ZTIYYkyJkQp4H5FIgpCFLEoQ0tvhSniBEiBBu/1EnmBYzYGSl84v/V74XnV60AqQ15hW/55WsIUylPkplLKUWldldeZb/4Ja0sk98Vhh2UhiHnyttET6OogJfiv8LU8AZjY2pyY1mOE3YH4xJZxOG+7sIoej3OrTdzoUt0bbQMUuZDOxO5UEkmeucRjO2FjNuT9WYd9+iIhzAtVaZUkoXrFKjio3d1Yw3Fc/kUaRyFCaeVuk/hVmy/FtGsoqdfYOXSHZbL6bODL42YiAAKRhNZzxz+UXObq3Q7WfMs4RMaxoNxe7hAc1mk/X1VZL5lLbq2pBhp7ILbL6stRwJ1zZPbm1aeIdCori2GN/2ihs78y1eFHUVc8tiaYxyGpewqdY//kRtpbN0lhQfHGd/qzNW5lcx93MuIHUSPsk1xkWZNuMW48MDPv7xP+Xxzz3OxQvnOX/mDPdeuki7vcq5MxdRGCbDGTLOCLUhzxLiRuQU8jsnRR/RiXB2dW3f2QeY+RZ7mFI3h4rCBFlEcBowFSwP1ivvy2KLBWFzGjoxwyslWe4qtxlJiro00xWGq8ee1BMpbAyI21U7UBidEze6RI0V9g9nyGhKOk+Zjmd89nOf4OBgyLve9cVs7c0QaB68v00gbUfYUh3eYmOKVaS+SB8NTfBAxLfHnVVCWQHKDZfFmtXrytltCrgiHVQx5buaxfIhwiOa4n5au6hGU64CXtYWaNdVcNB+WdI4qKLtDh95TiCg3QxJO02+6O1v5Xu+69uRQrB9YxuTGyaJ5urNazz2iU/Q6bR4aPwAa2urbK52EcYyRb5sqKutX+JYAtyma6Vp01vwCht6wczOP1BM/upqa2p29tK4AD4vojBPuq48Kd1VAki1DDPCmb6Mt9NbhvbSWrhO8GQoJ4I/KisFUm1SdkCztYoxE1LTZPfwkDzLCVsrrEU9wriBUCGNyCq0gSxTAwvzZDUMotIjgiX9IyoMJbwU8t+rJ5aiuRqVWoyH8NjSlDNlgWGLK4THrpW+EWC8smf8ymCK38DDBjeFPSwUwm5R755jhNVtzq1eQj54CW0yAqm4sLmBMZC5OIIvfeeb0Ubbej8IIuXG8VjHQtl+97oVWAvSwZMiocf3lX+/AgbZe9QtltUecgLClL/pSrBC9frqWnESEuaENp3PDU0x+IXkFF5RAlH44mwv+DLVwlgFSSAKTIw/r0IGgxGazAjyXDBNNDIU6Nzg7fFGuDLY0jpQGqEgEsJhdHGCgbIkF56/mKd6NyG/C7x7smvu8JxF05wlWUhDT/lRXqmsomXx2DKMuJ6XfMQECDbE45i2LguP9lDMMrxEA5nRdiVSspDsPlzA6+dCWHNkORmE87Z606Wfxr6t7hyDjf23r8w7tk7W+ae0w5fK1m1zWR07FeG9XloWTV9ynQEjDFJquxW8AkEO5CilEMJ6uXJhoYMSyjHuK5/TWiq8dYVy8ZzTTpM7Ta7lk/goHDsiLQvMXD3/zq073ppyZzrqaPPHS0ApBC6WvPrMcgKVjF9/H99PHsN7yONXFy/xT0J3ndO6GFPh39cux37nNoOR1YlSgRlmAV4IQFs9QQmcu1uiXS1JKWzCd+BEg5JY5xQnl+x3Qye5tx/UZafejqGPk5q3JXOUhVUVNlSsOcV5Xggt6AWLVCiDJ2vJkqZVn1qGeOviN6/1lHjdP1cIWzYxy7TloyJLvAw18DZ4UwssExwrhZbQKaw0RzupVEYXzsVZ6W+3jxIlw0vpFRk3UMYFkJl6wkeBHY3rEL851ilo2WAvvtvxzLckUvNOz7ttv92FJC2s3f67hR9iYdCrt/YxTIVZeImQuFNbjl/RS+atr+Ci1G0qIKyolFbgMC+9y00tFmdcVZF12Z/lb1D6KE5Ap4Q0JY5ClA8+sqIUkh68M2nJHYtPPpbFwpMMpMGgQCsk2u2GLa1n8BWGLyenY6RK7fAr01az8NkYXZHeR59anC+8MDrtUyo3OIYKSFdRYoFiAzZnSSjuYc2M/lqBEBbnK1Xi/DJs2TOavV7XogPFaQT8SynTISjErbDwo+xMV1pbuLJ6lTZXL9eVme8dRxDYZVuIYgsUIQTGJ4S8BB4qE8xfHqoKlhJmLAzS8isB72Ivj55EWTZL7OO33ZDQ+LTo6qPr02KZc/Bo8+/U8U5Blk7aG+1W7aqD0T3X+DgbTWmqLJ8hpEBhQJcT2q727hlOoNrYG06lc7xidWmE9LNP37FBQoial9bb6+3LnR62vE6fH6p6kO0/oqLMHzeIBlw9SSkppPcRZdatDh5hFE7QmjHlznT6UnvH2Gn9Y71prljBvLVgAbcW9ltRlQBlQvLine+Uy/pK0J2UyjrMO93SUUrRl/+d7kZHuBtT7MId3DNLZq0XlSgZs7Tfl2SZvWyLcWEJ2niztyCvmC+1Wx6rVqCT0F1h+GW/GSEqrmRLJSPfRshXfrxd0vOryezVOJHjn3v7bi70m9uc5uGDV+SOPut4M+iJSRzF7He6pxc6p5kE/syaTd1bWLx8LoSdX70rAYhGIKU3N9YFTZFlV3kRGwUtyE+5+8VLZvhSUpf4VXiJXD3Pv1iVUQxHnDWFWxkfaPb5wzMnnWRHGaO0Ed/2/lSWfLPQN684HX1WLcb8pHepWOoK7WVhxfOhEErJ+mSrPcQUsm+51DZHLvF9bGHQy7whAmZxaxFTeMSkkrUtS0qVyC0/ooxkrP5phNVbjB18jQs4EqU31GO6V5PxF5O9T3Hlwvc7rQILSt0pn/bSqPq0coX18f93S1WJrIQvuiqPVE0QVfyL7es8z4sQc6lkAVu8xcauFiVnGavXkr0yGN5LXf84B9Jv8yyx8K1cAdwRNwvK+Jf6INQF7KvPFqeHUdXzb5+VsOzWyybaMv3gJB7aOz178fKC2QvperJ3L0ITYAEFVD2gVT5ZTOa2z7MQRRU29+Jsb9+uQYFFm9grwvC6pmT5hthvsnKs0FYXyFT+9dp3YYgtjhUd6G5TWzJ9jPl/YVabxTiWV/N5y0/g1Lq0cc6UelzOIvwtx9I/p/S22vEVwhspKhyzCIOE/+D/OXmDTx4eHHiFogQv3jRUKl+VNgivjJjaiyqPbcDt72QbW02pK1/hlQ0beK3RqwtpjqfFEIGTkI8yhYUJVSjvBq3LLem1rr9t6U0t71G1zSPcpCoELs47KxFGUyZY3p5OzPBBKMnS+uaCx0vzkuoMu4gbK+abY7LUj97jvzyq5gbc7vdXox13Y570zH5cBGp5nv+tfrya5OGdUP//9q4sOXIQhkok979wpiEf2jHGYLenkphXlcx03CwGGZ4WZMkspiZOSACpaGQoosXqjKQ9FIwLPFDMRkYg+6rSF45vEA+bs6PL4wH6b9FU2wnESwbQW01Qw0MR+t+cR31MLbZ7tLsc9WR2hQRNThv62LBincUm5nwHSTh4sBvhbhmhoBTiLQKKQK/m46OhSMornTXIdL/ISXNzBuSMGDm7qMjMggXG1uVTVqvQXHzTOKUpJnKUl6ba9jhbJnqeL7tRzbMm9E9Ph8LBkzeiXtnGVtRjgW8phzO13kdx9oVXlNZUCrxmqgziYPMsc58KQN6ka8u8sBTIrxdgHTbhyL7orvQomqUGmCqNYtLTWg9SQ4i7ZX8KSyVEV/jfpk0zODNTokciRCtQqx4fhoyA/OJpUEok1EbibMiZ5WuwbAfkkb2Bw9dIsoWBROrVFMAdk3O/TTkBPcVUj0qsZz4kdx73tDGzul/2qHYqPq666LxsTKOD48ISED77hbemYmLkEFoiqdjNaiOHiKw+swHymWX+lMZ8TgBwVuCZtuh7hLYXB1BAbPCh9I57/a8rrj8BZx1umyhUpjFCb3fjr4ocdG+t5MiJl6Qul8gU7Dih7/cILkZLloGV0dnf2SjjzajNEuzt84rwwp2wHe6KUhz392h5atarcT6oGQ4sQtIMI8ivzkGQyEnksrLuj/f51IuJmXCB3WIG8ZaKgQqAjhsnJAXIDFcIiYLbobyK8zm57ZBvhkxTSWMsrA8R1x+H1qDtK3ZXW/D+QZ80apNrsoAmMEs8RpLs6FYgasaAjSW5g7jIiwXM/paEd2O0u4ngZrTDHJKOg7pDBXz2YgSJsMQ6/0kXE+wHNpNRssu7wmKusos0SfQW7cTZBpLaTBFdfIxZOA38f/XGvlkAO3d2Lzq30FTw+MfrPnPtzY2ZLDYW5yMCeVAPVj/gFFdxTPKlf19ftHo7JZffvOmiNFH7XjjtYR3AWJj0vybMNHPRkl7zxjiWHxjT5x2b5byFpH21AOjDRH0wZQcApqmODlho/+dgo7//R8PWfjSsV15nxiyGGPsIyI/PzyA8Ym1xrZIsaYyOHfeT+CtgWchMh0YxJfAlcKawL9GTutmP3UOvN3ikpFp7ZumJg3Enr0e3rd4F9Sds2qmsRRWV0z++oe29ezRn3NXxtQaEktBU0mFQOb5pDkwr05oDffa5Hts9LGHTCE4rrSrEHQ2UODjHz0w3EB+ohfuxF/R1vj442OV7/fD5bBy9ySE963RXp9J0qEYNXtmMyEhvukgFOBNsVMRqrd2f+JFjXQlkCysq+J4qyW9NTfH21b7W2Mb0B88kWyU6a8MwWr3oVUlMhM3HKCn9d2gkSqivGR6uyj7RFTqur6syArxe2c27rOytXc/3T75E2oVU2M7+38awwFtOAlEoTFiF0BcAzVKAIvCwv2psnBFAW2mGEqIqa61evo2lTOUkodJnZrC/1dRmaC0S2n0P6lTgG8bXAi+1kiWBZD/SBx8PH/GOnmPnk3VRryPqC+/4KoA8MKpLGK2e0izK9dO7Cwu/BlNmyYWF344l8AuPwhL4hUdhCfzCo7AEfuFRWAK/8CgsgV94FJbALzwKS+AXHoVvvy6K7NVrbLwAAAAASUVORK5CYII=\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "benchmark_tftrt('resnet50_saved_model_TFTRT_FP32')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4nKljmMORpM7", + "outputId": "7c3e950e-b370-4403-dccb-363ffa578449" + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Step 0: 18.1ms\n", + "Step 50: 18.7ms\n", + "Step 100: 18.7ms\n", + "Step 150: 18.6ms\n", + "Step 200: 18.6ms\n", + "Step 250: 18.5ms\n", + "Step 300: 18.6ms\n", + "Step 350: 18.5ms\n", + "Step 400: 18.5ms\n", + "Step 450: 18.3ms\n", + "Step 500: 18.3ms\n", + "Step 550: 18.3ms\n", + "Step 600: 18.2ms\n", + "Step 650: 18.1ms\n", + "Step 700: 18.1ms\n", + "Step 750: 18.0ms\n", + "Step 800: 18.1ms\n", + "Step 850: 18.0ms\n", + "Step 900: 18.0ms\n", + "Step 950: 18.0ms\n", + "Throughput: 437 images/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# TF-TRT FP16 model" + ], + "metadata": { + "id": "qVm47AseSGn3" + } + }, + { + "cell_type": "code", + "source": [ + "print('Converting to TF-TRT FP16...')\n", + "\n", + "converter = trt.TrtGraphConverterV2(input_saved_model_dir='resnet50_saved_model',\n", + " precision_mode=trt.TrtPrecisionMode.FP16,\n", + " max_workspace_size_bytes=8000000000)\n", + "converter.convert()\n", + "converter.save(output_saved_model_dir='resnet50_saved_model_TFTRT_FP16')\n", + "print('Done Converting to TF-TRT FP16')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1WDuKVqeR6Rd", + "outputId": "2c2383d4-5ead-4c0a-da31-90ea96e962e6" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Converting to TF-TRT FP16...\n", + "Done Converting to TF-TRT FP16\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "predict_tftrt('resnet50_saved_model_TFTRT_FP16')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "Y4CxWwVySNhY", + "outputId": "5320f697-75f3-4ca7-8b7a-8f21057c239d" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['serving_default']\n", + "{'output_0': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='output_0')}\n", + "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.55810547), ('n02109961', 'Eskimo_dog', 0.41503906), ('n02110063', 'malamute', 0.021484375)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "benchmark_tftrt('resnet50_saved_model_TFTRT_FP16')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0N3CgZbDSViW", + "outputId": "80fee9ed-b241-4880-af96-707690e14817" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Step 0: 6.8ms\n", + "Step 50: 6.6ms\n", + "Step 100: 6.3ms\n", + "Step 150: 6.3ms\n", + "Step 200: 6.8ms\n", + "Step 250: 6.5ms\n", + "Step 300: 6.7ms\n", + "Step 350: 7.4ms\n", + "Step 400: 4.6ms\n", + "Step 450: 4.1ms\n", + "Step 500: 4.8ms\n", + "Step 550: 4.8ms\n", + "Step 600: 4.7ms\n", + "Step 650: 4.7ms\n", + "Step 700: 4.8ms\n", + "Step 750: 4.8ms\n", + "Step 800: 4.7ms\n", + "Step 850: 4.8ms\n", + "Step 900: 4.7ms\n", + "Step 950: 4.8ms\n", + "Throughput: 1484 images/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# TF-TRT INT8 model" + ], + "metadata": { + "id": "x3Kfm5TFuJCV" + } + }, + { + "cell_type": "code", + "source": [ + "#import os\n", + "#os.kill(os.getpid(), 9)" + ], + "metadata": { + "id": "ubZrc9QFuNhJ" + }, + "execution_count": 29, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from __future__ import absolute_import, division, print_function, unicode_literals\n", + "import os\n", + "import time\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.python.compiler.tensorrt import trt_convert as trt\n", + "from tensorflow.python.saved_model import tag_constants\n", + "from tensorflow.keras.applications.resnet50 import ResNet50\n", + "from tensorflow.keras.preprocessing import image\n", + "from tensorflow.keras.applications.resnet50 import preprocess_input, decode_predictions" + ], + "metadata": { + "id": "u69ZQzN0uP14" + }, + "execution_count": 30, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "batch_size = 8\n", + "batched_input = np.zeros((batch_size, 224, 224, 3), dtype=np.float32)\n", + "\n", + "for i in range(batch_size):\n", + " img_path = './data/img%d.JPG' % (i % 3)\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " x = image.img_to_array(img)\n", + " x = np.expand_dims(x, axis=0)\n", + " x = preprocess_input(x)\n", + " batched_input[i, :] = x\n", + "batched_input = tf.constant(batched_input)\n", + "print('batched_input shape: ', batched_input.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kYBxxLDeuSey", + "outputId": "19542a7d-7051-4930-e82e-4f0a7b89ca45" + }, + "execution_count": 31, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "batched_input shape: (8, 224, 224, 3)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def calibration_input_fn():\n", + " yield (batched_input, )\n", + "\n", + "print('Converting to TF-TRT INT8...')\n", + "\n", + "converter = trt.TrtGraphConverterV2(input_saved_model_dir='resnet50_saved_model',\n", + " precision_mode=trt.TrtPrecisionMode.INT8,\n", + " max_workspace_size_bytes=8000000000)\n", + "\n", + "converter.convert(calibration_input_fn=calibration_input_fn)\n", + "converter.save(output_saved_model_dir='resnet50_saved_model_TFTRT_INT8')\n", + "print('Done Converting to TF-TRT INT8')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Td2OGfrkuWZc", + "outputId": "db1a2975-7ca0-491f-d6e8-5840995dee9f" + }, + "execution_count": 32, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Converting to TF-TRT INT8...\n", + "Done Converting to TF-TRT INT8\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def predict_tftrt(input_saved_model):\n", + " \"\"\"Runs prediction on a single image and shows the result.\n", + " input_saved_model (string): Name of the input model stored in the current dir\n", + " \"\"\"\n", + " img_path = './data/img0.JPG' # Siberian_husky\n", + " img = image.load_img(img_path, target_size=(224, 224))\n", + " x = image.img_to_array(img)\n", + " x = np.expand_dims(x, axis=0)\n", + " x = preprocess_input(x)\n", + " x = tf.constant(x)\n", + "\n", + " saved_model_loaded = tf.saved_model.load(input_saved_model, tags=[tag_constants.SERVING])\n", + " signature_keys = list(saved_model_loaded.signatures.keys())\n", + " print(signature_keys)\n", + "\n", + " infer = saved_model_loaded.signatures['serving_default']\n", + " print(infer.structured_outputs)\n", + "\n", + " labeling = infer(x)\n", + " preds = labeling['output_0'].numpy()\n", + " print('{} - Predicted: {}'.format(img_path, decode_predictions(preds, top=3)[0]))\n", + " plt.subplot(2,2,1)\n", + " plt.imshow(img);\n", + " plt.axis('off');\n", + " plt.title(decode_predictions(preds, top=3)[0][0][1])" + ], + "metadata": { + "id": "uCvpie3CuZVv" + }, + "execution_count": 33, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def benchmark_tftrt(input_saved_model):\n", + " saved_model_loaded = tf.saved_model.load(input_saved_model, tags=[tag_constants.SERVING])\n", + " infer = saved_model_loaded.signatures['serving_default']\n", + "\n", + " N_warmup_run = 50\n", + " N_run = 1000\n", + " elapsed_time = []\n", + "\n", + " for i in range(N_warmup_run):\n", + " labeling = infer(batched_input)\n", + "\n", + " for i in range(N_run):\n", + " start_time = time.time()\n", + " labeling = infer(batched_input)\n", + " #prob = labeling['probs'].numpy()\n", + " end_time = time.time()\n", + " elapsed_time = np.append(elapsed_time, end_time - start_time)\n", + " if i % 50 == 0:\n", + " print('Step {}: {:4.1f}ms'.format(i, (elapsed_time[-50:].mean()) * 1000))\n", + "\n", + " print('Throughput: {:.0f} images/s'.format(N_run * batch_size / elapsed_time.sum()))" + ], + "metadata": { + "id": "SmOXGcMGudzp" + }, + "execution_count": 34, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "predict_tftrt('resnet50_saved_model_TFTRT_INT8')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "WqpocxvFuggP", + "outputId": "d3e58b31-d60d-4ab9-8a46-eb15195a9ec9" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['serving_default']\n", + "{'output_0': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='output_0')}\n", + "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.5678711), ('n02109961', 'Eskimo_dog', 0.40893555), ('n02110063', 'malamute', 0.019729614)]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "benchmark_tftrt('resnet50_saved_model_TFTRT_INT8')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9IIEoSh9uiyw", + "outputId": "1eafd906-80cf-4c87-8ea8-bf1b3843297d" + }, + "execution_count": 36, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Step 0: 3.7ms\n", + "Step 50: 3.8ms\n", + "Step 100: 3.9ms\n", + "Step 150: 3.9ms\n", + "Step 200: 4.0ms\n", + "Step 250: 4.0ms\n", + "Step 300: 4.6ms\n", + "Step 350: 3.9ms\n", + "Step 400: 4.0ms\n", + "Step 450: 11.5ms\n", + "Step 500: 3.9ms\n", + "Step 550: 4.0ms\n", + "Step 600: 4.1ms\n", + "Step 650: 4.3ms\n", + "Step 700: 3.9ms\n", + "Step 750: 3.9ms\n", + "Step 800: 4.0ms\n", + "Step 850: 3.8ms\n", + "Step 900: 4.2ms\n", + "Step 950: 4.0ms\n", + "Throughput: 1823 images/s\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/TensorFlow/TensorFlowTensorRT/README.md.txt b/TensorFlow/TensorFlowTensorRT/README.md.txt new file mode 100644 index 000000000..3ead92e44 --- /dev/null +++ b/TensorFlow/TensorFlowTensorRT/README.md.txt @@ -0,0 +1,45 @@ +# TensorFlow-TensorRT (TF-TRT) Image Classification on Google Colab + +## Overview +The TensorFlow-TensorRT (TF-TRT) examples in the [official repository](https://github.com/tensorflow/tensorrt/tree/master/tftrt/benchmarking-python/image_classification) are outdated and no longer function correctly with newer TensorFlow versions. + +This README provides updated information and a working version of the Colab notebook for TF-TRT integration using TensorFlow 2.17.0. + +## Affected Notebooks +The following notebooks fail to run on TensorFlow 2.1+ due to TensorRT compatibility issues: + +- [Colab-TFv2-TF-TRT-inference-from-Keras-saved-model.ipynb](https://github.com/tensorflow/tensorrt/blob/master/tftrt/benchmarking-python/image_classification/Colab-TFv2-TF-TRT-inference-from-Keras-saved-model.ipynb) +- [NGC-TFv2-TF-TRT-inference-from-Keras-saved-model.ipynb](https://github.com/tensorflow/tensorrt/blob/master/tftrt/benchmarking-python/image_classification/NGC-TFv2-TF-TRT-inference-from-Keras-saved-model.ipynb) + +## Problem Description +These notebooks were originally designed for TensorFlow 2.0.0, but they fail with TensorFlow 2.1+ with the following error: + +``` +RuntimeError: TensorFlow has not been built with TensorRT support. +``` + +This issue has been discussed in the [NVIDIA Developer Forums](https://forums.developer.nvidia.com/t/runtimeerror-tensorflow-has-not-been-built-with-tensorrt-support/238124/9), but no official resolution has been provided. + +## Findings & Fix +- TF-TRT was tested on Google Colab with TensorFlow 2.17.0, along with compatible CUDA and TensorRT versions. +- It works correctly with TensorFlow 2.17.0 after some minor modifications. +- TensorFlow 2.18.0 does not support TensorRT, making 2.17.0 the latest version with full compatibility. + +### Fix for Newer TensorFlow Versions +For later TensorFlow versions that include TensorRT support, ensure that the correct TensorRT runtime libraries are installed. For example, in TensorFlow 2.17.0, the following command installs the required libraries: + +``` +sudo apt-get install -y libnvinfer8 libnvinfer-plugin8 +``` + +## Proposed Contribution +A working version of the Colab notebook has been created to successfully run TF-TRT on TensorFlow 2.17.0. This will assist developers and researchers in overcoming compatibility issues. + +## Next Steps +- Update the official documentation to reflect the correct TensorFlow, CUDA, and TensorRT versions that work together. +- Consider maintaining an up-to-date compatibility matrix for future versions. + +## References +- [TensorFlow-TensorRT Repository](https://github.com/tensorflow/tensorrt/tree/master/tftrt/benchmarking-python/image_classification) +- [NVIDIA Developer Forum Discussion](https://forums.developer.nvidia.com/t/runtimeerror-tensorflow-has-not-been-built-with-tensorrt-support/238124/9) +