tftrt/benchmarking-python/image_classification/NGC-TFv2-TF-TRT-inference-from-Keras-saved-model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/tensorflow/tensorrt/blob/r2.0/tftrt/examples/image_classification/TFv2-TF-TRT-inference-from-Keras-saved-model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dR1W9kv7IPhE"
   },
   "outputs": [],
   "source": [
    "# Copyright 2019 NVIDIA Corporation. All Rights Reserved.\n",
    "#\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "#     http://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License.\n",
    "# =============================================================================="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Yb3TdMZAkVNq"
   },
   "source": [
    "<img src=\"http://developer.download.nvidia.com/compute/machine-learning/frameworks/nvidia_logo.png\" style=\"width: 90px; float: right;\">\n",
    "\n",
    "# TF-TRT Inference from Keras Model with TensorFlow 2.0\n",
    "\n",
    "\n",
    "## Introduction\n",
    "The NVIDIA TensorRT is a C++ library that facilitates high performance inference on NVIDIA graphics processing units (GPUs). TensorRT takes a trained network, which consists of a network definition and a set of trained parameters, and produces a highly optimized runtime engine which performs inference for that network. \n",
    "\n",
    "TensorFlow™ integration with TensorRT™ (TF-TRT) optimizes and executes compatible subgraphs, allowing TensorFlow to execute the remaining graph. While you can still use TensorFlow's wide and flexible feature set, TensorRT will parse the model and apply optimizations to the portions of the graph wherever possible.\n",
    "\n",
    "In this notebook, we demonstrate the process of optimizing a ResNet-50 model with a TF-TRT.\n",
    "\n",
    "## Requirement\n",
    "\n",
    "### GPU\n",
    "\n",
    "This demo will work on any NVIDIA GPU with CUDA cores, though for improved FP16 and INT8 inference, a Volta, Turing, Ampere or newer generation GPU with Tensor cores is desired."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8Fg4x4aomCY4",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thu Mar 31 19:17:18 2022       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 470.57.02    Driver Version: 470.57.02    CUDA Version: 11.6     |\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  NVIDIA A40          On   | 00000000:01:00.0 Off |                    0 |\n",
      "|  0%   36C    P8    21W / 300W |      0MiB / 45634MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA A40          On   | 00000000:41:00.0 Off |                    0 |\n",
      "|  0%   36C    P8    22W / 300W |      0MiB / 45634MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   2  NVIDIA A40          On   | 00000000:81:00.0 Off |                    0 |\n",
      "|  0%   36C    P8    22W / 300W |      0MiB / 45634MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   3  NVIDIA A40          On   | 00000000:C1:00.0 Off |                    0 |\n",
      "|  0%   36C    P8    22W / 300W |      0MiB / 45634MiB |      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": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LG4IBNn-2PWY"
   },
   "source": [
    "### Install Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pillow in /usr/local/lib/python3.8/dist-packages (9.0.1)\n",
      "Requirement already satisfied: matplotlib in /usr/local/lib/python3.8/dist-packages (3.5.0)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (4.31.1)\n",
      "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (21.3)\n",
      "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (0.11.0)\n",
      "Requirement already satisfied: setuptools-scm>=4 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (6.4.2)\n",
      "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (1.21.1)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (2.8.2)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (3.0.7)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib) (1.4.0)\n",
      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.7->matplotlib) (1.15.0)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.8/dist-packages (from setuptools-scm>=4->matplotlib) (59.4.0)\n",
      "Requirement already satisfied: tomli>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from setuptools-scm>=4->matplotlib) (2.0.1)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install pillow matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nWYufTjPCMgW"
   },
   "source": [
    "### Importing required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Yyzwxjlm37jx"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "v0mfnfqg3ned",
    "outputId": "11c043a0-b8e5-49e2-f907-5f1372c92a68",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow version:  2.8.0\n",
      "TensorRT version: \n",
      "ii  libnvinfer-bin                    8.2.3-1+cuda11.4                  amd64        TensorRT binaries\r\n",
      "ii  libnvinfer-dev                    8.2.3-1+cuda11.4                  amd64        TensorRT development libraries and headers\r\n",
      "ii  libnvinfer-plugin-dev             8.2.3-1+cuda11.4                  amd64        TensorRT plugin libraries and headers\r\n",
      "ii  libnvinfer-plugin8                8.2.3-1+cuda11.4                  amd64        TensorRT plugin library\r\n",
      "ii  libnvinfer8                       8.2.3-1+cuda11.4                  amd64        TensorRT runtime libraries\r\n"
     ]
    }
   ],
   "source": [
    " print(\"Tensorflow version: \", tf.version.VERSION)\n",
    "\n",
    "# check TensorRT version\n",
    "print(\"TensorRT version: \")\n",
    "!dpkg -l | grep nvinfer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9U8b2394CZRu"
   },
   "source": [
    "A successfull TensorRT installation looks like:\n",
    "\n",
    "```\n",
    "TensorRT version: \n",
    "ii  libnvinfer5   5.1.5-1+cuda10.1   amd64        TensorRT runtime libraries\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SeekwaXj4CbI"
   },
   "source": [
    "### Check Tensor core GPU\n",
    "The below code check whether a Tensor-core GPU is present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "VHLld1VNkVOa",
    "outputId": "a0d2b13c-fe62-476c-9589-190bdcfff233"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor Core GPU Present: True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:17:23.701113: I tensorflow/core/platform/cpu_feature_guard.cc:152] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE3 SSE4.1 SSE4.2 AVX\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-03-31 19:17:25.283578: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.284562: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.285309: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.286039: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.294916: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.295394: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.295867: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:25.296338: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "v-R2iN4akVOi"
   },
   "source": [
    "## Data\n",
    "We download several random images for testing from the Internet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tVJ2-8rokVOl",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: cannot create directory ‘./data’: File exists\n",
      "--2022-03-31 19:17:26--  https://d17fnq9dkz9hgj.cloudfront.net/breed-uploads/2018/08/siberian-husky-detail.jpg?bust=1535566590&width=630\n",
      "Resolving d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)... 18.65.227.127, 18.65.227.223, 18.65.227.37, ...\n",
      "Connecting to d17fnq9dkz9hgj.cloudfront.net (d17fnq9dkz9hgj.cloudfront.net)|18.65.227.127|: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.003s  \n",
      "\n",
      "2022-03-31 19:17:26 (7.46 MB/s) - ‘./data/img0.JPG’ saved [24112/24112]\n",
      "\n",
      "--2022-03-31 19:17:26--  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.02s   \n",
      "\n",
      "2022-03-31 19:17:27 (24.7 MB/s) - ‘./data/img1.JPG’ saved [452718/452718]\n",
      "\n",
      "--2022-03-31 19:17:27--  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",
      "Resolving www.artis.nl (www.artis.nl)... 94.75.225.20\n",
      "Connecting to www.artis.nl (www.artis.nl)|94.75.225.20|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 361413 (353K) [image/jpeg]\n",
      "Saving to: ‘./data/img2.JPG’\n",
      "\n",
      "./data/img2.JPG     100%[===================>] 352.94K   152KB/s    in 2.3s    \n",
      "\n",
      "2022-03-31 19:17:30 (152 KB/s) - ‘./data/img2.JPG’ saved [361413/361413]\n",
      "\n",
      "--2022-03-31 19:17:31--  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.18.201.107, 104.18.202.107, 2606:4700::6812:c96b, ...\n",
      "Connecting to www.familyhandyman.com (www.familyhandyman.com)|104.18.201.107|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 94328 (92K) [image/jpeg]\n",
      "Saving to: ‘./data/img3.JPG’\n",
      "\n",
      "./data/img3.JPG     100%[===================>]  92.12K  --.-KB/s    in 0.005s  \n",
      "\n",
      "2022-03-31 19:17:31 (18.1 MB/s) - ‘./data/img3.JPG’ saved [94328/94328]\n",
      "\n"
     ]
    }
   ],
   "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/img3.JPG \"https://www.familyhandyman.com/wp-content/uploads/2018/09/How-to-Avoid-Snakes-Slithering-Up-Your-Toilet-shutterstock_780480850.jpg\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 269
    },
    "colab_type": "code",
    "id": "F_9n-AR1kVOv",
    "outputId": "e0ead6dc-e761-404e-a030-f6d3057a57da"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing import image\n",
    "\n",
    "fig, axes = plt.subplots(nrows=2, ncols=2)\n",
    "\n",
    "for i in range(4):\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');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xeV4r2YTkVO1"
   },
   "source": [
    "## Model\n",
    "\n",
    "We next download and test a ResNet-50 pre-trained model from the Keras model zoo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "WwRBOikEkVO3",
    "outputId": "2d63bc46-8bac-492f-b519-9ae5f19176bc"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:17:32.048652: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:32.049153: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:32.049637: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:17:32.050111: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "model = ResNet50(weights='imagenet')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before proceeding, let's quick take a look at the predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 410
    },
    "colab_type": "code",
    "id": "lFKQPoLO_ikd",
    "outputId": "c0b93de8-c94b-4977-992e-c780e12a3d52"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:17:35.279115: I tensorflow/stream_executor/cuda/cuda_dnn.cc:379] Loaded cuDNN version 8303\n",
      "2022-03-31 19:17:36.772709: I tensorflow/stream_executor/cuda/cuda_blas.cc:1804] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.5571331), ('n02109961', 'Eskimo_dog', 0.41630116), ('n02110063', 'malamute', 0.021332687)]\n",
      "./data/img1.JPG - Predicted: [('n01820546', 'lorikeet', 0.301645), ('n01537544', 'indigo_bunting', 0.16954009), ('n01828970', 'bee_eater', 0.16138536)]\n",
      "./data/img2.JPG - Predicted: [('n02481823', 'chimpanzee', 0.5103813), ('n02480495', 'orangutan', 0.16043848), ('n02480855', 'gorilla', 0.1509965)]\n",
      "./data/img3.JPG - Predicted: [('n01729977', 'green_snake', 0.4083977), ('n03627232', 'knot', 0.09960673), ('n01749939', 'green_mamba', 0.06695716)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(4):\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",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 110
    },
    "colab_type": "code",
    "id": "WxlUF3rlkVPH",
    "outputId": "9f3864e7-f211-4c06-d2d2-585c1a477e34"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:17:50.289205: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: resnet50_saved_model/assets\n"
     ]
    }
   ],
   "source": [
    "# Save the entire model as a SavedModel.\n",
    "model.save('resnet50_saved_model') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 453
    },
    "colab_type": "code",
    "id": "RBu2RKs6kVPP",
    "outputId": "8e063261-7efb-47fd-fa6c-1bb5076d418c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\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['input_1'] tensor_info:\n",
      "        dtype: DT_FLOAT\n",
      "        shape: (-1, 224, 224, 3)\n",
      "        name: serving_default_input_1:0\n",
      "  The given SavedModel SignatureDef contains the following output(s):\n",
      "    outputs['predictions'] tensor_info:\n",
      "        dtype: DT_FLOAT\n",
      "        shape: (-1, 1000)\n",
      "        name: StatefulPartitionedCall:0\n",
      "  Method name is: tensorflow/serving/predict\n",
      "\n",
      "Concrete Functions:\n",
      "  Function Name: '__call__'\n",
      "    Option #1\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #2\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #3\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #4\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "\n",
      "  Function Name: '_default_save_signature'\n",
      "    Option #1\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "\n",
      "  Function Name: 'call_and_return_all_conditional_losses'\n",
      "    Option #1\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #2\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #3\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #4\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n"
     ]
    }
   ],
   "source": [
    "!saved_model_cli show --all --dir resnet50_saved_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XrL3FEcdkVPA"
   },
   "source": [
    "TF-TRT takes input as aTensorFlow saved model, therefore, we re-export the Keras model as a TF saved model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qBQwBvlNm-J8"
   },
   "source": [
    "### Benchmarking Inference with native TF2.0 saved model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8zLN0GMCkVPe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.models.load_model('resnet50_saved_model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "CGc-dC6DvwRP",
    "outputId": "e0a22e05-f4fe-47b6-93e8-2b806bf7098a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batched_input shape:  (8, 224, 224, 3)\n"
     ]
    }
   ],
   "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 % 4)\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rFBV6hQR7N3z"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0: 53.9ms\n",
      "Step 50: 54.3ms\n",
      "Step 100: 54.4ms\n",
      "Step 150: 53.6ms\n",
      "Step 200: 53.5ms\n",
      "Step 250: 53.8ms\n",
      "Step 300: 53.5ms\n",
      "Step 350: 53.7ms\n",
      "Step 400: 53.6ms\n",
      "Step 450: 60.1ms\n",
      "Step 500: 55.4ms\n",
      "Step 550: 55.1ms\n",
      "Step 600: 54.8ms\n",
      "Step 650: 54.7ms\n",
      "Step 700: 54.5ms\n",
      "Step 750: 54.2ms\n",
      "Step 800: 53.6ms\n",
      "Step 850: 53.7ms\n",
      "Step 900: 53.9ms\n",
      "Step 950: 54.0ms\n",
      "Throughput: 147 images/s\n"
     ]
    }
   ],
   "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 = model.predict(batched_input)\n",
    "\n",
    "for i in range(N_run):\n",
    "  start_time = time.time()\n",
    "  preds = model.predict(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()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vC_RN0BAkVPy"
   },
   "source": [
    "### TF-TRT FP32 model\n",
    "\n",
    "We first convert the TF native FP32 model to a TF-TRT FP32 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 126
    },
    "colab_type": "code",
    "id": "0eLImSJ-kVPz",
    "outputId": "e2c353c7-8e4b-49aa-ab97-f4d82797d4d8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting to TF-TRT FP32...\n",
      "INFO:tensorflow:Linked TensorRT version: (8, 2, 3)\n",
      "INFO:tensorflow:Loaded TensorRT version: (8, 2, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:19:13.215168: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2022-03-31 19:19:13.215301: I tensorflow/core/grappler/clusters/single_machine.cc:358] Starting new session\n",
      "2022-03-31 19:19:13.266148: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:13.266661: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:13.267135: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:13.267607: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:13.306703: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1191] Optimization results for grappler item: graph_to_optimize\n",
      "  function_optimizer: Graph size after: 1202 nodes (878), 1857 edges (1533), time = 21.014ms.\n",
      "  function_optimizer: function_optimizer did nothing. time = 0.004ms.\n",
      "\n",
      "2022-03-31 19:19:14.924270: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2022-03-31 19:19:14.924388: I tensorflow/core/grappler/clusters/single_machine.cc:358] Starting new session\n",
      "2022-03-31 19:19:14.932456: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:14.932935: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:14.933404: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:14.933871: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:19:15.199938: W tensorflow/compiler/tf2tensorrt/convert/trt_optimization_pass.cc:192] Calibration with FP32 or FP16 is not implemented. Falling back to use_calibration = False.Note that the default value of use_calibration is True.\n",
      "2022-03-31 19:19:15.200029: I tensorflow/compiler/tf2tensorrt/convert/trt_optimization_pass.cc:211] [TF-TRT] not using explicit QDQ mode\n",
      "2022-03-31 19:19:15.363566: W tensorflow/compiler/tf2tensorrt/segment/segment.cc:954] \n",
      "\n",
      "################################################################################\n",
      "TensorRT unsupported/non-converted OP Report:\n",
      "\t- NoOp -> 2x\n",
      "\t- Identity -> 1x\n",
      "\t- Placeholder -> 1x\n",
      "--------------------------------------------------------------------------------\n",
      "\t- Total nonconverted OPs: 4\n",
      "\t- Total nonconverted OP Types: 3\n",
      "For more information see https://docs.nvidia.com/deeplearning/frameworks/tf-trt-user-guide/index.html#supported-ops.\n",
      "################################################################################\n",
      "\n",
      "2022-03-31 19:19:15.385464: W tensorflow/compiler/tf2tensorrt/segment/segment.cc:1281] The environment variable TF_TRT_MAX_ALLOWED_ENGINES=20 has no effect since there are only 1 TRT Engines with  at least minimum_segment_size=3 nodes.\n",
      "2022-03-31 19:19:15.388155: I tensorflow/compiler/tf2tensorrt/convert/convert_graph.cc:795] Number of TensorRT candidate segments: 1\n",
      "2022-03-31 19:19:15.394285: I tensorflow/compiler/tf2tensorrt/convert/convert_graph.cc:909] Replaced segment 0 consisting of 500 nodes by TRTEngineOp_0_0.\n",
      "2022-03-31 19:19:15.507510: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1191] Optimization results for grappler item: tf_graph\n",
      "  model_pruner: Graph size after: 880 nodes (-322), 1535 edges (-322), time = 6.713ms.\n",
      "  debug_stripper: debug_stripper did nothing. time = 0.073ms.\n",
      "  layout: Graph size after: 884 nodes (4), 1539 edges (4), time = 33.663ms.\n",
      "  dependency_optimizer: Graph size after: 560 nodes (-324), 575 edges (-964), time = 11.753ms.\n",
      "  constant_folding: Graph size after: 558 nodes (-2), 573 edges (-2), time = 17.339ms.\n",
      "  common_subgraph_elimination: Graph size after: 508 nodes (-50), 573 edges (0), time = 48.204ms.\n",
      "  TensorRTOptimizer: Graph size after: 9 nodes (-499), 2 edges (-571), time = 203.31ms.\n",
      "  constant_folding: Graph size after: 3 nodes (-6), 2 edges (0), time = 0.818ms.\n",
      "Optimization results for grappler item: TRTEngineOp_0_0_native_segment\n",
      "  model_pruner: Graph size after: 450 nodes (-52), 469 edges (-52), time = 3.293ms.\n",
      "  debug_stripper: debug_stripper did nothing. time = 0.032ms.\n",
      "  layout: Graph size after: 450 nodes (0), 469 edges (0), time = 9.911ms.\n",
      "  dependency_optimizer: Graph size after: 450 nodes (0), 469 edges (0), time = 3.693ms.\n",
      "  constant_folding: Graph size after: 450 nodes (0), 469 edges (0), time = 9.606ms.\n",
      "  common_subgraph_elimination: Graph size after: 450 nodes (0), 469 edges (0), time = 46.168ms.\n",
      "  TensorRTOptimizer: Graph size after: 450 nodes (0), 469 edges (0), time = 0.806ms.\n",
      "  constant_folding: Graph size after: 450 nodes (0), 469 edges (0), time = 10.418ms.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Could not find TRTEngineOp_0_0 in TF-TRT cache. This can happen if build() is not called, which means TensorRT engines will be built and cached at runtime.\n",
      "INFO:tensorflow:Assets written to: resnet50_saved_model_TFTRT_FP32/assets\n",
      "Done Converting to TF-TRT FP32\n"
     ]
    }
   ],
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 453
    },
    "colab_type": "code",
    "id": "dlue_3npkVQC",
    "outputId": "4dd6a366-fe9a-43c8-aad0-dd357bba41bb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\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['input_1'] tensor_info:\n",
      "        dtype: DT_FLOAT\n",
      "        shape: (-1, 224, 224, 3)\n",
      "        name: serving_default_input_1:0\n",
      "  The given SavedModel SignatureDef contains the following output(s):\n",
      "    outputs['predictions'] tensor_info:\n",
      "        dtype: DT_FLOAT\n",
      "        shape: (-1, 1000)\n",
      "        name: PartitionedCall:0\n",
      "  Method name is: tensorflow/serving/predict\n",
      "\n",
      "Concrete Functions:\n",
      "  Function Name: '__call__'\n",
      "    Option #1\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #2\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #3\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #4\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "\n",
      "  Function Name: '_default_save_signature'\n",
      "    Option #1\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "\n",
      "  Function Name: 'call_and_return_all_conditional_losses'\n",
      "    Option #1\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #2\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          input_1: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='input_1')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #3\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: True\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n",
      "    Option #4\n",
      "      Callable with:\n",
      "        Argument #1\n",
      "          inputs: TensorSpec(shape=(None, 224, 224, 3), dtype=tf.float32, name='inputs')\n",
      "        Argument #2\n",
      "          DType: bool\n",
      "          Value: False\n",
      "        Argument #3\n",
      "          DType: NoneType\n",
      "          Value: None\n"
     ]
    }
   ],
   "source": [
    "!saved_model_cli show --all --dir resnet50_saved_model_TFTRT_FP32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before proceeding, let's write a couple of utility functions to use the model for prediction and benchmarking purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rf97K_rxvwRm"
   },
   "outputs": [],
   "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['predictions'].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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "z9b5j6jMvwRt"
   },
   "outputs": [],
   "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()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 238
    },
    "colab_type": "code",
    "id": "pRK0pRE-snvb",
    "outputId": "1f7ab6c1-dbfa-4e3e-a21d-df9975c70455"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['serving_default']\n",
      "{'predictions': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='predictions')}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:19:46.675549: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n",
      "2022-03-31 19:19:46.682518: I tensorflow/compiler/tf2tensorrt/common/utils.cc:100] Linked TensorRT version: 8.2.3\n",
      "2022-03-31 19:19:46.682690: I tensorflow/compiler/tf2tensorrt/common/utils.cc:102] Loaded TensorRT version: 8.2.3\n",
      "2022-03-31 19:19:47.748477: I tensorflow/compiler/tf2tensorrt/convert/convert_nodes.cc:1372] [TF-TRT] Sparse compute capability is enabled.\n",
      "2022-03-31 19:19:47.750009: W tensorflow/compiler/tf2tensorrt/utils/trt_logger.cc:36] TF-TRT Warning: DefaultLogger It is suggested to disable layer timing cache while using AlgorithmSelector. Please refer to the developer guide in https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#builder-layer-timing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.5569863), ('n02109961', 'Eskimo_dog', 0.41644078), ('n02110063', 'malamute', 0.021332804)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "predict_tftrt('resnet50_saved_model_TFTRT_FP32')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Vd2DoGUp8ivj"
   },
   "source": [
    "Next, we load and test the TF-TRT FP32 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ai6bxNcNszHc"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:20:15.711311: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n",
      "2022-03-31 19:20:16.363793: W tensorflow/compiler/tf2tensorrt/utils/trt_logger.cc:36] TF-TRT Warning: DefaultLogger It is suggested to disable layer timing cache while using AlgorithmSelector. Please refer to the developer guide in https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#builder-layer-timing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0:  4.0ms\n",
      "Step 50:  4.0ms\n",
      "Step 100:  4.0ms\n",
      "Step 150:  4.0ms\n",
      "Step 200:  4.0ms\n",
      "Step 250:  4.0ms\n",
      "Step 300:  4.0ms\n",
      "Step 350:  4.0ms\n",
      "Step 400:  4.0ms\n",
      "Step 450:  4.0ms\n",
      "Step 500:  4.0ms\n",
      "Step 550:  4.0ms\n",
      "Step 600:  4.0ms\n",
      "Step 650:  4.0ms\n",
      "Step 700:  4.0ms\n",
      "Step 750:  4.0ms\n",
      "Step 800:  4.0ms\n",
      "Step 850:  4.0ms\n",
      "Step 900:  4.0ms\n",
      "Step 950:  4.0ms\n",
      "Throughput: 1985 images/s\n"
     ]
    }
   ],
   "source": [
    "benchmark_tftrt('resnet50_saved_model_TFTRT_FP32')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G2F8t6cPkVQS"
   },
   "source": [
    "### TF-TRT FP16 model\n",
    "We next convert the native TF FP32 saved model to TF-TRT FP16 model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 126
    },
    "colab_type": "code",
    "id": "0ia_AlSDkVQT",
    "outputId": "d29eb6de-101b-4b9a-8ebf-4880a2e469bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting to TF-TRT FP16...\n",
      "INFO:tensorflow:Linked TensorRT version: (8, 2, 3)\n",
      "INFO:tensorflow:Loaded TensorRT version: (8, 2, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:20:40.435280: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2022-03-31 19:20:40.435397: I tensorflow/core/grappler/clusters/single_machine.cc:358] Starting new session\n",
      "2022-03-31 19:20:40.443801: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:40.444278: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:40.444748: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:40.445214: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:40.490770: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1191] Optimization results for grappler item: graph_to_optimize\n",
      "  function_optimizer: Graph size after: 1202 nodes (878), 1857 edges (1533), time = 21.034ms.\n",
      "  function_optimizer: function_optimizer did nothing. time = 0.006ms.\n",
      "\n",
      "2022-03-31 19:20:42.931666: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2022-03-31 19:20:42.931793: I tensorflow/core/grappler/clusters/single_machine.cc:358] Starting new session\n",
      "2022-03-31 19:20:42.939826: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:42.940301: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:42.940766: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:42.941246: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:20:43.209210: W tensorflow/compiler/tf2tensorrt/convert/trt_optimization_pass.cc:192] Calibration with FP32 or FP16 is not implemented. Falling back to use_calibration = False.Note that the default value of use_calibration is True.\n",
      "2022-03-31 19:20:43.209312: I tensorflow/compiler/tf2tensorrt/convert/trt_optimization_pass.cc:211] [TF-TRT] not using explicit QDQ mode\n",
      "2022-03-31 19:20:43.367920: W tensorflow/compiler/tf2tensorrt/segment/segment.cc:954] \n",
      "\n",
      "################################################################################\n",
      "TensorRT unsupported/non-converted OP Report:\n",
      "\t- NoOp -> 2x\n",
      "\t- Identity -> 1x\n",
      "\t- Placeholder -> 1x\n",
      "--------------------------------------------------------------------------------\n",
      "\t- Total nonconverted OPs: 4\n",
      "\t- Total nonconverted OP Types: 3\n",
      "For more information see https://docs.nvidia.com/deeplearning/frameworks/tf-trt-user-guide/index.html#supported-ops.\n",
      "################################################################################\n",
      "\n",
      "2022-03-31 19:20:43.392249: W tensorflow/compiler/tf2tensorrt/segment/segment.cc:1281] The environment variable TF_TRT_MAX_ALLOWED_ENGINES=20 has no effect since there are only 1 TRT Engines with  at least minimum_segment_size=3 nodes.\n",
      "2022-03-31 19:20:43.396221: I tensorflow/compiler/tf2tensorrt/convert/convert_graph.cc:795] Number of TensorRT candidate segments: 1\n",
      "2022-03-31 19:20:43.403616: I tensorflow/compiler/tf2tensorrt/convert/convert_graph.cc:909] Replaced segment 0 consisting of 500 nodes by TRTEngineOp_1_0.\n",
      "2022-03-31 19:20:43.536490: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1191] Optimization results for grappler item: tf_graph\n",
      "  model_pruner: Graph size after: 880 nodes (-322), 1535 edges (-322), time = 7.715ms.\n",
      "  debug_stripper: debug_stripper did nothing. time = 0.089ms.\n",
      "  layout: Graph size after: 884 nodes (4), 1539 edges (4), time = 36.548ms.\n",
      "  dependency_optimizer: Graph size after: 560 nodes (-324), 575 edges (-964), time = 13.753ms.\n",
      "  constant_folding: Graph size after: 558 nodes (-2), 573 edges (-2), time = 19.516ms.\n",
      "  common_subgraph_elimination: Graph size after: 508 nodes (-50), 573 edges (0), time = 48.447ms.\n",
      "  TensorRTOptimizer: Graph size after: 9 nodes (-499), 2 edges (-571), time = 207.596ms.\n",
      "  constant_folding: Graph size after: 3 nodes (-6), 2 edges (0), time = 1.646ms.\n",
      "Optimization results for grappler item: TRTEngineOp_1_0_native_segment\n",
      "  model_pruner: Graph size after: 450 nodes (-52), 469 edges (-52), time = 3.733ms.\n",
      "  debug_stripper: debug_stripper did nothing. time = 0.047ms.\n",
      "  layout: Graph size after: 450 nodes (0), 469 edges (0), time = 10.839ms.\n",
      "  dependency_optimizer: Graph size after: 450 nodes (0), 469 edges (0), time = 4.449ms.\n",
      "  constant_folding: Graph size after: 450 nodes (0), 469 edges (0), time = 12.03ms.\n",
      "  common_subgraph_elimination: Graph size after: 450 nodes (0), 469 edges (0), time = 50.109ms.\n",
      "  TensorRTOptimizer: Graph size after: 450 nodes (0), 469 edges (0), time = 1.096ms.\n",
      "  constant_folding: Graph size after: 450 nodes (0), 469 edges (0), time = 11.639ms.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Could not find TRTEngineOp_1_0 in TF-TRT cache. This can happen if build() is not called, which means TensorRT engines will be built and cached at runtime.\n",
      "INFO:tensorflow:Assets written to: resnet50_saved_model_TFTRT_FP16/assets\n",
      "Done Converting to TF-TRT FP16\n"
     ]
    }
   ],
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 238
    },
    "colab_type": "code",
    "id": "yTDbB6DWn0kJ",
    "outputId": "33cd23f8-9c8b-4cdd-9c7a-4939aae12f56"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['serving_default']\n",
      "{'predictions': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='predictions')}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:20:59.847894: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n",
      "2022-03-31 19:21:00.426191: W tensorflow/compiler/tf2tensorrt/utils/trt_logger.cc:36] TF-TRT Warning: DefaultLogger It is suggested to disable layer timing cache while using AlgorithmSelector. Please refer to the developer guide in https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#builder-layer-timing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.5570198), ('n02109961', 'Eskimo_dog', 0.41618717), ('n02110063', 'malamute', 0.021451887)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "predict_tftrt('resnet50_saved_model_TFTRT_FP16')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "G_gerN5j9l6U"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:21:52.622013: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n",
      "2022-03-31 19:21:53.272943: W tensorflow/compiler/tf2tensorrt/utils/trt_logger.cc:36] TF-TRT Warning: DefaultLogger It is suggested to disable layer timing cache while using AlgorithmSelector. Please refer to the developer guide in https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#builder-layer-timing.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0:  1.4ms\n",
      "Step 50:  1.8ms\n",
      "Step 100:  1.9ms\n",
      "Step 150:  1.8ms\n",
      "Step 200:  1.9ms\n",
      "Step 250:  1.8ms\n",
      "Step 300:  1.8ms\n",
      "Step 350:  1.8ms\n",
      "Step 400:  1.8ms\n",
      "Step 450:  1.8ms\n",
      "Step 500:  1.9ms\n",
      "Step 550:  1.8ms\n",
      "Step 600:  1.8ms\n",
      "Step 650:  1.8ms\n",
      "Step 700:  1.8ms\n",
      "Step 750:  1.8ms\n",
      "Step 800:  1.8ms\n",
      "Step 850:  1.8ms\n",
      "Step 900:  1.9ms\n",
      "Step 950:  1.7ms\n",
      "Throughput: 4388 images/s\n"
     ]
    }
   ],
   "source": [
    "benchmark_tftrt('resnet50_saved_model_TFTRT_FP16')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qKSJ-oizkVQY"
   },
   "source": [
    "### TF-TRT INT8 model\n",
    "\n",
    "Creating TF-TRT INT8 model requires a small calibration dataset. This data set ideally should represent the test data in production well, and will be used to create a value histogram for each layer in the neural network for effective 8-bit quantization.  \n",
    "\n",
    "Herein, for demonstration purposes, we take only the 4 images that we downloaded for calibration. In production, this set should be more representative of the production data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oRXVurzh6o5T"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.kill(os.getpid(), 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding data loading and util functions again from above for to ease the notebook flow after reseting the kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batched_input shape:  (8, 224, 224, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:22:50.687672: I tensorflow/core/platform/cpu_feature_guard.cc:152] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE3 SSE4.1 SSE4.2 AVX\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-03-31 19:22:52.061051: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:52.062051: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:52.062771: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:52.063471: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "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 % 4)\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 201
    },
    "colab_type": "code",
    "id": "iM8DshiYkVQe",
    "outputId": "d3e88347-e060-4fd2-de2b-79cb38fc8442",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting to TF-TRT INT8...\n",
      "INFO:tensorflow:Linked TensorRT version: (8, 2, 3)\n",
      "INFO:tensorflow:Loaded TensorRT version: (8, 2, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:22:58.090840: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2022-03-31 19:22:58.090987: I tensorflow/core/grappler/clusters/single_machine.cc:358] Starting new session\n",
      "2022-03-31 19:22:58.140049: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:58.140553: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:58.141027: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:58.141500: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:58.206961: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1191] Optimization results for grappler item: graph_to_optimize\n",
      "  function_optimizer: Graph size after: 1202 nodes (878), 1857 edges (1533), time = 20.537ms.\n",
      "  function_optimizer: function_optimizer did nothing. time = 0.004ms.\n",
      "\n",
      "2022-03-31 19:22:59.989419: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 4\n",
      "2022-03-31 19:22:59.989537: I tensorflow/core/grappler/clusters/single_machine.cc:358] Starting new session\n",
      "2022-03-31 19:22:59.997708: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 43436 MB memory:  -> device: 0, name: NVIDIA A40, pci bus id: 0000:01:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:59.998191: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 43436 MB memory:  -> device: 1, name: NVIDIA A40, pci bus id: 0000:41:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:59.998671: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:2 with 43436 MB memory:  -> device: 2, name: NVIDIA A40, pci bus id: 0000:81:00.0, compute capability: 8.6\n",
      "2022-03-31 19:22:59.999143: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:3 with 43436 MB memory:  -> device: 3, name: NVIDIA A40, pci bus id: 0000:c1:00.0, compute capability: 8.6\n",
      "2022-03-31 19:23:00.283190: I tensorflow/compiler/tf2tensorrt/convert/trt_optimization_pass.cc:211] [TF-TRT] not using explicit QDQ mode\n",
      "2022-03-31 19:23:00.450001: W tensorflow/compiler/tf2tensorrt/segment/segment.cc:954] \n",
      "\n",
      "################################################################################\n",
      "TensorRT unsupported/non-converted OP Report:\n",
      "\t- NoOp -> 2x\n",
      "\t- Identity -> 1x\n",
      "\t- Placeholder -> 1x\n",
      "--------------------------------------------------------------------------------\n",
      "\t- Total nonconverted OPs: 4\n",
      "\t- Total nonconverted OP Types: 3\n",
      "For more information see https://docs.nvidia.com/deeplearning/frameworks/tf-trt-user-guide/index.html#supported-ops.\n",
      "################################################################################\n",
      "\n",
      "2022-03-31 19:23:00.471991: W tensorflow/compiler/tf2tensorrt/segment/segment.cc:1281] The environment variable TF_TRT_MAX_ALLOWED_ENGINES=20 has no effect since there are only 1 TRT Engines with  at least minimum_segment_size=3 nodes.\n",
      "2022-03-31 19:23:00.474762: I tensorflow/compiler/tf2tensorrt/convert/convert_graph.cc:795] Number of TensorRT candidate segments: 1\n",
      "2022-03-31 19:23:00.480847: I tensorflow/compiler/tf2tensorrt/convert/convert_graph.cc:909] Replaced segment 0 consisting of 500 nodes by TRTEngineOp_0_0.\n",
      "2022-03-31 19:23:00.589579: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1191] Optimization results for grappler item: tf_graph\n",
      "  model_pruner: Graph size after: 880 nodes (-322), 1535 edges (-322), time = 6.609ms.\n",
      "  debug_stripper: debug_stripper did nothing. time = 0.068ms.\n",
      "  layout: Graph size after: 884 nodes (4), 1539 edges (4), time = 32.965ms.\n",
      "  dependency_optimizer: Graph size after: 560 nodes (-324), 575 edges (-964), time = 11.566ms.\n",
      "  constant_folding: Graph size after: 558 nodes (-2), 573 edges (-2), time = 17.167ms.\n",
      "  common_subgraph_elimination: Graph size after: 508 nodes (-50), 573 edges (0), time = 71.133ms.\n",
      "  TensorRTOptimizer: Graph size after: 9 nodes (-499), 2 edges (-571), time = 202.865ms.\n",
      "  constant_folding: Graph size after: 3 nodes (-6), 2 edges (0), time = 0.56ms.\n",
      "Optimization results for grappler item: TRTEngineOp_0_0_native_segment\n",
      "  model_pruner: Graph size after: 450 nodes (-52), 469 edges (-52), time = 3.263ms.\n",
      "  debug_stripper: debug_stripper did nothing. time = 0.033ms.\n",
      "  layout: Graph size after: 450 nodes (0), 469 edges (0), time = 9.598ms.\n",
      "  dependency_optimizer: Graph size after: 450 nodes (0), 469 edges (0), time = 3.901ms.\n",
      "  constant_folding: Graph size after: 450 nodes (0), 469 edges (0), time = 9.608ms.\n",
      "  common_subgraph_elimination: Graph size after: 450 nodes (0), 469 edges (0), time = 46.16ms.\n",
      "  TensorRTOptimizer: Graph size after: 450 nodes (0), 469 edges (0), time = 0.809ms.\n",
      "  constant_folding: Graph size after: 450 nodes (0), 469 edges (0), time = 10.374ms.\n",
      "\n",
      "2022-03-31 19:23:01.756699: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n",
      "2022-03-31 19:23:01.763673: I tensorflow/compiler/tf2tensorrt/common/utils.cc:100] Linked TensorRT version: 8.2.3\n",
      "2022-03-31 19:23:01.763850: I tensorflow/compiler/tf2tensorrt/common/utils.cc:102] Loaded TensorRT version: 8.2.3\n",
      "2022-03-31 19:23:02.867073: I tensorflow/compiler/tf2tensorrt/convert/convert_nodes.cc:1372] [TF-TRT] Sparse compute capability is enabled.\n",
      "2022-03-31 19:23:02.868626: W tensorflow/compiler/tf2tensorrt/utils/trt_logger.cc:36] TF-TRT Warning: DefaultLogger It is suggested to disable layer timing cache while using AlgorithmSelector. Please refer to the developer guide in https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#builder-layer-timing.\n",
      "2022-03-31 19:23:05.817535: I tensorflow/stream_executor/cuda/cuda_dnn.cc:379] Loaded cuDNN version 8303\n",
      "2022-03-31 19:23:06.244408: I tensorflow/stream_executor/cuda/cuda_blas.cc:1804] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: resnet50_saved_model_TFTRT_INT8/assets\n",
      "Done Converting to TF-TRT INT8\n"
     ]
    }
   ],
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gu0CSNGVvwSY"
   },
   "outputs": [],
   "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['predictions'].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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DMVOHSo_vwSd"
   },
   "outputs": [],
   "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()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 238
    },
    "colab_type": "code",
    "id": "DSKfqPDGEv7U",
    "outputId": "028545e1-26e5-4fb6-930f-7b10af2c82fe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['serving_default']\n",
      "{'predictions': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='predictions')}\n",
      "./data/img0.JPG - Predicted: [('n02110185', 'Siberian_husky', 0.5626333), ('n02109961', 'Eskimo_dog', 0.4116313), ('n02110063', 'malamute', 0.02198676)]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:24:46.535802: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "predict_tftrt('resnet50_saved_model_TFTRT_INT8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2mM9D3BTEzQS"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-31 19:24:51.421224: I tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc:446] TRTEngineOp not using explicit QDQ\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0:  2.2ms\n",
      "Step 50:  1.8ms\n",
      "Step 100:  1.7ms\n",
      "Step 150:  1.8ms\n",
      "Step 200:  1.8ms\n",
      "Step 250:  1.7ms\n",
      "Step 300:  1.7ms\n",
      "Step 350:  1.8ms\n",
      "Step 400:  1.8ms\n",
      "Step 450:  1.6ms\n",
      "Step 500:  1.4ms\n",
      "Step 550:  1.4ms\n",
      "Step 600:  1.5ms\n",
      "Step 650:  1.3ms\n",
      "Step 700:  1.4ms\n",
      "Step 750:  1.9ms\n",
      "Step 800:  1.9ms\n",
      "Step 850:  1.9ms\n",
      "Step 900:  1.8ms\n",
      "Step 950:  1.8ms\n",
      "Throughput: 4746 images/s\n"
     ]
    }
   ],
   "source": [
    "benchmark_tftrt('resnet50_saved_model_TFTRT_INT8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I13snJ9VkVQh"
   },
   "source": [
    "## Conclusion\n",
    "In this notebook, we have demonstrated the process of creating TF-TRT FP32, FP16 and INT8 inference models from an original Keras FP32 model, as well as verify their speed and accuracy. \n",
    "\n",
    "### What's next\n",
    "Try TF-TRT on your own model and data, and experience the simplicity and speed up it offers."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "include_colab_link": true,
   "machine_shape": "hm",
   "name": "Colab-TF20-TF-TRT-inference-from-Keras-saved-model.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}