notebooks/110-ct-segmentation-quantize/110-ct-scan-live-inference.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Live Inference and Benchmark CT-scan Data with OpenVINO™\n",
    "\n",
    "## Kidney Segmentation with PyTorch Lightning and OpenVINO™ - Part 4 \n",
    "\n",
    "This tutorial is a part of a series on how to train, optimize, quantize and show live inference on a medical segmentation model. The goal is to accelerate inference on a kidney segmentation model. The [UNet](https://arxiv.org/abs/1505.04597) model is trained from scratch, and the data is from [Kits19](https://github.com/neheller/kits19).\n",
    "\n",
    "This tutorial shows how to benchmark performance of the model and show live inference with async API and MULTI plugin in OpenVINO.\n",
    "\n",
    "This notebook needs a quantized OpenVINO IR model and images from the [KiTS-19](https://github.com/neheller/kits19) dataset, converted to 2D images. (To learn how the model is quantized, see the [Convert and Quantize a UNet Model and Show Live Inference](110-ct-segmentation-quantize-nncf.ipynb) tutorial.)\n",
    "\n",
    "This notebook provides a pre-trained model, trained for 20 epochs with the full KiTS-19 frames dataset, which has an F1 score on the validation set of 0.9. The training code is available in the [PyTorch MONAI Training](../110-ct-segmentation-quantize/pytorch-monai-training.ipynb) notebook. \n",
    "\n",
    "For demonstration purposes, this tutorial will download one converted CT scan to use for inference.\n",
    "\n",
    "#### Table of content:\n",
    "- [Imports](#Imports-Uparrow)\n",
    "- [Settings](#Settings-Uparrow)\n",
    "- [Benchmark Model Performance](#Benchmark-Model-Performance-Uparrow)\n",
    "- [Download and Prepare Data](#Download-and-Prepare-Data-Uparrow)\n",
    "- [Show Live Inference](#Show-Live-Inference-Uparrow)\n",
    "    - [Load Model and List of Image Files](#Load-Model-and-List-of-Image-Files-Uparrow)\n",
    "    - [Prepare images](#Prepare-images-Uparrow)\n",
    "    - [Specify device](#Specify-device-Uparrow)\n",
    "    - [Setting callback function](#Setting-callback-function-Uparrow)\n",
    "    - [Create asynchronous inference queue and perform it](#Create-asynchronous-inference-queue-and-perform-it-Uparrow)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install -q \"openvino>=2023.1.0\" \"monai>=0.9.1,<1.0.0\" \"nncf>=2.5.0\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import zipfile\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "from monai.transforms import LoadImage\n",
    "import openvino as ov\n",
    "\n",
    "from custom_segmentation import SegmentationModel\n",
    "\n",
    "sys.path.append(\"../utils\")\n",
    "from notebook_utils import download_file"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "To use the pre-trained models, set `IR_PATH` to `\"pretrained_model/unet44.xml\"` and `COMPRESSED_MODEL_PATH` to `\"pretrained_model/quantized_unet44.xml\"`. To use a model that you trained or optimized yourself, adjust the model paths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "68e59e878bbd4e9c9e5e8e1d455c4a16",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "pretrained_model/quantized_unet_kits19.xml:   0%|          | 0.00/280k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ddfda4b110644808ca81d28ca37e32d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "pretrained_model/quantized_unet_kits19.bin:   0%|          | 0.00/1.90M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The directory that contains the IR model (xml and bin) files.\n",
    "models_dir = Path('pretrained_model')\n",
    "\n",
    "ir_model_url = 'https://storage.openvinotoolkit.org/repositories/openvino_notebooks/models/kidney-segmentation-kits19/FP16-INT8/'\n",
    "ir_model_name_xml = 'quantized_unet_kits19.xml'\n",
    "ir_model_name_bin = 'quantized_unet_kits19.bin'\n",
    "\n",
    "download_file(ir_model_url + ir_model_name_xml, filename=ir_model_name_xml, directory=models_dir)\n",
    "download_file(ir_model_url + ir_model_name_bin, filename=ir_model_name_bin, directory=models_dir)\n",
    "\n",
    "MODEL_PATH = models_dir / ir_model_name_xml\n",
    "\n",
    "# Uncomment the next line to use the FP16 model instead of the quantized model.\n",
    "# MODEL_PATH = \"pretrained_model/unet_kits19.xml\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmark Model Performance [$\\Uparrow$](#Table-of-content:)\n",
    "To measure the inference performance of the IR model, use [Benchmark Tool](https://docs.openvino.ai/2023.0/openvino_inference_engine_tools_benchmark_tool_README.html) - an inference performance measurement tool in OpenVINO. Benchmark tool is a command-line application that can be run in the notebook with `! benchmark_app` or `%sx benchmark_app` commands.\n",
    "\n",
    "> **Note**: The `benchmark_app` tool is able to measure the performance of the OpenVINO Intermediate Representation (OpenVINO IR) models only. For more accurate performance, run `benchmark_app` in a terminal/command prompt after closing other applications. Run `benchmark_app -m model.xml -d CPU` to benchmark async inference on CPU for one minute. Change `CPU` to `GPU` to benchmark on GPU. Run `benchmark_app --help` to see an overview of all command-line options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "318febf0c60b41fa97a5d60ea73988ce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'MULTI:CPU,GPU'), value='MULTI:CPU,GPU')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "core = ov.Core()\n",
    "# By default, benchmark on MULTI:CPU,GPU if a GPU is available, otherwise on CPU.\n",
    "device_list = [\"MULTI:CPU,GPU\" if \"GPU\" in core.available_devices else \"AUTO\"]\n",
    "\n",
    "import ipywidgets as widgets\n",
    "\n",
    "device = widgets.Dropdown(\n",
    "    options=core.available_devices + device_list,\n",
    "    value=device_list[0],\n",
    "    description='Device:',\n",
    "    disabled=False,\n",
    ")\n",
    "\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [],
    "test_replace": {
     "-t 15": "-t 3"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Step 1/11] Parsing and validating input arguments\n",
      "[ INFO ] Parsing input parameters\n",
      "[Step 2/11] Loading OpenVINO Runtime\n",
      "[ INFO ] OpenVINO:\n",
      "[ INFO ] Build ................................. 2023.0.0-10926-b4452d56304-releases/2023/0\n",
      "[ INFO ] \n",
      "[ INFO ] Device info:\n",
      "[ INFO ] CPU\n",
      "[ INFO ] Build ................................. 2023.0.0-10926-b4452d56304-releases/2023/0\n",
      "[ INFO ] GPU\n",
      "[ INFO ] Build ................................. 2023.0.0-10926-b4452d56304-releases/2023/0\n",
      "[ INFO ] MULTI\n",
      "[ INFO ] Build ................................. 2023.0.0-10926-b4452d56304-releases/2023/0\n",
      "[ INFO ] \n",
      "[ INFO ] \n",
      "[Step 3/11] Setting device configuration\n",
      "[ WARNING ] Performance hint was not explicitly specified in command line. Device(MULTI) performance hint will be set to PerformanceMode.LATENCY.\n",
      "[Step 4/11] Reading model files\n",
      "[ INFO ] Loading model files\n",
      "[ INFO ] Read model took 15.75 ms\n",
      "[ INFO ] Original model I/O parameters:\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     input.1 (node: input.1) : f32 / [...] / [1,1,512,512]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     153 (node: 153) : f32 / [...] / [1,1,512,512]\n",
      "[Step 5/11] Resizing model to match image sizes and given batch\n",
      "[ INFO ] Model batch size: 1\n",
      "[Step 6/11] Configuring input of the model\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     input.1 (node: input.1) : f32 / [N,C,H,W] / [1,1,512,512]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     153 (node: 153) : f32 / [...] / [1,1,512,512]\n",
      "[Step 7/11] Loading the model to the device\n",
      "61 warnings generated.\n",
      "1 warning generated.\n",
      "61 warnings generated.\n",
      "61 warnings generated.\n",
      "63 warnings generated.\n",
      "61 warnings generated.\n",
      "64 warnings generated.\n",
      "63 warnings generated.\n",
      "63 warnings generated.\n",
      "[ INFO ] Compile model took 5573.46 ms\n",
      "[Step 8/11] Querying optimal runtime parameters\n",
      "[ INFO ] Model:\n",
      "[ INFO ]   PERFORMANCE_HINT: PerformanceMode.THROUGHPUT\n",
      "[ INFO ]   NETWORK_NAME: pretrained_unet_kits19\n",
      "[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 16\n",
      "[ INFO ]   MODEL_PRIORITY: Priority.MEDIUM\n",
      "[ INFO ]   MULTI_DEVICE_PRIORITIES: CPU,GPU\n",
      "[ INFO ]   CPU:\n",
      "[ INFO ]     CPU_BIND_THREAD: YES\n",
      "[ INFO ]     CPU_THREADS_NUM: 0\n",
      "[ INFO ]     CPU_THROUGHPUT_STREAMS: 12\n",
      "[ INFO ]     DEVICE_ID: \n",
      "[ INFO ]     DUMP_EXEC_GRAPH_AS_DOT: \n",
      "[ INFO ]     DYN_BATCH_ENABLED: NO\n",
      "[ INFO ]     DYN_BATCH_LIMIT: 0\n",
      "[ INFO ]     ENFORCE_BF16: NO\n",
      "[ INFO ]     EXCLUSIVE_ASYNC_REQUESTS: NO\n",
      "[ INFO ]     NETWORK_NAME: pretrained_unet_kits19\n",
      "[ INFO ]     OPTIMAL_NUMBER_OF_INFER_REQUESTS: 12\n",
      "[ INFO ]     PERFORMANCE_HINT: THROUGHPUT\n",
      "[ INFO ]     PERFORMANCE_HINT_NUM_REQUESTS: 0\n",
      "[ INFO ]     PERF_COUNT: NO\n",
      "[ INFO ]   GPU:\n",
      "[ INFO ]     AUTO_BATCH_TIMEOUT: 1000\n",
      "[ INFO ]     EXECUTION_DEVICES: ['GPU.0']\n",
      "[ INFO ]     NETWORK_NAME: pretrained_unet_kits19\n",
      "[ INFO ]     OPTIMAL_NUMBER_OF_INFER_REQUESTS: 4\n",
      "[ INFO ]   EXECUTION_DEVICES: ['CPU', 'GPU']\n",
      "[Step 9/11] Creating infer requests and preparing input tensors\n",
      "[ WARNING ] No input files were given for input 'input.1'!. This input will be filled with random values!\n",
      "[ INFO ] Fill input 'input.1' with random values \n",
      "[Step 10/11] Measuring performance (Start inference synchronously, limits: 15000 ms duration)\n",
      "[ INFO ] Benchmarking in inference only mode (inputs filling are not included in measurement loop).\n",
      "[ INFO ] First inference took 48.38 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU', 'GPU']\n",
      "[ INFO ] Count:            349 iterations\n",
      "[ INFO ] Duration:         15020.54 ms\n",
      "[ INFO ] Throughput:   24.12 FPS\n"
     ]
    }
   ],
   "source": [
    "# Benchmark model\n",
    "! benchmark_app -m $MODEL_PATH -d $device.value -t 15 -api sync"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download and Prepare Data [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Download one validation video for live inference. \n",
    "\n",
    "This tutorial reuses the `KitsDataset` class that was also used in the training and quantization notebook that will be released later.\n",
    "\n",
    "The data is expected in `BASEDIR`. The `BASEDIR` directory should contain the `case_00000` to `case_00299` subdirectories. If the data for the case specified above does not already exist, it will be downloaded and extracted in the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data for case_00117 exists\n"
     ]
    }
   ],
   "source": [
    "# Directory that contains the CT scan data. This directory should contain subdirectories\n",
    "# case_00XXX where XXX is between 000 and 299.\n",
    "BASEDIR = Path(\"kits19_frames_1\")\n",
    "# The CT scan case number. For example: 16 for data from the case_00016 directory.\n",
    "# Currently only 117 is supported.\n",
    "CASE = 117\n",
    "\n",
    "case_path = BASEDIR / f\"case_{CASE:05d}\"\n",
    "\n",
    "if not case_path.exists():\n",
    "    filename = download_file(\n",
    "        f\"https://storage.openvinotoolkit.org/data/test_data/openvino_notebooks/kits19/case_{CASE:05d}.zip\"\n",
    "    )\n",
    "    with zipfile.ZipFile(filename, \"r\") as zip_ref:\n",
    "        zip_ref.extractall(path=BASEDIR)\n",
    "    os.remove(filename)  # remove zipfile\n",
    "    print(f\"Downloaded and extracted data for case_{CASE:05d}\")\n",
    "else:\n",
    "    print(f\"Data for case_{CASE:05d} exists\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Show Live Inference [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "To show live inference on the model in the notebook, use the asynchronous processing feature of OpenVINO Runtime.\n",
    "\n",
    "If you use a GPU device, with `device=\"GPU\"` or `device=\"MULTI:CPU,GPU\"` to do inference on an integrated graphics card, model loading will be slow the first time you run this code. The model will be cached, so after the first time model loading will be faster. For more information on OpenVINO Runtime, including Model Caching, refer to the [OpenVINO API tutorial](../002-openvino-api/002-openvino-api.ipynb).\n",
    "\n",
    "We will use [`AsyncInferQueue`](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_Python_API_exclusives.html#asyncinferqueue) to perform asynchronous inference. It can be instantiated with compiled model and a number of jobs - parallel execution threads. If you don't pass a number of jobs or pass `0`, then OpenVINO will pick the optimal number based on your device and heuristics. After acquiring the inference queue, there are two jobs to do:\n",
    "\n",
    "- Preprocess the data and push it to the inference queue. The preprocessing steps will remain the same.\n",
    "- Tell the inference queue what to do with the model output after the inference is finished. It is represented by the `callback` python function that takes an inference result and data that we passed to the inference queue along with the prepared input data\n",
    "\n",
    "Everything else will be handled by the `AsyncInferQueue` instance."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Model and List of Image Files [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Load the segmentation model to OpenVINO Runtime with `SegmentationModel`, based on the Model API from [Open Model Zoo](https://github.com/openvinotoolkit/open_model_zoo/). This model implementation includes pre and post processing for the model. For `SegmentationModel` this includes the code to create an overlay of the segmentation mask on the original image/frame. Uncomment the next cell to see the implementation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "122wcKhzXn3z",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "case_00117, 69 images\n"
     ]
    }
   ],
   "source": [
    "core = ov.Core()\n",
    "segmentation_model = SegmentationModel(\n",
    "    ie=core, model_path=Path(MODEL_PATH), sigmoid=True, rotate_and_flip=True\n",
    ")\n",
    "image_paths = sorted(case_path.glob(\"imaging_frames/*jpg\"))\n",
    "\n",
    "print(f\"{case_path.name}, {len(image_paths)} images\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare images [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Use the `reader = LoadImage()` function to read the images in the same way as in the [training](../110-ct-segmentation-quantize/pytorch-monai-training.ipynb) tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [],
    "test_replace": {
     "len(image_paths)": "len(image_paths[:5])"
    }
   },
   "outputs": [],
   "source": [
    "framebuf = []\n",
    "\n",
    "next_frame_id = 0\n",
    "reader = LoadImage(image_only=True, dtype=np.uint8)\n",
    "\n",
    "while next_frame_id < len(image_paths) - 1:\n",
    "    image_path = image_paths[next_frame_id]\n",
    "    image = reader(str(image_path))\n",
    "    framebuf.append(image)\n",
    "    next_frame_id += 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify device [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "318febf0c60b41fa97a5d60ea73988ce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'MULTI:CPU,GPU'), value='MULTI:CPU,GPU')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting callback function [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "When `callback` is set, any job that ends the inference, calls the Python function. The `callback` function must have two arguments: one is the request that calls the `callback`, which provides the `InferRequest` API; the other is called `userdata`, which provides the possibility of passing runtime values.\n",
    "\n",
    "The `callback` function will show the results of inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import copy\n",
    "from IPython import display\n",
    "\n",
    "from typing import Dict, Any\n",
    "\n",
    "# Define a callback function that runs every time the asynchronous pipeline completes inference on a frame\n",
    "def completion_callback(infer_request: ov.InferRequest, user_data: Dict[str, Any],) -> None:\n",
    "    preprocess_meta = user_data['preprocess_meta']\n",
    "    \n",
    "    raw_outputs = {out.any_name: copy.deepcopy(res.data) for out, res in zip(infer_request.model_outputs, infer_request.output_tensors)}\n",
    "    frame = segmentation_model.postprocess(raw_outputs, preprocess_meta)\n",
    "\n",
    "    _, encoded_img = cv2.imencode(\".jpg\", frame, params=[cv2.IMWRITE_JPEG_QUALITY, 90])\n",
    "    # Create IPython image\n",
    "    i = display.Image(data=encoded_img)\n",
    "\n",
    "    # Display the image in this notebook\n",
    "    display.clear_output(wait=True)\n",
    "    display.display(i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create asynchronous inference queue and perform it [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded model to Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'MULTI:CPU,GPU'), value='MULTI:CPU,GPU') in 1.05 seconds.\n",
      "Total time to infer all frames: 1.881s\n",
      "Time per frame: 0.027659s (36.155 FPS)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "load_start_time = time.perf_counter()\n",
    "compiled_model = core.compile_model(segmentation_model.net, device.value)\n",
    "# Create asynchronous inference queue with optimal number of infer requests\n",
    "infer_queue = ov.AsyncInferQueue(compiled_model)\n",
    "infer_queue.set_callback(completion_callback)\n",
    "load_end_time = time.perf_counter()\n",
    "\n",
    "results = [None] * len(framebuf)\n",
    "frame_number = 0\n",
    "\n",
    "# Perform inference on every frame in the framebuffer\n",
    "start_time = time.time()\n",
    "for i, input_frame in enumerate(framebuf):\n",
    "    inputs, preprocessing_meta = segmentation_model.preprocess({segmentation_model.net.input(0): input_frame})\n",
    "    infer_queue.start_async(inputs, {'preprocess_meta': preprocessing_meta})\n",
    "\n",
    "# Wait until all inference requests in the AsyncInferQueue are completed\n",
    "infer_queue.wait_all()\n",
    "stop_time = time.time()\n",
    "\n",
    "# Calculate total inference time and FPS\n",
    "total_time = stop_time - start_time\n",
    "fps = len(framebuf) / total_time\n",
    "time_per_frame = 1 / fps \n",
    "\n",
    "print(f\"Loaded model to {device} in {load_end_time-load_start_time:.2f} seconds.\")\n",
    "\n",
    "print(f'Total time to infer all frames: {total_time:.3f}s')\n",
    "print(f'Time per frame: {time_per_frame:.6f}s ({fps:.3f} FPS)')"
   ]
  }
 ],
 "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.10.12"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "vscode": {
   "interpreter": {
    "hash": "cec18e25feb9469b5ff1085a8097bdcd86db6a4ac301d6aeff87d0f3e7ce4ca5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}