notebooks/115-async-api/115-async-api.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Asynchronous Inference with OpenVINO™\n",
    "This notebook demonstrates how to use the [Async API](https://docs.openvino.ai/nightly/openvino_docs_deployment_optimization_guide_common.html) for asynchronous execution with OpenVINO.\n",
    "\n",
    "OpenVINO Runtime supports inference in either synchronous or asynchronous mode. The key advantage of the Async API is that when a device is busy with inference, the application can perform other tasks in parallel (for example, populating inputs or scheduling other requests) rather than wait for the current inference to complete first.\n",
    "\n",
    "#### Table of contents:\n",
    "- [Imports](#Imports)\n",
    "- [Prepare model and data processing](#Prepare-model-and-data-processing)\n",
    "    - [Download test model](#Download-test-model)\n",
    "    - [Load the model](#Load-the-model)\n",
    "    - [Create functions for data processing](#Create-functions-for-data-processing)\n",
    "    - [Get the test video](#Get-the-test-video)\n",
    "- [How to improve the throughput of video processing](#How-to-improve-the-throughput-of-video-processing)\n",
    "    - [Sync Mode (default)](#Sync-Mode-(default))\n",
    "    - [Test performance in Sync Mode](#Test-performance-in-Sync-Mode)\n",
    "    - [Async Mode](#Async-Mode)\n",
    "    - [Test the performance in Async Mode](#Test-the-performance-in-Async-Mode)\n",
    "    - [Compare the performance](#Compare-the-performance)\n",
    "- [`AsyncInferQueue`](#AsyncInferQueue)\n",
    "    - [Setting Callback](#Setting-Callback)\n",
    "    - [Test the performance with `AsyncInferQueue`](#Test-the-performance-with-AsyncInferQueue)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install -q \"openvino>=2023.1.0\"\n",
    "%pip install -q opencv-python matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import time\n",
    "import numpy as np\n",
    "import openvino as ov\n",
    "from IPython import display\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Fetch the notebook utils script from the openvino_notebooks repo\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",
    "\n",
    "import notebook_utils as utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare model and data processing\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "### Download test model\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "We use a pre-trained model from OpenVINO's [Open Model Zoo](https://docs.openvino.ai/nightly/model_zoo.html) to start the test. In this case, the model will be executed to detect the person in each frame of the video."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "################|| Downloading person-detection-0202 ||################\n",
      "\n",
      "========== Retrieving model/intel/person-detection-0202/FP16/person-detection-0202.xml from the cache\n",
      "\n",
      "========== Retrieving model/intel/person-detection-0202/FP16/person-detection-0202.bin from the cache\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# directory where model will be downloaded\n",
    "base_model_dir = \"model\"\n",
    "\n",
    "# model name as named in Open Model Zoo\n",
    "model_name = \"person-detection-0202\"\n",
    "precision = \"FP16\"\n",
    "model_path = (\n",
    "    f\"model/intel/{model_name}/{precision}/{model_name}.xml\"\n",
    ")\n",
    "download_command = f\"omz_downloader \" \\\n",
    "                   f\"--name {model_name} \" \\\n",
    "                   f\"--precision {precision} \" \\\n",
    "                   f\"--output_dir {base_model_dir} \" \\\n",
    "                   f\"--cache_dir {base_model_dir}\"\n",
    "! $download_command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the model\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize OpenVINO runtime\n",
    "core = ov.Core()\n",
    "\n",
    "# read the network and corresponding weights from file\n",
    "model = core.read_model(model=model_path)\n",
    "\n",
    "# compile the model for the CPU (you can choose manually CPU, GPU etc.)\n",
    "# or let the engine choose the best available device (AUTO)\n",
    "compiled_model = core.compile_model(model=model, device_name=\"CPU\")\n",
    "\n",
    "# get input node\n",
    "input_layer_ir = model.input(0)\n",
    "N, C, H, W = input_layer_ir.shape\n",
    "shape = (H, W)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create functions for data processing\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(image):\n",
    "    \"\"\"\n",
    "    Define the preprocess function for input data\n",
    "    \n",
    "    :param: image: the orignal input frame\n",
    "    :returns:\n",
    "            resized_image: the image processed\n",
    "    \"\"\"\n",
    "    resized_image = cv2.resize(image, shape)\n",
    "    resized_image = cv2.cvtColor(np.array(resized_image), cv2.COLOR_BGR2RGB)\n",
    "    resized_image = resized_image.transpose((2, 0, 1))\n",
    "    resized_image = np.expand_dims(resized_image, axis=0).astype(np.float32)\n",
    "    return resized_image\n",
    "\n",
    "\n",
    "def postprocess(result, image, fps):\n",
    "    \"\"\"\n",
    "    Define the postprocess function for output data\n",
    "    \n",
    "    :param: result: the inference results\n",
    "            image: the orignal input frame\n",
    "            fps: average throughput calculated for each frame\n",
    "    :returns:\n",
    "            image: the image with bounding box and fps message\n",
    "    \"\"\"\n",
    "    detections = result.reshape(-1, 7)\n",
    "    for i, detection in enumerate(detections):\n",
    "        _, image_id, confidence, xmin, ymin, xmax, ymax = detection\n",
    "        if confidence > 0.5:\n",
    "            xmin = int(max((xmin * image.shape[1]), 10))\n",
    "            ymin = int(max((ymin * image.shape[0]), 10))\n",
    "            xmax = int(min((xmax * image.shape[1]), image.shape[1] - 10))\n",
    "            ymax = int(min((ymax * image.shape[0]), image.shape[0] - 10))\n",
    "            cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)\n",
    "            cv2.putText(image, str(round(fps, 2)) + \" fps\", (5, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 3) \n",
    "    return image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get the test video\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "video_path = 'https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/video/CEO%20Pat%20Gelsinger%20on%20Leading%20Intel.mp4'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to improve the throughput of video processing\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Below, we compare the performance of the synchronous and async-based approaches:\n",
    "\n",
    "### Sync Mode (default)\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Let us see how video processing works with the default approach.<br />\n",
    "Using the synchronous approach, the frame is captured with OpenCV and then immediately processed:\n",
    "\n",
    "![drawing](https://user-images.githubusercontent.com/91237924/168452573-d354ea5b-7966-44e5-813d-f9053be4338a.png)\n",
    "\n",
    "```\n",
    "while(true) {\n",
    "// capture frame\n",
    "// populate CURRENT InferRequest\n",
    "// Infer CURRENT InferRequest\n",
    "//this call is synchronous\n",
    "// display CURRENT result\n",
    "}\n",
    "```\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sync_api(source, flip, fps, use_popup, skip_first_frames):\n",
    "    \"\"\"\n",
    "    Define the main function for video processing in sync mode\n",
    "    \n",
    "    :param: source: the video path or the ID of your webcam\n",
    "    :returns:\n",
    "            sync_fps: the inference throughput in sync mode\n",
    "    \"\"\"\n",
    "    frame_number = 0\n",
    "    infer_request = compiled_model.create_infer_request()\n",
    "    player = None\n",
    "    try:\n",
    "        # Create a video player\n",
    "        player = utils.VideoPlayer(source, flip=flip, fps=fps, skip_first_frames=skip_first_frames)\n",
    "        # Start capturing\n",
    "        start_time = time.time()\n",
    "        player.start()\n",
    "        if use_popup:\n",
    "            title = \"Press ESC to Exit\"\n",
    "            cv2.namedWindow(title, cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE)\n",
    "        while True:\n",
    "            frame = player.next()\n",
    "            if frame is None:\n",
    "                print(\"Source ended\")\n",
    "                break\n",
    "            resized_frame = preprocess(frame)\n",
    "            infer_request.set_tensor(input_layer_ir, ov.Tensor(resized_frame))\n",
    "            # Start the inference request in synchronous mode \n",
    "            infer_request.infer()\n",
    "            res = infer_request.get_output_tensor(0).data\n",
    "            stop_time = time.time()\n",
    "            total_time = stop_time - start_time\n",
    "            frame_number = frame_number + 1\n",
    "            sync_fps = frame_number / total_time \n",
    "            frame = postprocess(res, frame, sync_fps)\n",
    "            # Display the results\n",
    "            if use_popup:\n",
    "                cv2.imshow(title, frame)\n",
    "                key = cv2.waitKey(1)\n",
    "                # escape = 27\n",
    "                if key == 27:\n",
    "                    break\n",
    "            else:\n",
    "                # Encode numpy array to jpg\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",
    "                # Display the image in this notebook\n",
    "                display.clear_output(wait=True)\n",
    "                display.display(i)         \n",
    "    # ctrl-c\n",
    "    except KeyboardInterrupt:\n",
    "        print(\"Interrupted\")\n",
    "    # Any different error\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "    finally:\n",
    "        if use_popup:\n",
    "            cv2.destroyAllWindows()\n",
    "        if player is not None:\n",
    "            # stop capturing\n",
    "            player.stop()\n",
    "        return sync_fps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test performance in Sync Mode\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "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": [
      "Source ended\n",
      "average throuput in sync mode: 58.55 fps\n"
     ]
    }
   ],
   "source": [
    "sync_fps = sync_api(source=video_path, flip=False, fps=30, use_popup=False, skip_first_frames=800)\n",
    "print(f\"average throuput in sync mode: {sync_fps:.2f} fps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Async Mode\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Let us see how the OpenVINO Async API can improve the overall frame rate of an application. The key advantage of the Async approach is as follows: while a device is busy with the inference, the application can do other things in parallel (for example, populating inputs or scheduling other requests) rather than wait for the current inference to complete first.\n",
    "\n",
    "![drawing](https://user-images.githubusercontent.com/91237924/168452572-c2ff1c59-d470-4b85-b1f6-b6e1dac9540e.png)\n",
    "\n",
    "In the example below, inference is applied to the results of the video decoding. So it is possible to keep multiple infer requests, and while the current request is processed, the input frame for the next is being captured. This essentially hides the latency of capturing, so that the overall frame rate is rather determined only by the slowest part of the pipeline (decoding vs inference) and not by the sum of the stages.\n",
    "\n",
    "```\n",
    "while(true) {\n",
    "// capture frame\n",
    "// populate NEXT InferRequest\n",
    "// start NEXT InferRequest\n",
    "// this call is async and returns immediately\n",
    "// wait for the CURRENT InferRequest\n",
    "// display CURRENT result\n",
    "// swap CURRENT and NEXT InferRequests\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def async_api(source, flip, fps, use_popup, skip_first_frames):\n",
    "    \"\"\"\n",
    "    Define the main function for video processing in async mode\n",
    "    \n",
    "    :param: source: the video path or the ID of your webcam\n",
    "    :returns:\n",
    "            async_fps: the inference throughput in async mode\n",
    "    \"\"\"\n",
    "    frame_number = 0\n",
    "    # Create 2 infer requests\n",
    "    curr_request = compiled_model.create_infer_request()\n",
    "    next_request = compiled_model.create_infer_request()\n",
    "    player = None\n",
    "    async_fps = 0\n",
    "    try:\n",
    "        # Create a video player\n",
    "        player = utils.VideoPlayer(source, flip=flip, fps=fps, skip_first_frames=skip_first_frames)\n",
    "        # Start capturing\n",
    "        start_time = time.time()\n",
    "        player.start()\n",
    "        if use_popup:\n",
    "            title = \"Press ESC to Exit\"\n",
    "            cv2.namedWindow(title, cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_AUTOSIZE)\n",
    "        # Capture CURRENT frame\n",
    "        frame = player.next()\n",
    "        resized_frame = preprocess(frame)\n",
    "        curr_request.set_tensor(input_layer_ir, ov.Tensor(resized_frame))\n",
    "        # Start the CURRENT inference request\n",
    "        curr_request.start_async()\n",
    "        while True:\n",
    "            # Capture NEXT frame\n",
    "            next_frame = player.next()\n",
    "            if next_frame is None:\n",
    "                print(\"Source ended\")\n",
    "                break\n",
    "            resized_frame = preprocess(next_frame)\n",
    "            next_request.set_tensor(input_layer_ir, ov.Tensor(resized_frame))\n",
    "            # Start the NEXT inference request\n",
    "            next_request.start_async()\n",
    "            # Waiting for CURRENT inference result\n",
    "            curr_request.wait()\n",
    "            res = curr_request.get_output_tensor(0).data\n",
    "            stop_time = time.time()\n",
    "            total_time = stop_time - start_time\n",
    "            frame_number = frame_number + 1\n",
    "            async_fps = frame_number / total_time  \n",
    "            frame = postprocess(res, frame, async_fps)\n",
    "            # Display the results\n",
    "            if use_popup:\n",
    "                cv2.imshow(title, frame)\n",
    "                key = cv2.waitKey(1)\n",
    "                # escape = 27\n",
    "                if key == 27:\n",
    "                    break\n",
    "            else:\n",
    "                # Encode numpy array to jpg\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",
    "                # Display the image in this notebook\n",
    "                display.clear_output(wait=True)\n",
    "                display.display(i)\n",
    "            # Swap CURRENT and NEXT frames\n",
    "            frame = next_frame\n",
    "            # Swap CURRENT and NEXT infer requests\n",
    "            curr_request, next_request = next_request, curr_request         \n",
    "    # ctrl-c\n",
    "    except KeyboardInterrupt:\n",
    "        print(\"Interrupted\")\n",
    "    # Any different error\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "    finally:\n",
    "        if use_popup:\n",
    "            cv2.destroyAllWindows()\n",
    "        if player is not None:\n",
    "            # stop capturing\n",
    "            player.stop()\n",
    "        return async_fps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the performance in Async Mode\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCAFoAoADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD8rKKKKsAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA/9k=",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Source ended\n",
      "average throuput in async mode: 74.96 fps\n"
     ]
    }
   ],
   "source": [
    "async_fps = async_api(source=video_path, flip=False, fps=30, use_popup=False, skip_first_frames=800)\n",
    "print(f\"average throuput in async mode: {async_fps:.2f} fps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare the performance\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width = 0.4\n",
    "fontsize = 14\n",
    "\n",
    "plt.rc('font', size=fontsize)\n",
    "fig, ax = plt.subplots(1, 1, figsize=(10, 8))\n",
    "\n",
    "rects1 = ax.bar([0], sync_fps, width, color='#557f2d')\n",
    "rects2 = ax.bar([width], async_fps, width)\n",
    "ax.set_ylabel(\"frames per second\")\n",
    "ax.set_xticks([0, width]) \n",
    "ax.set_xticklabels([\"Sync mode\", \"Async mode\"])\n",
    "ax.set_xlabel(\"Higher is better\")\n",
    "\n",
    "fig.suptitle('Sync mode VS Async mode')\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `AsyncInferQueue`\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "Asynchronous mode pipelines can be supported with the [`AsyncInferQueue`](https://docs.openvino.ai/2023.3/openvino_docs_OV_UG_Python_API_exclusives.html#asyncinferqueue) wrapper class. This class automatically spawns the pool of `InferRequest` objects (also called “jobs”) and provides synchronization mechanisms to control the flow of the pipeline. It is a simpler way to manage the infer request queue in Asynchronous mode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting Callback\n",
    "[back to top ⬆️](#Table-of-contents:)\n",
    "\n",
    "When `callback` is set, any job that ends inference calls upon 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 “user data”, which provides the possibility of passing runtime values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def callback(infer_request, info) -> None:\n",
    "    \"\"\"\n",
    "    Define the callback function for postprocessing\n",
    "    \n",
    "    :param: infer_request: the infer_request object\n",
    "            info: a tuple includes original frame and starts time\n",
    "    :returns:\n",
    "            None\n",
    "    \"\"\"\n",
    "    global frame_number\n",
    "    global total_time\n",
    "    global inferqueue_fps\n",
    "    stop_time = time.time()\n",
    "    frame, start_time = info\n",
    "    total_time = stop_time - start_time\n",
    "    frame_number = frame_number + 1\n",
    "    inferqueue_fps = frame_number / total_time\n",
    "    \n",
    "    res = infer_request.get_output_tensor(0).data[0]\n",
    "    frame = postprocess(res, frame, inferqueue_fps)\n",
    "    # Encode numpy array to jpg\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",
    "    # Display the image in this notebook\n",
    "    display.clear_output(wait=True)\n",
    "    display.display(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inferqueue(source, flip, fps, skip_first_frames) -> None:\n",
    "    \"\"\"\n",
    "    Define the main function for video processing with async infer queue\n",
    "    \n",
    "    :param: source: the video path or the ID of your webcam\n",
    "    :retuns:\n",
    "        None\n",
    "    \"\"\"\n",
    "    # Create infer requests queue\n",
    "    infer_queue = ov.AsyncInferQueue(compiled_model, 2)\n",
    "    infer_queue.set_callback(callback)\n",
    "    player = None\n",
    "    try:\n",
    "        # Create a video player\n",
    "        player = utils.VideoPlayer(source, flip=flip, fps=fps, skip_first_frames=skip_first_frames)\n",
    "        # Start capturing\n",
    "        start_time = time.time()\n",
    "        player.start()\n",
    "        while True:\n",
    "            # Capture frame\n",
    "            frame = player.next()\n",
    "            if frame is None:\n",
    "                print(\"Source ended\")\n",
    "                break\n",
    "            resized_frame = preprocess(frame)\n",
    "            # Start the inference request with async infer queue \n",
    "            infer_queue.start_async({input_layer_ir.any_name: resized_frame}, (frame, start_time))\n",
    "    except KeyboardInterrupt:\n",
    "        print(\"Interrupted\")\n",
    "    # Any different error\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "    finally:\n",
    "        infer_queue.wait_all()\n",
    "        player.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the performance with `AsyncInferQueue`\n",
    "[back to top ⬆️](#Table-of-contents:)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "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": [
      "average throughput in async mode with async infer queue: 102.97 fps\n"
     ]
    }
   ],
   "source": [
    "frame_number = 0\n",
    "total_time = 0\n",
    "inferqueue(source=video_path, flip=False, fps=30, skip_first_frames=800)\n",
    "print(f\"average throughput in async mode with async infer queue: {inferqueue_fps:.2f} 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.8.10"
  },
  "openvino_notebooks": {
   "imageUrl": "",
   "tags": {
    "categories": [
     "API Overview"
    ],
    "libraries": [],
    "other": [],
    "tasks": []
   }
  },
  "vscode": {
   "interpreter": {
    "hash": "08af04953a73b86b66cc089a637d3d397b0b73ad05ea59846f770cc21ccdacba"
   }
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}