notebooks/104-model-tools/104-model-tools.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "artificial-discretion",
   "metadata": {},
   "source": [
    "# Working with Open Model Zoo Models\n",
    "This tutorial shows how to download a model from [Open Model Zoo](https://github.com/openvinotoolkit/open_model_zoo), convert it to OpenVINO™ IR format, show information about the model, and benchmark the model.\n",
    "\n",
    "#### Table of content:\n",
    "- [OpenVINO and Open Model Zoo Tools](#OpenVINO-and-Open-Model-Zoo-Tools-Uparrow)\n",
    "- [Preparation](#Preparation-Uparrow)\n",
    "    - [Model Name](#Model-Name-Uparrow)\n",
    "    - [Imports](#Imports-Uparrow)\n",
    "    - [Settings and Configuration](#Settings-and-Configuration-Uparrow)\n",
    "- [Download a Model from Open Model Zoo](#Download-a-Model-from-Open-Model-Zoo-Uparrow)\n",
    "- [Convert a Model to OpenVINO IR format](#Convert-a-Model-to-OpenVINO-IR-format-Uparrow)\n",
    "- [Get Model Information](#Get-Model-Information-Uparrow)\n",
    "- [Run Benchmark Tool](#Run-Benchmark-Tool-Uparrow)\n",
    "    - [Benchmark with Different Settings](#Benchmark-with-Different-Settings-Uparrow)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4dda33e",
   "metadata": {},
   "source": [
    "## OpenVINO and Open Model Zoo Tools [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "OpenVINO and Open Model Zoo tools are listed in the table below.\n",
    "\n",
    "| Tool             | Command             | Description                                             |\n",
    "|:-----------------|:--------------------|:--------------------------------------------------------|\n",
    "| Model Downloader | `omz_downloader`      | Download models from Open Model Zoo.                    |\n",
    "| Model Converter  | `omz_converter`       | Convert Open Model Zoo models to OpenVINO's IR format.  |\n",
    "| Info Dumper      | `omz_info_dumper`     | Print information about Open Model Zoo models.          |\n",
    "| Benchmark Tool   | `benchmark_app`       | Benchmark model performance by computing inference time.|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "57288459",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install openvino package\n",
    "%pip install -q \"openvino-dev>=2023.1.0\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec90f61-08f3-4417-8a6f-ec61c9e5955b",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Preparation [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "### Model Name [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Set `model_name` to the name of the Open Model Zoo model to use in this notebook. Refer to the list of [public](https://github.com/openvinotoolkit/open_model_zoo/blob/master/models/public/index.md) and [Intel](https://github.com/openvinotoolkit/open_model_zoo/blob/master/models/intel/index.md) pre-trained models for a full list of models that can be used. Set `model_name` to the model you want to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "21d6d2be-05a8-4c52-9ad9-af892a76db1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_name = \"resnet-50-pytorch\"\n",
    "model_name = \"mobilenet-v2-pytorch\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0206a22-dc33-4666-ab2b-86386b97caca",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "### Imports [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "impressed-uncertainty",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from pathlib import Path\n",
    "\n",
    "import openvino as ov\n",
    "from IPython.display import Markdown, display\n",
    "\n",
    "# Fetch `notebook_utils` module\n",
    "import urllib.request\n",
    "urllib.request.urlretrieve(\n",
    "    url='https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/main/notebooks/utils/notebook_utils.py',\n",
    "    filename='notebook_utils.py'\n",
    ")\n",
    "from notebook_utils import DeviceNotFoundAlert, NotebookAlert"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "parental-assets",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "### Settings and Configuration [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Set the file and directory paths. By default, this notebook downloads models from Open Model Zoo to the `open_model_zoo_models` directory in your `$HOME` directory. On Windows, the $HOME directory is usually `c:\\users\\username`, on Linux `/home/username`. To change the folder, change `base_model_dir` in the cell below.\n",
    "\n",
    "The following settings can be changed:\n",
    "\n",
    "* `base_model_dir`: Models will be downloaded into the `intel` and `public` folders in this directory.\n",
    "* `omz_cache_dir`: Cache folder for Open Model Zoo. Specifying a cache directory is not required for Model Downloader and Model Converter, but it speeds up subsequent downloads.\n",
    "* `precision`: If specified, only models with this precision will be downloaded and converted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "korean-agency",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "base_model_dir: model, omz_cache_dir: cache, gpu_availble: True\n"
     ]
    }
   ],
   "source": [
    "base_model_dir = Path(\"model\")\n",
    "omz_cache_dir = Path(\"cache\")\n",
    "precision = \"FP16\"\n",
    "\n",
    "# Check if an iGPU is available on this system to use with Benchmark App.\n",
    "core = ov.Core()\n",
    "gpu_available = \"GPU\" in core.available_devices\n",
    "\n",
    "print(\n",
    "    f\"base_model_dir: {base_model_dir}, omz_cache_dir: {omz_cache_dir}, gpu_availble: {gpu_available}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "judicial-preview",
   "metadata": {},
   "source": [
    "## Download a Model from Open Model Zoo [$\\Uparrow$](#Table-of-content:)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rising-interval",
   "metadata": {},
   "source": [
    "Specify, display and run the Model Downloader command to download the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "df2b0446-0c49-41cf-9f3f-dec1232249f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment the next line to show help in omz_downloader which explains the command-line options.\n",
    "\n",
    "# !omz_downloader --help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "556d0c12-15cf-492d-a1ed-41dff5090eff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Download command: `omz_downloader --name mobilenet-v2-pytorch --output_dir model --cache_dir cache`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Downloading mobilenet-v2-pytorch..."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "################|| Downloading mobilenet-v2-pytorch ||################\n",
      "\n",
      "========== Retrieving model/public/mobilenet-v2-pytorch/mobilenet_v2-b0353104.pth from the cache\n",
      "\n"
     ]
    }
   ],
   "source": [
    "download_command = (\n",
    "    f\"omz_downloader --name {model_name} --output_dir {base_model_dir} --cache_dir {omz_cache_dir}\"\n",
    ")\n",
    "display(Markdown(f\"Download command: `{download_command}`\"))\n",
    "display(Markdown(f\"Downloading {model_name}...\"))\n",
    "! $download_command"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proprietary-checklist",
   "metadata": {},
   "source": [
    "## Convert a Model to OpenVINO IR format [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "Specify, display and run the Model Converter command to convert the model to OpenVINO IR format. Model conversion may take a while. The output of the Model Converter command will be displayed. When the conversion is successful, the last lines of the output will include: `[ SUCCESS ] Generated IR version 11 model.` For downloaded models that are already in OpenVINO IR format, conversion will be skipped."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "11fe7461-90db-4585-b55f-b3df42b01274",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment the next line to show Help in omz_converter which explains the command-line options.\n",
    "\n",
    "# !omz_converter --help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "engaged-academy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Convert command: `omz_converter --name mobilenet-v2-pytorch --precisions FP16 --download_dir model --output_dir model`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Converting mobilenet-v2-pytorch..."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========== Converting mobilenet-v2-pytorch to ONNX\n",
      "Conversion to ONNX command: /home/ea/work/notebooks_convert/notebooks_conv_env/bin/python -- /home/ea/work/notebooks_convert/notebooks_conv_env/lib/python3.8/site-packages/openvino/model_zoo/internal_scripts/pytorch_to_onnx.py --model-name=mobilenet_v2 --weights=model/public/mobilenet-v2-pytorch/mobilenet_v2-b0353104.pth --import-module=torchvision.models --input-shape=1,3,224,224 --output-file=model/public/mobilenet-v2-pytorch/mobilenet-v2.onnx --input-names=data --output-names=prob\n",
      "\n",
      "ONNX check passed successfully.\n",
      "\n",
      "========== Converting mobilenet-v2-pytorch to IR (FP16)\n",
      "Conversion command: /home/ea/work/notebooks_convert/notebooks_conv_env/bin/python -- /home/ea/work/notebooks_convert/notebooks_conv_env/bin/mo --framework=onnx --output_dir=/tmp/tmpgpuw8ex1 --model_name=mobilenet-v2-pytorch --input=data '--mean_values=data[123.675,116.28,103.53]' '--scale_values=data[58.624,57.12,57.375]' --reverse_input_channels --output=prob --input_model=model/public/mobilenet-v2-pytorch/mobilenet-v2.onnx '--layout=data(NCHW)' '--input_shape=[1, 3, 224, 224]' --compress_to_fp16=True\n",
      "\n",
      "[ INFO ] Generated IR will be compressed to FP16. If you get lower accuracy, please consider disabling compression by removing argument --compress_to_fp16 or set it to false --compress_to_fp16=False.\n",
      "Find more information about compression to FP16 at https://docs.openvino.ai/latest/openvino_docs_MO_DG_FP16_Compression.html\n",
      "[ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11.\n",
      "Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/latest/openvino_2_0_transition_guide.html\n",
      "[ SUCCESS ] Generated IR version 11 model.\n",
      "[ SUCCESS ] XML file: /tmp/tmpgpuw8ex1/mobilenet-v2-pytorch.xml\n",
      "[ SUCCESS ] BIN file: /tmp/tmpgpuw8ex1/mobilenet-v2-pytorch.bin\n",
      "\n"
     ]
    }
   ],
   "source": [
    "convert_command = f\"omz_converter --name {model_name} --precisions {precision} --download_dir {base_model_dir} --output_dir {base_model_dir}\"\n",
    "display(Markdown(f\"Convert command: `{convert_command}`\"))\n",
    "display(Markdown(f\"Converting {model_name}...\"))\n",
    "\n",
    "! $convert_command"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa8d655f-215d-4e3c-adcb-e8fd4a2e8ab4",
   "metadata": {},
   "source": [
    "## Get Model Information [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "The Info Dumper prints the following information for Open Model Zoo models:\n",
    "\n",
    "* Model name\n",
    "* Description\n",
    "* Framework that was used to train the model\n",
    "* License URL\n",
    "* Precisions supported by the model\n",
    "* Subdirectory: the location of the downloaded model\n",
    "* Task type\n",
    "\n",
    "This information can be shown by running `omz_info_dumper --name model_name` in a terminal. The information can also be parsed and used in scripts. \n",
    "\n",
    "In the next cell, run Info Dumper and use `json` to load the information in a dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b8247daf-d3c5-4420-b4c8-d305ac4ace5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'mobilenet-v2-pytorch',\n",
       "  'composite_model_name': None,\n",
       "  'description': 'MobileNet V2 is image classification model pre-trained on ImageNet dataset. This is a PyTorch* implementation of MobileNetV2 architecture as described in the paper \"Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification, Detection and Segmentation\" <https://arxiv.org/abs/1801.04381>.\\nThe model input is a blob that consists of a single image of \"1, 3, 224, 224\" in \"RGB\" order.\\nThe model output is typical object classifier for the 1000 different classifications matching with those in the ImageNet database.',\n",
       "  'framework': 'pytorch',\n",
       "  'license_url': 'https://raw.githubusercontent.com/pytorch/vision/master/LICENSE',\n",
       "  'accuracy_config': '/home/ea/work/notebooks_convert/notebooks_conv_env/lib/python3.8/site-packages/openvino/model_zoo/models/public/mobilenet-v2-pytorch/accuracy-check.yml',\n",
       "  'model_config': '/home/ea/work/notebooks_convert/notebooks_conv_env/lib/python3.8/site-packages/openvino/model_zoo/models/public/mobilenet-v2-pytorch/model.yml',\n",
       "  'precisions': ['FP16', 'FP32'],\n",
       "  'quantization_output_precisions': ['FP16-INT8', 'FP32-INT8'],\n",
       "  'subdirectory': 'public/mobilenet-v2-pytorch',\n",
       "  'task_type': 'classification',\n",
       "  'input_info': [{'name': 'data',\n",
       "    'shape': [1, 3, 224, 224],\n",
       "    'layout': 'NCHW'}],\n",
       "  'model_stages': []}]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_info_output = %sx omz_info_dumper --name $model_name\n",
    "model_info = json.loads(model_info_output.get_nlstr())\n",
    "\n",
    "if len(model_info) > 1:\n",
    "    NotebookAlert(\n",
    "        f\"There are multiple IR files for the {model_name} model. The first model in the \"\n",
    "        \"omz_info_dumper output will be used for benchmarking. Change \"\n",
    "        \"`selected_model_info` in the cell below to select a different model from the list.\",\n",
    "        \"warning\",\n",
    "    )\n",
    "\n",
    "model_info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ea7e868-fd2d-4d11-9c87-7aa1f1301083",
   "metadata": {},
   "source": [
    "Having information of the model in a JSON file enables extraction of the path to the model directory, and building the path to the OpenVINO IR file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "de1a319e-bbef-414c-921d-60938b4a01a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model/public/mobilenet-v2-pytorch/FP16/mobilenet-v2-pytorch.xml exists: True\n"
     ]
    }
   ],
   "source": [
    "selected_model_info = model_info[0]\n",
    "model_path = (\n",
    "    base_model_dir\n",
    "    / Path(selected_model_info[\"subdirectory\"])\n",
    "    / Path(f\"{precision}/{selected_model_info['name']}.xml\")\n",
    ")\n",
    "print(model_path, \"exists:\", model_path.exists())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54e01154-f700-479f-9111-147c95595d46",
   "metadata": {},
   "source": [
    "## Run Benchmark Tool [$\\Uparrow$](#Table-of-content:)\n",
    "\n",
    "By default, Benchmark Tool runs inference for 60 seconds in asynchronous mode on CPU. It returns inference speed as latency (milliseconds per image) and throughput values (frames per second). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "282452e8-24c7-49c0-bdb2-10677971c30f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment the next line to show Help in benchmark_app which explains the command-line options.\n",
    "# !benchmark_app --help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9812b0c8-8cd0-4840-bca3-a28171d055b7",
   "metadata": {
    "tags": [],
    "test_replace": {
     "-t 15": "-t 3"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Benchmark command: `benchmark_app -m model/public/mobilenet-v2-pytorch/FP16/mobilenet-v2-pytorch.xml -t 15`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Benchmarking mobilenet-v2-pytorch on CPU with async inference for 15 seconds..."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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 ] \n",
      "[ INFO ] \n",
      "[Step 3/11] Setting device configuration\n",
      "[ WARNING ] Performance hint was not explicitly specified in command line. Device(CPU) performance hint will be set to PerformanceMode.THROUGHPUT.\n",
      "[Step 4/11] Reading model files\n",
      "[ INFO ] Loading model files\n",
      "[ INFO ] Read model took 18.31 ms\n",
      "[ INFO ] Original model I/O parameters:\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     data (node: data) : f32 / [N,C,H,W] / [1,3,224,224]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     prob (node: prob) : f32 / [...] / [1,1000]\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 ]     data (node: data) : u8 / [N,C,H,W] / [1,3,224,224]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     prob (node: prob) : f32 / [...] / [1,1000]\n",
      "[Step 7/11] Loading the model to the device\n",
      "[ INFO ] Compile model took 153.97 ms\n",
      "[Step 8/11] Querying optimal runtime parameters\n",
      "[ INFO ] Model:\n",
      "[ INFO ]   NETWORK_NAME: torch_jit\n",
      "[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 12\n",
      "[ INFO ]   NUM_STREAMS: 12\n",
      "[ INFO ]   AFFINITY: Affinity.CORE\n",
      "[ INFO ]   INFERENCE_NUM_THREADS: 36\n",
      "[ INFO ]   PERF_COUNT: False\n",
      "[ INFO ]   INFERENCE_PRECISION_HINT: <Type: 'float32'>\n",
      "[ INFO ]   PERFORMANCE_HINT: PerformanceMode.THROUGHPUT\n",
      "[ INFO ]   EXECUTION_MODE_HINT: ExecutionMode.PERFORMANCE\n",
      "[ INFO ]   PERFORMANCE_HINT_NUM_REQUESTS: 0\n",
      "[ INFO ]   ENABLE_CPU_PINNING: True\n",
      "[ INFO ]   SCHEDULING_CORE_TYPE: SchedulingCoreType.ANY_CORE\n",
      "[ INFO ]   ENABLE_HYPER_THREADING: True\n",
      "[ INFO ]   EXECUTION_DEVICES: ['CPU']\n",
      "[Step 9/11] Creating infer requests and preparing input tensors\n",
      "[ WARNING ] No input files were given for input 'data'!. This input will be filled with random values!\n",
      "[ INFO ] Fill input 'data' with random values \n",
      "[Step 10/11] Measuring performance (Start inference asynchronously, 12 inference requests, limits: 15000 ms duration)\n",
      "[ INFO ] Benchmarking in inference only mode (inputs filling are not included in measurement loop).\n",
      "[ INFO ] First inference took 6.61 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU']\n",
      "[ INFO ] Count:            23880 iterations\n",
      "[ INFO ] Duration:         15008.51 ms\n",
      "[ INFO ] Latency:\n",
      "[ INFO ]    Median:        7.04 ms\n",
      "[ INFO ]    Average:       7.37 ms\n",
      "[ INFO ]    Min:           4.25 ms\n",
      "[ INFO ]    Max:           24.12 ms\n",
      "[ INFO ] Throughput:   1591.10 FPS\n"
     ]
    }
   ],
   "source": [
    "benchmark_command = f\"benchmark_app -m {model_path} -t 15\"\n",
    "display(Markdown(f\"Benchmark command: `{benchmark_command}`\"))\n",
    "display(Markdown(f\"Benchmarking {model_name} on CPU with async inference for 15 seconds...\"))\n",
    "\n",
    "! $benchmark_command"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75891996-cf53-4c76-ad3c-5fb468ccd7bb",
   "metadata": {},
   "source": [
    "### Benchmark with Different Settings [$\\Uparrow$](#Table-of-content:)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d64dd7-789d-4536-ab8f-84999c73afaf",
   "metadata": {},
   "source": [
    "The `benchmark_app` tool displays logging information that is not always necessary. A more compact result is achieved when the output is parsed with `json`.\n",
    "\n",
    "The following cells show some examples of `benchmark_app` with different parameters. Below are some useful parameters:\n",
    "\n",
    "- `-d` A device to use for inference. For example: CPU, GPU, MULTI. Default: CPU.\n",
    "- `-t` Time expressed in number of seconds to run inference. Default: 60.\n",
    "- `-api` Use asynchronous (async) or synchronous (sync) inference. Default: async.\n",
    "- `-b` Batch size. Default: 1.\n",
    "\n",
    "\n",
    "Run `! benchmark_app --help` to get an overview of all possible command-line parameters.\n",
    "\n",
    "In the next cell, define the `benchmark_model()` function that calls `benchmark_app`. This makes it easy to try different combinations. In the cell below that, you display available devices on the system.\n",
    "\n",
    "> **Note**: In this notebook, `benchmark_app` runs for 15 seconds to give a quick indication of performance. For more accurate performance, it is recommended to run inference for at least one minute by setting the `t` parameter to 60 or higher, and run `benchmark_app` in a terminal/command prompt after closing other applications. Copy the **benchmark command** and paste it in a command prompt where you have activated the `openvino_env` environment. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7742390e-df71-45e1-9572-f3cbaa576ec3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def benchmark_model(model_xml, device=\"CPU\", seconds=60, api=\"async\", batch=1):\n",
    "    core = ov.Core()\n",
    "    model_path = Path(model_xml)\n",
    "    if (\"GPU\" in device) and (\"GPU\" not in core.available_devices):\n",
    "        DeviceNotFoundAlert(\"GPU\")\n",
    "    else:\n",
    "        benchmark_command = f\"benchmark_app -m {model_path} -d {device} -t {seconds} -api {api} -b {batch}\"\n",
    "        display(Markdown(f\"**Benchmark {model_path.name} with {device} for {seconds} seconds with {api} inference**\"))\n",
    "        display(Markdown(f\"Benchmark command: `{benchmark_command}`\"))\n",
    "\n",
    "        benchmark_output = %sx $benchmark_command\n",
    "        print(\"command ended\")\n",
    "        benchmark_result = [line for line in benchmark_output\n",
    "                            if not (line.startswith(r\"[\") or line.startswith(\"      \") or line == \"\")]\n",
    "        print(\"\\n\".join(benchmark_result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "298904f0-638c-4958-876a-3b8c8bd06518",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU: Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz\n",
      "GPU: NVIDIA GeForce GTX 1080 Ti (dGPU)\n"
     ]
    }
   ],
   "source": [
    "core = ov.Core()\n",
    "\n",
    "# Show devices available for OpenVINO Runtime\n",
    "for device in core.available_devices:\n",
    "    device_name = core.get_property(device, \"FULL_DEVICE_NAME\")\n",
    "    print(f\"{device}: {device_name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "486919e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "benchmark_model(model_path, device=\"CPU\", seconds=15, api=\"async\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b1d4c745-a4c2-4242-a2e7-fff1eb098b98",
   "metadata": {
    "tags": [],
    "test_replace": {
     "seconds=15": "seconds=3"
    }
   },
   "outputs": [],
   "source": [
    "benchmark_model(model_path, device=\"AUTO\", seconds=15, api=\"async\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5d47e1cf-cb2f-4138-928c-b56891d5c318",
   "metadata": {
    "tags": [],
    "test_replace": {
     "seconds=15": "seconds=3"
    }
   },
   "outputs": [],
   "source": [
    "benchmark_model(model_path, device=\"GPU\", seconds=15, api=\"async\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4a1b0bb2-87c7-44c9-92bf-1d95aa1500a1",
   "metadata": {
    "tags": [],
    "test_replace": {
     "seconds=15": "seconds=3"
    }
   },
   "outputs": [],
   "source": [
    "benchmark_model(model_path, device=\"MULTI:CPU,GPU\", seconds=15, api=\"async\")"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}