notebooks/301-tensorflow-training-openvino/301-tensorflow-training-openvino-nncf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KwQtSOz0VrVX",
    "tags": []
   },
   "source": [
    "# Post-Training Quantization with TensorFlow Classification Model\n",
    "\n",
    "This example demonstrates how to quantize the OpenVINO model that was created in [301-tensorflow-training-openvino notebook](301-tensorflow-training-openvino.ipynb), to improve inference speed. Quantization is performed with [Post-training Quantization with NNCF](https://docs.openvino.ai/nightly/basic_quantization_flow.html). A custom dataloader and metric will be defined, and accuracy and performance will be computed for the original IR model and the quantized model.\n",
    "\n",
    "#### Table of contents:\n",
    "- [Preparation](#Preparation)\n",
    "    - [Imports](#Imports)\n",
    "- [Post-training Quantization with NNCF](#Post-training-Quantization-with-NNCF)\n",
    "    - [Select inference device](#Select-inference-device)\n",
    "- [Compare Metrics](#Compare-Metrics)\n",
    "- [Run Inference on Quantized Model](#Run-Inference-on-Quantized-Model)\n",
    "- [Compare Inference Speed](#Compare-Inference-Speed)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KwQtSOz0VrVX"
   },
   "source": [
    "## Preparation\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "The notebook requires that the training notebook has been run and that the Intermediate Representation (IR) models are created. If the IR models do not exist, running the next cell will run the training notebook. This will take a while."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install -q tensorflow Pillow matplotlib numpy tqdm nncf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "hide_output"
    ],
    "test_replace": {
     "301-tensorflow-training-openvino.ipynb": "test_301-tensorflow-training-openvino.ipynb"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-19 14:24:34.067196: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-07-19 14:24:34.108011: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-07-19 14:24:34.842368: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "model_xml = Path(\"model/flower/flower_ir.xml\")\n",
    "dataset_url = (\n",
    "    \"https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\"\n",
    ")\n",
    "data_dir = Path(tf.keras.utils.get_file(\"flower_photos\", origin=dataset_url, untar=True))\n",
    "\n",
    "if not model_xml.exists():\n",
    "    print(\"Executing training notebook. This will take a while...\")\n",
    "    %run 301-tensorflow-training-openvino.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xG4gTnxHXn3z"
   },
   "source": [
    "### Imports\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "The Post Training Quantization API is implemented in the `nncf` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Wi2JvOs1Xn3z",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, tensorflow, onnx, openvino\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import nncf\n",
    "from openvino.runtime import Core\n",
    "from openvino.runtime import serialize\n",
    "from PIL import Image\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "sys.path.append(\"../utils\")\n",
    "from notebook_utils import download_file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mgaRN7mTXn30"
   },
   "source": [
    "## Post-training Quantization with NNCF\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "[NNCF](https://github.com/openvinotoolkit/nncf) provides a suite of advanced algorithms for Neural Networks inference optimization in OpenVINO with minimal accuracy drop.\n",
    "\n",
    "Create a quantized model from the pre-trained FP32 model and the calibration dataset. The optimization process contains the following steps:\n",
    "\n",
    "1. Create a Dataset for quantization.\n",
    "2. Run nncf.quantize for getting an optimized model.\n",
    "\n",
    "The validation dataset already defined in the training notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 3670 files belonging to 5 classes.\n",
      "Using 734 files for validation.\n",
      "<class 'tensorflow.python.framework.ops.EagerTensor'> <class 'tensorflow.python.framework.ops.EagerTensor'>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-19 14:24:37.330443: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1956] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n",
      "2023-07-19 14:24:37.392191: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'Placeholder/_4' with dtype int32 and shape [734]\n",
      "\t [[{{node Placeholder/_4}}]]\n",
      "2023-07-19 14:24:37.392450: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'Placeholder/_0' with dtype string and shape [734]\n",
      "\t [[{{node Placeholder/_0}}]]\n"
     ]
    }
   ],
   "source": [
    "img_height = 180\n",
    "img_width = 180\n",
    "val_dataset = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "  data_dir,\n",
    "  validation_split=0.2,\n",
    "  subset=\"validation\",\n",
    "  seed=123,\n",
    "  image_size=(img_height, img_width),\n",
    "  batch_size=1\n",
    ")\n",
    "\n",
    "for a, b in val_dataset:\n",
    "    print(type(a), type(b))\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The validation dataset can be reused in quantization process. But it returns a tuple (images, labels), whereas calibration_dataset should only return images. The transformation function helps to transform a user validation dataset to the calibration dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def transform_fn(data_item):\n",
    "    \"\"\"\n",
    "    The transformation function transforms a data item into model input data.\n",
    "    This function should be passed when the data item cannot be used as model's input.\n",
    "    \"\"\"\n",
    "    images, _ = data_item\n",
    "    return images.numpy()\n",
    "\n",
    "\n",
    "calibration_dataset = nncf.Dataset(val_dataset, transform_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download Intermediate Representation (IR) model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "core = Core()\n",
    "ir_model = core.read_model(model_xml)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use [Basic Quantization Flow](https://docs.openvino.ai/2023.3/basic_quantization_flow.html). To use the most advanced quantization flow that allows to apply 8-bit quantization to the model with accuracy control see [Quantizing with accuracy control](https://docs.openvino.ai/2023.3/quantization_w_accuracy_control.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Statistics collection:  73%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████                                                         | 734/1000 [00:03<00:01, 185.17it/s]\n",
      "Biases correction: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:01<00:00,  3.86it/s]\n"
     ]
    }
   ],
   "source": [
    "quantized_model = nncf.quantize(\n",
    "    ir_model,\n",
    "    calibration_dataset,\n",
    "    subset_size=1000\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save quantized model to benchmark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "compressed_model_dir = Path(\"model/optimized\")\n",
    "compressed_model_dir.mkdir(parents=True, exist_ok=True)\n",
    "compressed_model_xml = compressed_model_dir / \"flower_ir.xml\"\n",
    "serialize(quantized_model, str(compressed_model_xml))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select inference device\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "select device from dropdown list for running inference using OpenVINO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc8476bfe52a4dc5a2ecc2c18098e0f5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'AUTO'), value='AUTO')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "\n",
    "device = widgets.Dropdown(\n",
    "    options=core.available_devices + [\"AUTO\"],\n",
    "    value='AUTO',\n",
    "    description='Device:',\n",
    "    disabled=False,\n",
    ")\n",
    "\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare Metrics\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Define a metric to determine the performance of the model.\n",
    "\n",
    "For this demo we define validate function to compute accuracy metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def validate(model, validation_loader):\n",
    "    \"\"\"\n",
    "    Evaluate model and compute accuracy metrics.\n",
    "\n",
    "    :param model: Model to validate\n",
    "    :param validation_loader: Validation dataset\n",
    "    :returns: Accuracy scores\n",
    "    \"\"\"\n",
    "    predictions = []\n",
    "    references = []\n",
    "\n",
    "    output = model.outputs[0]\n",
    "\n",
    "    for images, target in validation_loader:\n",
    "        pred = model(images.numpy())[output]\n",
    "\n",
    "        predictions.append(np.argmax(pred, axis=1))\n",
    "        references.append(target)\n",
    "\n",
    "    predictions = np.concatenate(predictions, axis=0)\n",
    "    references = np.concatenate(references, axis=0)\n",
    "\n",
    "    scores = accuracy_score(references, predictions)\n",
    "\n",
    "    return scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate accuracy for the original model and the quantized model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the original model: 0.732\n",
      "Accuracy of the quantized model: 0.736\n"
     ]
    }
   ],
   "source": [
    "original_compiled_model = core.compile_model(model=ir_model, device_name=device.value)\n",
    "quantized_compiled_model = core.compile_model(model=quantized_model, device_name=device.value)\n",
    "\n",
    "original_accuracy = validate(original_compiled_model, val_dataset)\n",
    "quantized_accuracy = validate(quantized_compiled_model, val_dataset)\n",
    "\n",
    "print(f\"Accuracy of the original model: {original_accuracy:.3f}\")\n",
    "print(f\"Accuracy of the quantized model: {quantized_accuracy:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare file size of the models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original model size: 7791.65 KB\n",
      "Quantized model size: 3897.08 KB\n"
     ]
    }
   ],
   "source": [
    "original_model_size = model_xml.with_suffix(\".bin\").stat().st_size / 1024\n",
    "quantized_model_size = compressed_model_xml.with_suffix(\".bin\").stat().st_size / 1024\n",
    "\n",
    "print(f\"Original model size: {original_model_size:.2f} KB\")\n",
    "print(f\"Quantized model size: {quantized_model_size:.2f} KB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we can see that the original and quantized models have similar accuracy with a much smaller size of the quantized model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DJbP4pdEXn30"
   },
   "source": [
    "## Run Inference on Quantized Model\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Copy the preprocess function from the training notebook and run inference on the quantized model with Inference Engine. See the [OpenVINO API tutorial](../002-openvino-api/002-openvino-api.ipynb) for more information about running inference with Inference Engine Python API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pre_process_image(imagePath, img_height=180):\n",
    "    # Model input format\n",
    "    n, c, h, w = [1, 3, img_height, img_height]\n",
    "    image = Image.open(imagePath)\n",
    "    image = image.resize((h, w), resample=Image.BILINEAR)\n",
    "\n",
    "    # Convert to array and change data layout from HWC to CHW\n",
    "    image = np.array(image)\n",
    "\n",
    "    input_image = image.reshape((n, h, w, c))\n",
    "\n",
    "    return input_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "q8lGxI-1Xn31"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'output/A_Close_Up_Photo_of_a_Dandelion.jpg' already exists.\n",
      "input image shape: (1, 180, 180, 3)\n",
      "input layer shape: [1,180,180,3]\n",
      "This image most likely belongs to dandelion with a 99.01 percent confidence.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the names of the input and output layer\n",
    "# model_pot = ie.read_model(model=\"model/optimized/flower_ir.xml\")\n",
    "input_layer = quantized_compiled_model.input(0)\n",
    "output_layer = quantized_compiled_model.output(0)\n",
    "\n",
    "# Get the class names: a list of directory names in alphabetical order\n",
    "class_names = sorted([item.name for item in Path(data_dir).iterdir() if item.is_dir()])\n",
    "\n",
    "# Run inference on an input image...\n",
    "inp_img_url = (\n",
    "    \"https://upload.wikimedia.org/wikipedia/commons/4/48/A_Close_Up_Photo_of_a_Dandelion.jpg\"\n",
    ")\n",
    "directory = \"output\"\n",
    "inp_file_name = \"A_Close_Up_Photo_of_a_Dandelion.jpg\"\n",
    "file_path = Path(directory)/Path(inp_file_name)\n",
    "# Download the image if it does not exist yet\n",
    "if not Path(inp_file_name).exists():\n",
    "    download_file(inp_img_url, inp_file_name, directory=directory)\n",
    "\n",
    "# Pre-process the image and get it ready for inference.\n",
    "input_image = pre_process_image(imagePath=file_path)\n",
    "print(f'input image shape: {input_image.shape}')\n",
    "print(f'input layer shape: {input_layer.shape}')\n",
    "\n",
    "res = quantized_compiled_model([input_image])[output_layer]\n",
    "\n",
    "score = tf.nn.softmax(res[0])\n",
    "\n",
    "# Show the results\n",
    "image = Image.open(file_path)\n",
    "plt.imshow(image)\n",
    "print(\n",
    "    \"This image most likely belongs to {} with a {:.2f} percent confidence.\".format(\n",
    "        class_names[np.argmax(score)], 100 * np.max(score)\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare Inference Speed\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Measure inference speed with the [OpenVINO Benchmark App](https://docs.openvino.ai/2023.3/openvino_sample_benchmark_tool.html).\n",
    "\n",
    "Benchmark App is a command line tool that measures raw inference performance for a specified OpenVINO IR model. Run `benchmark_app --help` to see a list of available parameters. By default, Benchmark App tests the performance of the model specified with the `-m` parameter with asynchronous inference on CPU, for one minute. Use the `-d` parameter to test performance on a different device, for example an Intel integrated Graphics (iGPU), and `-t` to set the number of seconds to run inference. See the [documentation](https://docs.openvino.ai/2023.3/openvino_sample_benchmark_tool.html) for more information.\n",
    "\n",
    "This tutorial uses a wrapper function from [Notebook Utils](https://github.com/openvinotoolkit/openvino_notebooks/blob/main/notebooks/utils/notebook_utils.ipynb). It prints the `benchmark_app` command with the chosen parameters.\n",
    "\n",
    "In the next cells, inference speed will be measured for the original and quantized model on CPU. If an iGPU is available, inference speed will be measured for CPU+GPU as well. The number of seconds is set to 15.\n",
    "\n",
    "> **NOTE**: For the most accurate performance estimation, it is recommended to run `benchmark_app` in a terminal/command prompt after closing other applications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device information:\n",
      "Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz\n",
      "NVIDIA GeForce GTX 1080 Ti (dGPU)\n"
     ]
    }
   ],
   "source": [
    "# print the available devices on this system\n",
    "print(\"Device information:\")\n",
    "print(core.get_property(\"CPU\", \"FULL_DEVICE_NAME\"))\n",
    "if \"GPU\" in core.available_devices:\n",
    "    print(core.get_property(\"GPU\", \"FULL_DEVICE_NAME\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "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.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] \n",
      "[ INFO ] Device info:\n",
      "[ INFO ] CPU\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-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 4.29 ms\n",
      "[ INFO ] Original model I/O parameters:\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     sequential_1_input (node: sequential_1_input) : f32 / [...] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\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 ]     sequential_1_input (node: sequential_1_input) : u8 / [N,H,W,C] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\n",
      "[Step 7/11] Loading the model to the device\n",
      "[ INFO ] Compile model took 58.01 ms\n",
      "[Step 8/11] Querying optimal runtime parameters\n",
      "[ INFO ] Model:\n",
      "[ INFO ]   NETWORK_NAME: TensorFlow_Frontend_IR\n",
      "[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 18\n",
      "[ INFO ]   NUM_STREAMS: 18\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 'sequential_1_input'!. This input will be filled with random values!\n",
      "[ INFO ] Fill input 'sequential_1_input' with random values \n",
      "[Step 10/11] Measuring performance (Start inference asynchronously, 18 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 7.57 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU']\n",
      "[ INFO ] Count:            66240 iterations\n",
      "[ INFO ] Duration:         15009.58 ms\n",
      "[ INFO ] Latency:\n",
      "[ INFO ]    Median:        3.49 ms\n",
      "[ INFO ]    Average:       3.85 ms\n",
      "[ INFO ]    Min:           1.54 ms\n",
      "[ INFO ]    Max:           57.73 ms\n",
      "[ INFO ] Throughput:   4413.18 FPS\n"
     ]
    }
   ],
   "source": [
    "# Original model - CPU\n",
    "! benchmark_app -m $model_xml -d CPU -t 15 -api async"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "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.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] \n",
      "[ INFO ] Device info:\n",
      "[ INFO ] CPU\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-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 7.79 ms\n",
      "[ INFO ] Original model I/O parameters:\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     sequential_1_input (node: sequential_1_input) : f32 / [...] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\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 ]     sequential_1_input (node: sequential_1_input) : u8 / [N,H,W,C] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\n",
      "[Step 7/11] Loading the model to the device\n",
      "[ INFO ] Compile model took 43.27 ms\n",
      "[Step 8/11] Querying optimal runtime parameters\n",
      "[ INFO ] Model:\n",
      "[ INFO ]   NETWORK_NAME: TensorFlow_Frontend_IR\n",
      "[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 18\n",
      "[ INFO ]   NUM_STREAMS: 18\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 'sequential_1_input'!. This input will be filled with random values!\n",
      "[ INFO ] Fill input 'sequential_1_input' with random values \n",
      "[Step 10/11] Measuring performance (Start inference asynchronously, 18 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 1.41 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU']\n",
      "[ INFO ] Count:            213894 iterations\n",
      "[ INFO ] Duration:         15001.08 ms\n",
      "[ INFO ] Latency:\n",
      "[ INFO ]    Median:        1.03 ms\n",
      "[ INFO ]    Average:       1.11 ms\n",
      "[ INFO ]    Min:           0.60 ms\n",
      "[ INFO ]    Max:           26.98 ms\n",
      "[ INFO ] Throughput:   14258.57 FPS\n"
     ]
    }
   ],
   "source": [
    "# Quantized model - CPU\n",
    "! benchmark_app -m $compressed_model_xml -d CPU -t 15 -api async"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-0eZaw1W5-wt"
   },
   "source": [
    "**Benchmark on MULTI:CPU,GPU**\n",
    "\n",
    "With a recent Intel CPU, the best performance can often be achieved by doing inference on both the CPU and the iGPU, with OpenVINO's [Multi Device Plugin](https://docs.openvino.ai/2021.4/openvino_docs_IE_DG_supported_plugins_MULTI.html). It takes a bit longer to load a model on GPU than on CPU, so this benchmark will take a bit longer to complete than the CPU benchmark, when run for the first time. Benchmark App supports caching, by specifying the `--cdir` parameter. In the cells below, the model will cached to the `model_cache` directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "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.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] \n",
      "[ INFO ] Device info:\n",
      "[ INFO ] CPU\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] GPU\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] MULTI\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-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.THROUGHPUT.\n",
      "[Step 4/11] Reading model files\n",
      "[ INFO ] Loading model files\n",
      "[ INFO ] Read model took 4.36 ms\n",
      "[ INFO ] Original model I/O parameters:\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     sequential_1_input (node: sequential_1_input) : f32 / [...] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\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 ]     sequential_1_input (node: sequential_1_input) : u8 / [N,H,W,C] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\n",
      "[Step 7/11] Loading the model to the device\n",
      "ptxas error   : Entry function 'permute_tile_8x8_4x4_17198056047416626451_0' uses too much shared data (0xc020 bytes, 0xc000 max)\n",
      "\n",
      "[ INFO ] Compile model took 429.44 ms\n",
      "[Step 8/11] Querying optimal runtime parameters\n",
      "[ INFO ] Model:\n",
      "[ INFO ]   PERFORMANCE_HINT: PerformanceMode.THROUGHPUT\n",
      "[ INFO ]   NETWORK_NAME: TensorFlow_Frontend_IR\n",
      "[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 22\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: 18\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: TensorFlow_Frontend_IR\n",
      "[ INFO ]     OPTIMAL_NUMBER_OF_INFER_REQUESTS: 18\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: TensorFlow_Frontend_IR\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 'sequential_1_input'!. This input will be filled with random values!\n",
      "[ INFO ] Fill input 'sequential_1_input' with random values \n",
      "[Step 10/11] Measuring performance (Start inference asynchronously, 22 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 9.69 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU', 'GPU']\n",
      "[ INFO ] Count:            72094 iterations\n",
      "[ INFO ] Duration:         15007.08 ms\n",
      "[ INFO ] Throughput:   4804.00 FPS\n"
     ]
    }
   ],
   "source": [
    "# Original model - MULTI:CPU,GPU\n",
    "if \"GPU\" in core.available_devices:\n",
    "    ! benchmark_app -m $model_xml -d MULTI:CPU,GPU -t 15 -api async\n",
    "else:\n",
    "    print(\"A supported integrated GPU is not available on this system.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "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.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] \n",
      "[ INFO ] Device info:\n",
      "[ INFO ] CPU\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] GPU\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-releases/2023/0\n",
      "[ INFO ] MULTI\n",
      "[ INFO ] Build ................................. 2023.0.1-11005-fa1c41994f3-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.THROUGHPUT.\n",
      "[Step 4/11] Reading model files\n",
      "[ INFO ] Loading model files\n",
      "[ INFO ] Read model took 4.70 ms\n",
      "[ INFO ] Original model I/O parameters:\n",
      "[ INFO ] Model inputs:\n",
      "[ INFO ]     sequential_1_input (node: sequential_1_input) : f32 / [...] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\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 ]     sequential_1_input (node: sequential_1_input) : u8 / [N,H,W,C] / [1,180,180,3]\n",
      "[ INFO ] Model outputs:\n",
      "[ INFO ]     outputs (node: sequential_2/outputs/BiasAdd) : f32 / [...] / [1,5]\n",
      "[Step 7/11] Loading the model to the device\n",
      "1 warning generated.\n",
      "1 warning generated.\n",
      "5 warnings generated.\n",
      "[ INFO ] Compile model took 383.53 ms\n",
      "[Step 8/11] Querying optimal runtime parameters\n",
      "[ INFO ] Model:\n",
      "[ INFO ]   PERFORMANCE_HINT: PerformanceMode.THROUGHPUT\n",
      "[ INFO ]   NETWORK_NAME: TensorFlow_Frontend_IR\n",
      "[ INFO ]   OPTIMAL_NUMBER_OF_INFER_REQUESTS: 274\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: 18\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: TensorFlow_Frontend_IR\n",
      "[ INFO ]     OPTIMAL_NUMBER_OF_INFER_REQUESTS: 18\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: TensorFlow_Frontend_IR\n",
      "[ INFO ]     OPTIMAL_NUMBER_OF_INFER_REQUESTS: 256\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 'sequential_1_input'!. This input will be filled with random values!\n",
      "[ INFO ] Fill input 'sequential_1_input' with random values \n",
      "[Step 10/11] Measuring performance (Start inference asynchronously, 274 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 2.22 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU', 'GPU']\n",
      "[ INFO ] Count:            202760 iterations\n",
      "[ INFO ] Duration:         15338.85 ms\n",
      "[ INFO ] Throughput:   13218.72 FPS\n"
     ]
    }
   ],
   "source": [
    "# Quantized model - MULTI:CPU,GPU\n",
    "if \"GPU\" in core.available_devices:\n",
    "    ! benchmark_app -m $compressed_model_xml -d MULTI:CPU,GPU -t 15 -api async\n",
    "else:\n",
    "    print(\"A supported integrated GPU is not available on this system.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device information:\n",
      "Intel(R) Core(TM) i9-10980XE CPU @ 3.00GHz\n",
      "NVIDIA GeForce GTX 1080 Ti (dGPU)\n"
     ]
    }
   ],
   "source": [
    "# print the available devices on this system\n",
    "print(\"Device information:\")\n",
    "print(core.get_property(\"CPU\", \"FULL_DEVICE_NAME\"))\n",
    "if \"GPU\" in core.available_devices:\n",
    "    print(core.get_property(\"GPU\", \"FULL_DEVICE_NAME\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-0eZaw1W5-wt"
   },
   "source": [
    "**Original IR model - CPU**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "tags": [],
    "test_replace": {
     "-t 15": "-t 3"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ INFO ] Count:            67410 iterations\n",
      "[ INFO ] Duration:         15003.10 ms\n",
      "[ INFO ] Latency:\n",
      "[ INFO ]    Median:        3.51 ms\n",
      "[ INFO ]    Average:       3.78 ms\n",
      "[ INFO ]    Min:           1.46 ms\n",
      "[ INFO ]    Max:           27.97 ms\n",
      "[ INFO ] Throughput:   4493.07 FPS\n"
     ]
    }
   ],
   "source": [
    "benchmark_output = %sx benchmark_app -m $model_xml -t 15 -api async\n",
    "# Remove logging info from benchmark_app output and show only the results\n",
    "benchmark_result = benchmark_output[-8:]\n",
    "print(\"\\n\".join(benchmark_result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-0eZaw1W5-wt"
   },
   "source": [
    "**Quantized IR model - CPU**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "tags": [],
    "test_replace": {
     "-t 15": "-t 3"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ INFO ] Count:            218736 iterations\n",
      "[ INFO ] Duration:         15002.12 ms\n",
      "[ INFO ] Latency:\n",
      "[ INFO ]    Median:        1.03 ms\n",
      "[ INFO ]    Average:       1.09 ms\n",
      "[ INFO ]    Min:           0.59 ms\n",
      "[ INFO ]    Max:           23.43 ms\n",
      "[ INFO ] Throughput:   14580.34 FPS\n"
     ]
    }
   ],
   "source": [
    "benchmark_output = %sx benchmark_app -m $compressed_model_xml -t 15 -api async\n",
    "# Remove logging info from benchmark_app output and show only the results\n",
    "benchmark_result = benchmark_output[-8:]\n",
    "print(\"\\n\".join(benchmark_result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-0eZaw1W5-wt"
   },
   "source": [
    "**Original IR model - MULTI:CPU,GPU**\n",
    "\n",
    "With a recent Intel CPU, the best performance can often be achieved by doing inference on both the CPU and the iGPU, with OpenVINO's [Multi Device Plugin](https://docs.openvino.ai/2023.3/openvino_docs_OV_UG_Running_on_multiple_devices.html). It takes a bit longer to load a model on GPU than on CPU, so this benchmark will take a bit longer to complete than the CPU benchmark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "tags": [],
    "test_replace": {
     "-t 15": "-t 3"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Step 10/11] Measuring performance (Start inference asynchronously, 22 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 10.47 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU', 'GPU']\n",
      "[ INFO ] Count:            72292 iterations\n",
      "[ INFO ] Duration:         15005.20 ms\n",
      "[ INFO ] Throughput:   4817.80 FPS\n"
     ]
    }
   ],
   "source": [
    "if \"GPU\" in core.available_devices:\n",
    "    benchmark_output = %sx benchmark_app -m $model_xml -d MULTI:CPU,GPU -t 15 -api async\n",
    "    # Remove logging info from benchmark_app output and show only the results\n",
    "    benchmark_result = benchmark_output[-8:]\n",
    "    print(\"\\n\".join(benchmark_result))\n",
    "else:\n",
    "    print(\"An GPU is not available on this system.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-0eZaw1W5-wt"
   },
   "source": [
    "**Quantized IR model - MULTI:CPU,GPU**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "-0eZaw1W5-wt",
    "tags": [],
    "test_replace": {
     "-t 15": "-t 3"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Step 10/11] Measuring performance (Start inference asynchronously, 274 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 2.62 ms\n",
      "[Step 11/11] Dumping statistics report\n",
      "[ INFO ] Execution Devices:['CPU', 'GPU']\n",
      "[ INFO ] Count:            204678 iterations\n",
      "[ INFO ] Duration:         15358.70 ms\n",
      "[ INFO ] Throughput:   13326.52 FPS\n"
     ]
    }
   ],
   "source": [
    "if \"GPU\" in core.available_devices:\n",
    "    benchmark_output = %sx benchmark_app -m $compressed_model_xml -d MULTI:CPU,GPU -t 15 -api async\n",
    "    # Remove logging info from benchmark_app output and show only the results\n",
    "    benchmark_result = benchmark_output[-8:]\n",
    "    print(\"\\n\".join(benchmark_result))\n",
    "else:\n",
    "    print(\"An GPU is not available on this system.\")"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "301-tensorflow-training-openvino-pot.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "interpreter": {
   "hash": "8e25c8ed6cc2cfe6c8620be5042bb64fac4c236f57496fb5eb68e9ea1795f1fe"
  },
  "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"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "bc8476bfe52a4dc5a2ecc2c18098e0f5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "DropdownModel",
      "state": {
       "_options_labels": [
        "CPU",
        "GPU",
        "AUTO"
       ],
       "description": "Device:",
       "index": 2,
       "layout": "IPY_MODEL_e0992a9fcc774345b7fd4215849e0c8d",
       "style": "IPY_MODEL_bd70d2e90e63415ebeccd4a9cfb192a4"
      }
     },
     "bd70d2e90e63415ebeccd4a9cfb192a4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "e0992a9fcc774345b7fd4215849e0c8d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}