acceleration/TensorRT_inference_acceleration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) MONAI Consortium  \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",
    "&nbsp;&nbsp;&nbsp;&nbsp;http://www.apache.org/licenses/LICENSE-2.0  \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",
    "\n",
    "# Benchmark TensorRT models inference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial shows how to convert a bundle into a TensorRT engine-based TorchScript for better performance and benchmark the latency difference between the original bundle and the TensorRT engine-based TorchScript.\n",
    "\n",
    "The `endoscopic_tool_segmentation` bundle is used as the example in this tutorial. The inference latency before and after the coversion process will be compared. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup environment\n",
    "\n",
    "The TensorRT conversion is supported since **MONAI 1.2** with **Torch-TensorRT 1.4.0** and **TensorRT 8.5.3**. If a docker container is used, please ensure the MONAI version is >=1.2 or the environment meets the min version requirement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, tqdm]\"\n",
    "!python -c \"import matplotlib\" || pip install -q matplotlib\n",
    "!python -c \"import pandas\" || pip install -q pandas\n",
    "!python -c \"import torch_tensorrt\" || pip install torch_tensorrt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import tempfile\n",
    "\n",
    "import torch\n",
    "import torch_tensorrt\n",
    "import numpy as np\n",
    "from ignite.engine import Engine\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import monai\n",
    "from monai.apps import download_and_extract\n",
    "from monai.config import print_config\n",
    "from ignite.engine import Events\n",
    "from collections import OrderedDict\n",
    "from monai.engines import IterationEvents\n",
    "\n",
    "print(f\"Torch-TensorRT version: {torch_tensorrt.__version__}.\")\n",
    "\n",
    "print_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup data directory\n",
    "\n",
    "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable.  \n",
    "This allows you to save results and reuse downloads.  \n",
    "If not specified a temporary directory will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root dir is: /workspace/data\n"
     ]
    }
   ],
   "source": [
    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
    "print(f\"root dir is: {root_dir}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download dataset\n",
    "\n",
    "Downloads and extracts the endoscopic_tool_segmentation dataset. The dataset is a subset of the [EndoVis 2017 Robot Instrument Challenge](https://endovissub2017-roboticinstrumentsegmentation.grand-challenge.org/Data/) data. It is used here just for verifying the latency of model inference. Please make sure to read the requirements and usage policies of the challenge data and give credit to the authors of the dataset!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "endoscopic_tool_dataset.zip: 12.9MB [00:00, 21.7MB/s]                                           "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-04-26 09:14:56,803 - INFO - Downloaded: /workspace/data/endoscopic_tool_dataset.zip\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-04-26 09:14:56,832 - INFO - Verified 'endoscopic_tool_dataset.zip', md5: f82da47259c0a617202fb54624798a55.\n",
      "2023-04-26 09:14:56,833 - INFO - Writing into directory: /workspace/data.\n"
     ]
    }
   ],
   "source": [
    "resource = \"https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/endoscopic_tool_dataset.zip\"\n",
    "md5 = \"f82da47259c0a617202fb54624798a55\"\n",
    "\n",
    "compressed_file = os.path.join(root_dir, \"endoscopic_tool_dataset.zip\")\n",
    "data_root = os.path.join(root_dir, \"endoscopic_tool_dataset\")\n",
    "if not os.path.exists(data_root):\n",
    "    download_and_extract(resource, compressed_file, root_dir, md5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download the endoscopic_tool_segmentation bundle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-04-26 09:14:56,907 - INFO - --- input summary of monai.bundle.scripts.download ---\n",
      "2023-04-26 09:14:56,908 - INFO - > name: 'endoscopic_tool_segmentation'\n",
      "2023-04-26 09:14:56,909 - INFO - > bundle_dir: './'\n",
      "2023-04-26 09:14:56,910 - INFO - > source: 'github'\n",
      "2023-04-26 09:14:56,910 - INFO - > remove_prefix: 'monai_'\n",
      "2023-04-26 09:14:56,911 - INFO - > progress: True\n",
      "2023-04-26 09:14:56,911 - INFO - ---\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "endoscopic_tool_segmentation_v0.4.9.zip: 81.7MB [00:01, 61.9MB/s]                               "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2023-04-26 09:14:58,760 - INFO - Downloaded: endoscopic_tool_segmentation_v0.4.9.zip\n",
      "2023-04-26 09:14:58,761 - INFO - Expected md5 is None, skip md5 check for file endoscopic_tool_segmentation_v0.4.9.zip.\n",
      "2023-04-26 09:14:58,762 - INFO - Writing into directory: ..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "bundle_dir = \"./\"\n",
    "bundle_name = \"endoscopic_tool_segmentation\"\n",
    "bundle_path = os.path.join(bundle_dir, bundle_name)\n",
    "if not os.path.exists(bundle_path):\n",
    "    monai.bundle.download(name=bundle_name, bundle_dir=\"./\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export the TensorRT model with API\n",
    "\n",
    "Export the downloaded bundle model to TensorRT engine-based TorchScript models. It takes a while for the conversion and will generate the `model_trt_fp32.ts` and `model_trt_fp16.ts` into the `models` folder.\n",
    "\n",
    "The command is quite similar to the `ckpt_export` command, except the `precision` and `dynamic_batchsize` parameters. \n",
    "\n",
    "The `precision` parameter specifies the precision of the exported model weight, which currently supports `fp32` and `fp16` as input.\n",
    "\n",
    "The `dynamic_batchsize` parameter is a sequence with three elements to define the batch size range of the input of the model to be converted. Should be a sequence like `[MIN_BATCH, OPT_BATCH, MAX_BATCH]`. After conversion, the batch size of model input should be between `MIN_BATCH` and `MAX_BATCH`. The `OPT_BATCH` is the best performance batch size that the TensorRT tries to fit. It should be the most frequently used input batch size in the application. In this part, we simply assign it to `\"[1, 1, 1]\"`, because the `endoscopic_tool_segmentation` bundle takes a fixed input batch size, when doing the inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%cd endoscopic_tool_segmentation\n",
    "!python -m monai.bundle trt_export network_def --filepath models/model_trt_fp32.ts --ckpt_file models/model.pt --meta_file configs/metadata.json --config_file configs/inference.json --precision fp32 --dynamic_batchsize \"[1, 1, 1]\"\n",
    "!python -m monai.bundle trt_export network_def --filepath models/model_trt_fp16.ts --ckpt_file models/model.pt --meta_file configs/metadata.json --config_file configs/inference.json --precision fp16 --dynamic_batchsize \"[1, 1, 1]\"\n",
    "%cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the torch model and TensorRT model\n",
    "\n",
    "Load the original bundle model and the TensorRT engine-based TorchScript models. Please note that `torch_tensorrt>=1.4.0` must be imported before loading TensorRT engine-based TorchScript models, since it will provide some runtime context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_parser(meta_config, inference_config):\n",
    "    parser = monai.bundle.ConfigParser()\n",
    "    parser.read_meta(meta_config)\n",
    "    parser.read_config(inference_config)\n",
    "    return parser\n",
    "\n",
    "\n",
    "model_weight = os.path.join(f\"./{bundle_name}\", \"models\", \"model.pt\")\n",
    "meta_config = os.path.join(f\"./{bundle_name}\", \"configs\", \"metadata.json\")\n",
    "inference_config = os.path.join(f\"./{bundle_name}\", \"configs\", \"inference.json\")\n",
    "trt_fp32_model_path = os.path.join(f\"./{bundle_name}\", \"models\", \"model_trt_fp32.ts\")\n",
    "trt_fp16_model_path = os.path.join(f\"./{bundle_name}\", \"models\", \"model_trt_fp16.ts\")\n",
    "\n",
    "parser = get_parser(meta_config, inference_config)\n",
    "device = parser.get_parsed_content(\"device\")\n",
    "\n",
    "net_id = \"network\"\n",
    "spatial_shape = (1, 3, 736, 480)\n",
    "model = parser.get_parsed_content(net_id)\n",
    "\n",
    "model.eval()\n",
    "\n",
    "trt_fp32_model = torch.jit.load(trt_fp32_model_path)\n",
    "trt_fp16_model = torch.jit.load(trt_fp16_model_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmark the model inference time\n",
    "\n",
    "In this part, the model inference with a random input is benchmarked, i.e. the model computation latency without loading any real data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time for the PyTorch model: 6080.33ms. Average time for the PyTorch model: 12.16ms.\n",
      "Total time for the TensorRT fp32 model: 3140.43ms. Average time for the TensorRT fp32 model: 6.28ms.\n",
      "Total time for the TensorRT fp16 model: 2503.63ms. Average time for the TensorRT fp16 model: 5.01ms.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def inference_random_torch_timer(model, input_shape, model_type=\"torch\", warmup_iter=500, active_iter=500):\n",
    "    \"\"\"Do the inference several times and get the latency.\"\"\"\n",
    "\n",
    "    # Do some warmup in case there are extra libraries and models load overhead.\n",
    "    with torch.no_grad():\n",
    "        for _ in range(warmup_iter):\n",
    "            random_input = torch.rand(input_shape, dtype=torch.float32, device=device)\n",
    "            model(random_input)\n",
    "\n",
    "        timeaccumulate = []\n",
    "        for _ in range(active_iter):\n",
    "            starter, ender = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)\n",
    "            torch.cuda.synchronize()\n",
    "            starter.record()\n",
    "            model(random_input)\n",
    "            ender.record()\n",
    "            torch.cuda.synchronize()\n",
    "            time_cur = starter.elapsed_time(ender)\n",
    "            timeaccumulate.append(time_cur)\n",
    "        total_time = sum(timeaccumulate)\n",
    "        average_time = total_time / (len(timeaccumulate) + 1e-12)\n",
    "    print(\n",
    "        f\"Total time for the {model_type} model: {total_time:.2f}ms.\",\n",
    "        f\"Average time for the {model_type} model: {average_time:.2f}ms.\",\n",
    "    )\n",
    "    return timeaccumulate\n",
    "\n",
    "\n",
    "# Only test the fp32 precision torch model\n",
    "torch.backends.cuda.matmul.allow_tf32 = False\n",
    "torch.backends.cudnn.allow_tf32 = False\n",
    "\n",
    "torch_time_list = inference_random_torch_timer(model, spatial_shape, model_type=\"PyTorch\")\n",
    "trt32_time_list = inference_random_torch_timer(trt_fp32_model, spatial_shape, model_type=\"TensorRT fp32\")\n",
    "trt16_time_list = inference_random_torch_timer(trt_fp16_model, spatial_shape, model_type=\"TensorRT fp16\")\n",
    "\n",
    "plt.title(\"Latency benchmark results of different models.\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Latency (ms)\")\n",
    "plt.plot(torch_time_list, color=\"red\", label=\"PyTorch model\")\n",
    "plt.plot(trt32_time_list, color=\"green\", label=\"TensorRT fp32 model\")\n",
    "plt.plot(trt16_time_list, color=\"blue\", label=\"TensorRT fp16 model\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmark the end-to-end bundle run\n",
    "\n",
    "In this part, the `evaluator` in the bundle is parsed to do the end-to-end inference. A `TimerHandler` is defined to benchmark every part of the inference process."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the TimerHandler\n",
    "\n",
    "Define a `CUDATimer` to time the latency on GPU and a `TimerHandler` to attach this timer to every part of an end-to-end inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CUDATimer:\n",
    "    def __init__(self, type_str) -> None:\n",
    "        self.time_list = []\n",
    "        self.type_str = type_str\n",
    "\n",
    "    def start(self) -> None:\n",
    "        self.starter = torch.cuda.Event(enable_timing=True)\n",
    "        self.ender = torch.cuda.Event(enable_timing=True)\n",
    "        torch.cuda.synchronize()\n",
    "        self.starter.record()\n",
    "\n",
    "    def end(self) -> None:\n",
    "        self.ender.record()\n",
    "        torch.cuda.synchronize()\n",
    "        self.time_list.append(self.starter.elapsed_time(self.ender))\n",
    "\n",
    "    def get_max(self) -> float:\n",
    "        return max(self.time_list)\n",
    "\n",
    "    def get_min(self) -> float:\n",
    "        return min(self.time_list)\n",
    "\n",
    "    def get_mean(self) -> float:\n",
    "        np_time = np.array(self.time_list)\n",
    "        return np.mean(np_time)\n",
    "\n",
    "    def get_std(self) -> float:\n",
    "        np_time = np.array(self.time_list)\n",
    "        return np.std(np_time)\n",
    "\n",
    "    def get_sum(self) -> float:\n",
    "        np_time = np.array(self.time_list)\n",
    "        return np.sum(np_time)\n",
    "\n",
    "    def get_results_dict(self) -> OrderedDict:\n",
    "        out_list = [\n",
    "            (\"total\", self.get_sum()),\n",
    "            (\"min\", self.get_min()),\n",
    "            (\"max\", self.get_max()),\n",
    "            (\"mean\", self.get_mean()),\n",
    "            (\"std\", self.get_std()),\n",
    "        ]\n",
    "        return OrderedDict(out_list)\n",
    "\n",
    "\n",
    "class TimerHandler:\n",
    "    def __init__(self) -> None:\n",
    "        self.run_timer = CUDATimer(\"RUN\")\n",
    "        self.epoch_timer = CUDATimer(\"EPOCH\")\n",
    "        self.iteration_timer = CUDATimer(\"ITERATION\")\n",
    "        self.net_forward_timer = CUDATimer(\"FORWARD\")\n",
    "        self.get_batch_timer = CUDATimer(\"PREPARE_BATCH\")\n",
    "        self.post_process_timer = CUDATimer(\"POST_PROCESS\")\n",
    "        self.timer_list = [\n",
    "            self.run_timer,\n",
    "            self.epoch_timer,\n",
    "            self.iteration_timer,\n",
    "            self.net_forward_timer,\n",
    "            self.get_batch_timer,\n",
    "            self.post_process_timer,\n",
    "        ]\n",
    "\n",
    "    def attach(self, engine: Engine) -> None:\n",
    "        engine.add_event_handler(Events.STARTED, self.started, timer=self.run_timer)\n",
    "        engine.add_event_handler(Events.EPOCH_STARTED, self.started, timer=self.epoch_timer)\n",
    "        engine.add_event_handler(Events.ITERATION_STARTED, self.started, timer=self.iteration_timer)\n",
    "        engine.add_event_handler(Events.GET_BATCH_STARTED, self.started, timer=self.get_batch_timer)\n",
    "        engine.add_event_handler(Events.GET_BATCH_COMPLETED, self.completed, timer=self.get_batch_timer)\n",
    "        engine.add_event_handler(Events.GET_BATCH_COMPLETED, self.started, timer=self.net_forward_timer)\n",
    "        engine.add_event_handler(IterationEvents.FORWARD_COMPLETED, self.completed, timer=self.net_forward_timer)\n",
    "        engine.add_event_handler(IterationEvents.FORWARD_COMPLETED, self.started, timer=self.post_process_timer)\n",
    "        engine.add_event_handler(Events.ITERATION_COMPLETED, self.completed, timer=self.post_process_timer)\n",
    "        engine.add_event_handler(Events.ITERATION_COMPLETED, self.completed, timer=self.iteration_timer)\n",
    "        engine.add_event_handler(Events.EPOCH_COMPLETED, self.completed, timer=self.epoch_timer)\n",
    "        engine.add_event_handler(Events.COMPLETED, self.completed, timer=self.run_timer)\n",
    "\n",
    "    def started(self, engine: Engine, timer: CUDATimer) -> None:\n",
    "        timer.start()\n",
    "\n",
    "    def completed(self, engine: Engine, timer: CUDATimer) -> None:\n",
    "        timer.end()\n",
    "\n",
    "    def print_results(self) -> None:\n",
    "        index = [x.type_str for x in self.timer_list]\n",
    "        column_title = list(self.timer_list[0].get_results_dict().keys())\n",
    "        column_title = [x + \"/ms\" for x in column_title]\n",
    "        latency_list = [x for timer in self.timer_list for x in timer.get_results_dict().values()]\n",
    "        latency_array = np.array(latency_list)\n",
    "        latency_array = np.reshape(latency_array, (len(index), len(column_title)))\n",
    "        df = pd.DataFrame(latency_array, index=index, columns=column_title)\n",
    "        return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Benchmark the MONAI bundle\n",
    "\n",
    "In this part, an `evaluator` with the original MONAI bundle runs several iterations to benchmark the latency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch_parser = get_parser(meta_config, inference_config)\n",
    "torch_parser[\"dataset_dir\"] = data_root\n",
    "torch_parser[\"bundle_root\"] = f\"./{bundle_name}\"\n",
    "torch_evaluator = torch_parser.get_parsed_content(\"evaluator\")\n",
    "torch_timer = TimerHandler()\n",
    "torch_timer.attach(torch_evaluator)\n",
    "torch_evaluator.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>total/ms</th>\n",
       "      <th>min/ms</th>\n",
       "      <th>max/ms</th>\n",
       "      <th>mean/ms</th>\n",
       "      <th>std/ms</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RUN</th>\n",
       "      <td>6641.093750</td>\n",
       "      <td>6641.093750</td>\n",
       "      <td>6641.093750</td>\n",
       "      <td>6641.093750</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EPOCH</th>\n",
       "      <td>6640.197266</td>\n",
       "      <td>6640.197266</td>\n",
       "      <td>6640.197266</td>\n",
       "      <td>6640.197266</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ITERATION</th>\n",
       "      <td>5747.162674</td>\n",
       "      <td>37.098530</td>\n",
       "      <td>53.634590</td>\n",
       "      <td>38.314418</td>\n",
       "      <td>1.626507</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FORWARD</th>\n",
       "      <td>4214.751709</td>\n",
       "      <td>27.449505</td>\n",
       "      <td>35.384319</td>\n",
       "      <td>28.098345</td>\n",
       "      <td>1.038988</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PREPARE_BATCH</th>\n",
       "      <td>700.098719</td>\n",
       "      <td>0.147104</td>\n",
       "      <td>40.188927</td>\n",
       "      <td>4.667325</td>\n",
       "      <td>3.410287</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>POST_PROCESS</th>\n",
       "      <td>1522.538400</td>\n",
       "      <td>9.442208</td>\n",
       "      <td>18.198112</td>\n",
       "      <td>10.150256</td>\n",
       "      <td>0.919048</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  total/ms       min/ms       max/ms      mean/ms    std/ms\n",
       "RUN            6641.093750  6641.093750  6641.093750  6641.093750  0.000000\n",
       "EPOCH          6640.197266  6640.197266  6640.197266  6640.197266  0.000000\n",
       "ITERATION      5747.162674    37.098530    53.634590    38.314418  1.626507\n",
       "FORWARD        4214.751709    27.449505    35.384319    28.098345  1.038988\n",
       "PREPARE_BATCH   700.098719     0.147104    40.188927     4.667325  3.410287\n",
       "POST_PROCESS   1522.538400     9.442208    18.198112    10.150256  0.919048"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch_timer.print_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Benchmark the TensorRT fp32 and fp16 models\n",
    "In this part, the `trt_fp32_model` and `trt_fp16_model` are loaded to an `evaluator` and run the same iterations as the original MONAI bundle to benchmark the latency difference. \n",
    "\n",
    "The `POST_PROCESS` and `PREPARE_BATCH` stages require a considerable amount of time. Although the model forward time is much improved, there is still room for acceleration in reducing the end-to-end latency on this particular MONAI bundle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace the model load part and remove the CheckpointLoader handler\n",
    "def del_ckpt_loader(parser):\n",
    "    ckpt_index = -1\n",
    "    for cnt, handler in enumerate(parser[\"handlers\"]):\n",
    "        if handler[\"_target_\"] == \"CheckpointLoader\":\n",
    "            ckpt_index = cnt\n",
    "            break\n",
    "    if ckpt_index != -1:\n",
    "        del parser[\"handlers\"][ckpt_index]\n",
    "\n",
    "\n",
    "trt32_parser = get_parser(meta_config, inference_config)\n",
    "trt32_parser[\"dataset_dir\"] = data_root\n",
    "trt32_parser[\"bundle_root\"] = f\"./{bundle_name}\"\n",
    "\n",
    "# Use torch.jit.load to load the jit model\n",
    "trt32_parser[net_id] = f\"$torch.jit.load('{trt_fp32_model_path}')\"\n",
    "del_ckpt_loader(trt32_parser)\n",
    "trt32_evaluator = trt32_parser.get_parsed_content(\"evaluator\")\n",
    "trt32_evaluator.amp = False\n",
    "trt32_timer = TimerHandler()\n",
    "trt32_timer.attach(trt32_evaluator)\n",
    "trt32_evaluator.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>total/ms</th>\n",
       "      <th>min/ms</th>\n",
       "      <th>max/ms</th>\n",
       "      <th>mean/ms</th>\n",
       "      <th>std/ms</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RUN</th>\n",
       "      <td>3618.392578</td>\n",
       "      <td>3618.392578</td>\n",
       "      <td>3618.392578</td>\n",
       "      <td>3618.392578</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EPOCH</th>\n",
       "      <td>3617.540771</td>\n",
       "      <td>3617.540771</td>\n",
       "      <td>3617.540771</td>\n",
       "      <td>3617.540771</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ITERATION</th>\n",
       "      <td>2702.197895</td>\n",
       "      <td>17.046593</td>\n",
       "      <td>24.722816</td>\n",
       "      <td>18.014653</td>\n",
       "      <td>1.094677</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FORWARD</th>\n",
       "      <td>1119.301630</td>\n",
       "      <td>7.273088</td>\n",
       "      <td>10.685312</td>\n",
       "      <td>7.462011</td>\n",
       "      <td>0.322076</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PREPARE_BATCH</th>\n",
       "      <td>685.971136</td>\n",
       "      <td>0.154464</td>\n",
       "      <td>31.215967</td>\n",
       "      <td>4.573141</td>\n",
       "      <td>2.766678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>POST_PROCESS</th>\n",
       "      <td>1574.500188</td>\n",
       "      <td>9.671904</td>\n",
       "      <td>17.191551</td>\n",
       "      <td>10.496668</td>\n",
       "      <td>0.972626</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  total/ms       min/ms       max/ms      mean/ms    std/ms\n",
       "RUN            3618.392578  3618.392578  3618.392578  3618.392578  0.000000\n",
       "EPOCH          3617.540771  3617.540771  3617.540771  3617.540771  0.000000\n",
       "ITERATION      2702.197895    17.046593    24.722816    18.014653  1.094677\n",
       "FORWARD        1119.301630     7.273088    10.685312     7.462011  0.322076\n",
       "PREPARE_BATCH   685.971136     0.154464    31.215967     4.573141  2.766678\n",
       "POST_PROCESS   1574.500188     9.671904    17.191551    10.496668  0.972626"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trt32_timer.print_results()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trt16_parser = get_parser(meta_config, inference_config)\n",
    "trt16_parser[\"dataset_dir\"] = data_root\n",
    "trt16_parser[\"bundle_root\"] = f\"./{bundle_name}\"\n",
    "\n",
    "# Use torch.jit.load to load the jit model\n",
    "trt16_parser[net_id] = f\"$torch.jit.load('{trt_fp16_model_path}')\"\n",
    "del_ckpt_loader(trt16_parser)\n",
    "trt16_evaluator = trt16_parser.get_parsed_content(\"evaluator\")\n",
    "trt16_evaluator.amp = False\n",
    "trt16_timer = TimerHandler()\n",
    "trt16_timer.attach(trt16_evaluator)\n",
    "trt16_evaluator.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>total/ms</th>\n",
       "      <th>min/ms</th>\n",
       "      <th>max/ms</th>\n",
       "      <th>mean/ms</th>\n",
       "      <th>std/ms</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RUN</th>\n",
       "      <td>3387.926758</td>\n",
       "      <td>3387.926758</td>\n",
       "      <td>3387.926758</td>\n",
       "      <td>3387.926758</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>EPOCH</th>\n",
       "      <td>3387.075195</td>\n",
       "      <td>3387.075195</td>\n",
       "      <td>3387.075195</td>\n",
       "      <td>3387.075195</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ITERATION</th>\n",
       "      <td>2482.248185</td>\n",
       "      <td>15.631616</td>\n",
       "      <td>22.302624</td>\n",
       "      <td>16.548321</td>\n",
       "      <td>0.849613</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FORWARD</th>\n",
       "      <td>919.405022</td>\n",
       "      <td>5.973472</td>\n",
       "      <td>8.953664</td>\n",
       "      <td>6.129367</td>\n",
       "      <td>0.302736</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PREPARE_BATCH</th>\n",
       "      <td>686.554657</td>\n",
       "      <td>0.139872</td>\n",
       "      <td>40.274338</td>\n",
       "      <td>4.577031</td>\n",
       "      <td>3.379327</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>POST_PROCESS</th>\n",
       "      <td>1554.704992</td>\n",
       "      <td>9.578368</td>\n",
       "      <td>13.574016</td>\n",
       "      <td>10.364700</td>\n",
       "      <td>0.647000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  total/ms       min/ms       max/ms      mean/ms    std/ms\n",
       "RUN            3387.926758  3387.926758  3387.926758  3387.926758  0.000000\n",
       "EPOCH          3387.075195  3387.075195  3387.075195  3387.075195  0.000000\n",
       "ITERATION      2482.248185    15.631616    22.302624    16.548321  0.849613\n",
       "FORWARD         919.405022     5.973472     8.953664     6.129367  0.302736\n",
       "PREPARE_BATCH   686.554657     0.139872    40.274338     4.577031  3.379327\n",
       "POST_PROCESS   1554.704992     9.578368    13.574016    10.364700  0.647000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trt16_timer.print_results()"
   ]
  }
 ],
 "metadata": {
  "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.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}