From 478c42fb0e6d60347329a70da3b9131b1efda522 Mon Sep 17 00:00:00 2001 From: Shashank Verma Date: Tue, 4 Aug 2020 15:28:38 -0700 Subject: [PATCH] Add TRTorch-SSD300 demo notebook - Change adds a TRTorch demo notebook for SSD Objection Detection model. - Observing ~100x speedup with TRTorch/TRT as compared to without it, as tested on a Tesla V100 32GB Signed-off-by: Shashank Verma --- notebooks/SSD-TRTorch.ipynb | 590 ++++++++++++++++++++++++++++++++++++ 1 file changed, 590 insertions(+) create mode 100644 notebooks/SSD-TRTorch.ipynb diff --git a/notebooks/SSD-TRTorch.ipynb b/notebooks/SSD-TRTorch.ipynb new file mode 100644 index 0000000000..c67477178a --- /dev/null +++ b/notebooks/SSD-TRTorch.ipynb @@ -0,0 +1,590 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 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": {}, + "source": [ + "\n", + "\n", + "# TRTorch - SSD Object Detection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Overview\n", + "\n", + "\n", + "In PyTorch 1.0, TorchScript was introduced as a method to separate your PyTorch model from Python, make it portable and optimizable.\n", + "\n", + "TRTorch is a compiler that uses TensorRT (NVIDIA's Deep Learning Optimization SDK and Runtime) to optimize TorchScript code. It compiles standard TorchScript modules into ones that internally run with TensorRT optimizations.\n", + "\n", + "TensorRT can take models from any major framework and specifically tune them to perform better on specific target hardware in the NVIDIA family, and TRTorch enables us to continue to remain in the PyTorch ecosystem whilst doing so. This allows us to leverage the great features in PyTorch, including module composability, its flexible tensor implementation, data loaders and more. TRTorch is available to use with both PyTorch and LibTorch. \n", + "\n", + "To get more background information on this, we suggest the **lenet-getting-starting** notebook as a primer for getting started with TRTorch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Learning objectives\n", + "\n", + "This notebook demonstrates the steps for compiling a TorchScript module with TRTorch on a pretrained SSD network, and running it to test the speedup obtained.\n", + "\n", + "## Contents\n", + "1. [Requirements](#1)\n", + "2. [SSD Overview](#2)\n", + "3. [Creating TorchScript modules](#3)\n", + "4. [Compiling with TRTorch](#4)\n", + "5. [Running Inference](#5)\n", + "6. [Measuring Speedup](#6)\n", + "7. [Conclusion](#7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 1. Requirements\n", + "\n", + "Follow the steps in `notebooks/README` to prepare a Docker container, within which you can run this demo notebook.\n", + "\n", + "In addition to that, run the following cell to obtain additional libraries specific to this demo." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You are using pip version 20.0.2; however, version 20.2.1 is available.\n", + "You should consider upgrading via the '/usr/bin/python -m pip install --upgrade pip' command.\n" + ] + } + ], + "source": [ + "%%bash\n", + "pip install numpy==1.19 scipy==1.5.2 scikit-image==0.17.2 matplotlib==3.3.0 pillow>=6.2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 2. SSD\n", + "\n", + "### Single Shot MultiBox Detector model for object detection\n", + "\n", + "_ | _\n", + "- | -\n", + "![alt](https://pytorch.org/assets/images/ssd_diagram.png) | ![alt](https://pytorch.org/assets/images/ssd.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "PyTorch has a model repository called the PyTorch Hub, which is a source for high quality implementations of common models. We can get our SSD model pretrained on [COCO](https://cocodataset.org/#home) from there.\n", + "\n", + "### Model Description\n", + "\n", + "This SSD300 model is based on the\n", + "[SSD: Single Shot MultiBox Detector](https://arxiv.org/abs/1512.02325) paper, which\n", + "describes SSD as “a method for detecting objects in images using a single deep neural network\".\n", + "The input size is fixed to 300x300.\n", + "\n", + "The main difference between this model and the one described in the paper is in the backbone.\n", + "Specifically, the VGG model is obsolete and is replaced by the ResNet-50 model.\n", + "\n", + "From the\n", + "[Speed/accuracy trade-offs for modern convolutional object detectors](https://arxiv.org/abs/1611.10012)\n", + "paper, the following enhancements were made to the backbone:\n", + "* The conv5_x, avgpool, fc and softmax layers were removed from the original classification model.\n", + "* All strides in conv4_x are set to 1x1.\n", + "\n", + "The backbone is followed by 5 additional convolutional layers.\n", + "In addition to the convolutional layers, we attached 6 detection heads:\n", + "* The first detection head is attached to the last conv4_x layer.\n", + "* The other five detection heads are attached to the corresponding 5 additional layers.\n", + "\n", + "Detector heads are similar to the ones referenced in the paper, however,\n", + "they are enhanced by additional BatchNorm layers after each convolution.\n", + "\n", + "More information about this SSD model is available at Nvidia's \"DeepLearningExamples\" Github [here](https://github.com/NVIDIA/DeepLearningExamples/tree/master/PyTorch/Detection/SSD)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub\n" + ] + }, + { + "data": { + "text/plain": [ + "['checkpoint_from_distributed',\n", + " 'nvidia_ncf',\n", + " 'nvidia_ssd',\n", + " 'nvidia_ssd_processing_utils',\n", + " 'nvidia_tacotron2',\n", + " 'nvidia_waveglow',\n", + " 'unwrap_distributed']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "\n", + "# List of available models in PyTorch Hub from Nvidia/DeepLearningExamples\n", + "torch.hub.list('NVIDIA/DeepLearningExamples:torchhub')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub\n" + ] + } + ], + "source": [ + "# load SSD model pretrained on COCO from Torch Hub\n", + "precision = 'fp32'\n", + "ssd300 = torch.hub.load('NVIDIA/DeepLearningExamples:torchhub', 'nvidia_ssd', model_math=precision);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setting `precision=\"fp16\"` will load a checkpoint trained with mixed precision \n", + "into architecture enabling execution on Tensor Cores. Handling mixed precision data requires the Apex library." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Benchmark utility" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "\n", + "import torch.backends.cudnn as cudnn\n", + "cudnn.benchmark = True\n", + "\n", + "# Helper function to benchmark the model\n", + "def benchmark(model, input_shape=(1024, 1, 32, 32), dtype='fp32', nwarmup=50, nruns=10000):\n", + " input_data = torch.randn(input_shape)\n", + " input_data = input_data.to(\"cuda\")\n", + " if dtype=='fp16':\n", + " input_data = input_data.half()\n", + " \n", + " print(\"Warm up ...\")\n", + " with torch.no_grad():\n", + " for _ in range(nwarmup):\n", + " features = model(input_data)\n", + " torch.cuda.synchronize()\n", + " print(\"Start timing ...\")\n", + " timings = []\n", + " with torch.no_grad():\n", + " for i in range(1, nruns+1):\n", + " start_time = time.time()\n", + " pred_loc, pred_label = model(input_data)\n", + " torch.cuda.synchronize()\n", + " end_time = time.time()\n", + " timings.append(end_time - start_time)\n", + " if i%1000==0:\n", + " print('Iteration %d/%d, ave batch time %.2f ms'%(i, nruns, np.mean(timings)*1000))\n", + "\n", + " print(\"Input shape:\", input_data.size())\n", + " print(\"Output location prediction size:\", pred_loc.size())\n", + " print(\"Output label prediction size:\", pred_label.size())\n", + " print('Average batch time: %.2f ms'%(np.mean(timings)*1000))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warm up ...\n", + "Start timing ...\n", + "Iteration 1000/1000, ave batch time 366.98 ms\n", + "Input shape: torch.Size([128, 3, 300, 300])\n", + "Output location prediction size: torch.Size([128, 4, 8732])\n", + "Output label prediction size: torch.Size([128, 81, 8732])\n", + "Average batch time: 366.98 ms\n" + ] + } + ], + "source": [ + "# Model benchmark without TRTorch/TensorRT\n", + "model = ssd300.eval().to(\"cuda\")\n", + "benchmark(model, input_shape=(128, 3, 300, 300), nruns=1000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 3. Creating TorchScript modules " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compile with TRTorch, the model must first be in **TorchScript**. TorchScript is a programming language included in PyTorch which removes the Python dependency normal PyTorch models have. This conversion is done via a JIT compiler which given a PyTorch Module will generate an equivalent TorchScript Module. There are two paths that can be used to generate TorchScript: **Tracing** and **Scripting**. Tracing follows execution of PyTorch generating ops in TorchScript corresponding to what it sees. Scripting does an analysis of the Python code and generates TorchScript, this allows the resulting graph to include control flow which tracing cannot do. Tracing however due to its simplicity is more likely to compile successfully with TRTorch (though both systems are supported)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = ssd300.eval().to(\"cuda\")\n", + "traced_model = torch.jit.trace(model, [torch.randn((1,3,300,300)).to(\"cuda\")])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can save this model and use it independently of Python." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# This is just an example, and not required for the purposes of this demo\n", + "torch.jit.save(traced_model, \"ssd_300_traced.jit.pt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 4. Compiling with TRTorch\n", + "TorchScript modules behave just like normal PyTorch modules and are intercompatable. From TorchScript we can now compile a TensorRT based module. This module will still be implemented in TorchScript but all the computation will be done in TensorRT." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import trtorch\n", + "\n", + "trt_model = trtorch.compile(traced_model, {\n", + " \"input_shapes\": [(3, 3, 300, 300)],\n", + " \"op_precision\": torch.half,\n", + " \"workspace_size\": 1 << 20\n", + "})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 5. Running Inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now run inference on the TRTorch compiled model. This is demonstrated below using sample images from the COCO 2017 Validation set." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /root/.cache/torch/hub/NVIDIA_DeepLearningExamples_torchhub\n" + ] + } + ], + "source": [ + "# Sample images from the COCO validation set\n", + "uris = [\n", + " 'http://images.cocodataset.org/val2017/000000397133.jpg',\n", + " 'http://images.cocodataset.org/val2017/000000037777.jpg',\n", + " 'http://images.cocodataset.org/val2017/000000252219.jpg'\n", + "]\n", + "\n", + "# For convenient and comprehensive formatting of input and output of the model, load a set of utility methods.\n", + "utils = torch.hub.load('NVIDIA/DeepLearningExamples:torchhub', 'nvidia_ssd_processing_utils')\n", + "\n", + "# Format images to comply with the network input\n", + "inputs = [utils.prepare_input(uri) for uri in uris]\n", + "tensor = utils.prepare_tensor(inputs, False)\n", + "\n", + "# The model was trained on COCO dataset, which we need to access in order to\n", + "# translate class IDs into object names. \n", + "classes_to_labels = utils.get_coco_object_dictionary()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Run object detection\n", + "detections_batch = trt_model(tensor.to(torch.half))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, raw output from SSD network per input image contains 8732 boxes with localization and class probability distribution. Let’s filter this output to only get reasonable detections (confidence>40%) in a more comprehensive format." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "results_per_input = utils.decode_results(detections_batch)\n", + "best_results_per_input = [utils.pick_best(results, 0.40) for results in results_per_input]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's visualize our predictions!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the images and predicted bounding boxes (with confidence scores).\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.patches as patches\n", + "\n", + "for image_idx in range(len(best_results_per_input)):\n", + " fig, ax = plt.subplots(1)\n", + " # Show original, denormalized image...\n", + " image = inputs[image_idx] / 2 + 0.5\n", + " ax.imshow(image)\n", + " # ...with detections\n", + " bboxes, classes, confidences = best_results_per_input[image_idx]\n", + " for idx in range(len(bboxes)):\n", + " left, bot, right, top = bboxes[idx]\n", + " x, y, w, h = [val * 300 for val in [left, bot, right - left, top - bot]]\n", + " rect = patches.Rectangle((x, y), w, h, linewidth=1, edgecolor='r', facecolor='none')\n", + " ax.add_patch(rect)\n", + " ax.text(x, y, \"{} {:.0f}%\".format(classes_to_labels[classes[idx] - 1], confidences[idx]*100), bbox=dict(facecolor='white', alpha=0.5))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 6. Measuring Speedup\n", + "We can run the benchmark again utility to see the speedup gained! Compare this result with the average time taken by a similar sized batch of input in the case without TRTorch/TRT above." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warm up ...\n", + "Start timing ...\n", + "Iteration 1000/1000, ave batch time 3.30 ms\n", + "Input shape: torch.Size([128, 3, 300, 300])\n", + "Output location prediction size: torch.Size([3, 4, 8732])\n", + "Output label prediction size: torch.Size([3, 81, 8732])\n", + "Average batch time: 3.30 ms\n" + ] + } + ], + "source": [ + "benchmark(trt_model, input_shape=(128, 3, 300, 300), nruns=1000, dtype=\"fp16\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## 7. Conclusion\n", + "\n", + "In this notebook, we have walked through the complete process of compiling a TorchScript SSD300 model with TRTorch, and tested the performance impact of the optimization." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Details\n", + "For detailed information on model input and output,\n", + "training recipies, inference and performance visit:\n", + "[github](https://github.com/NVIDIA/DeepLearningExamples/tree/master/PyTorch/Detection/SSD)\n", + "and/or [NGC](https://ngc.nvidia.com/catalog/model-scripts/nvidia:ssd_for_pytorch)\n", + "\n", + "### References\n", + "\n", + " - [SSD: Single Shot MultiBox Detector](https://arxiv.org/abs/1512.02325) paper\n", + " - [Speed/accuracy trade-offs for modern convolutional object detectors](https://arxiv.org/abs/1611.10012) paper\n", + " - [SSD on NGC](https://ngc.nvidia.com/catalog/model-scripts/nvidia:ssd_for_pytorch)\n", + " - [SSD on github](https://github.com/NVIDIA/DeepLearningExamples/tree/master/PyTorch/Detection/SSD)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}