OpenVINO Notebooks Snippets for Jupyter Lab

[helena-intel]

Jupyter Lab Code Snippets allows you to save often used snippets in Jupyter Lab, for easy access across all projects. You can install it with pip install jupyterlab-code-snippets in the openvino_env environment. You may have to do jupyter lab build after that.

For some useful OpenVINO snippets, copy the code below, go to Settings->Advanced Settings Editor in Jupyter Lab, select Code Snippets Manager and paste the code in the User Preferences editor to the right. Click the save button to save, and your snippets should show up instantly. They are now always accessible from the sidebar in Jupyter. You can add snippets too (please share useful ones here!) and edit them to match your preferences. To use a snippet, click on the snippets menu icon (three dots) and choose Copy snippet to clipboard

For explanation of the code in the snippets, see the OpenVINO API Tutorial notebook and the Model Optimizer notebooks (101, 102 and 103).

{
    // Code Snippet Manager
    // jupyterlab-code-snippets:snippets
    // Code Snippet Manager Settings
    // *********************************

    // Code Snippets
    // The list of snippets.
    "snippets": [
        {
            "name": "OpenVINO: imports",
            "description": "Imports that are often useful for OpenVINO notebooks",
            "language": "Python",
            "code": [
                "import os",
                "import time",
                "from pathlib import Path",
                "",
                "import cv2",
                "import matplotlib.pyplot as plt",
                "import numpy as np",
                "from openvino.inference_engine import IECore"
            ],
            "id": 0,
            "tags": []
        },
        {
            "name": "OpenVINO: show available devices",
            "description": "Shows the device name of all devices available on the system for OpenVINO Inference Engine",
            "language": "Python",
            "code": [
                "from openvino.inference_engine import IECore",
                "",
                "ie = IECore()",
                "for device in ie.available_devices:",
                "    device_name = ie.get_metric(device, \"FULL_DEVICE_NAME\")",
                "    print(f\"{device}: {device_name}\")"
            ],
            "id": 1,
            "tags": [
                "openvino"
            ]
        },
        {
            "name": "OpenVINO: hello device query",
            "description": "Show supported metrics and config keys for all devices available for OpenVINO Inference Engine",
            "language": "Python",
            "code": [
                "# https://github.com/openvinotoolkit/openvino/blob/master/inference-engine/ie_bridges/python/sample/hello_query_device/hello_query_device.py",
                "",
                "from openvino.inference_engine import IECore",
                "ie = IECore()",
                "",
                "def param_to_string(metric) -> str:",
                "    \"\"\"Convert a list / tuple of parameters returned from IE to a string\"\"\"",
                "    if isinstance(metric, (list, tuple)):",
                "        return ', '.join([str(x) for x in metric])",
                "    else:",
                "        return str(metric)",
                "",
                "print('Available devices:')",
                "for device in ie.available_devices:",
                "    print(f'{device} :')",
                "    print('\\tSUPPORTED_METRICS:')",
                "    for metric in ie.get_metric(device, 'SUPPORTED_METRICS'):",
                "        if metric not in ('SUPPORTED_METRICS', 'SUPPORTED_CONFIG_KEYS'):",
                "            try:",
                "                metric_val = ie.get_metric(device, metric)",
                "            except TypeError:",
                "                metric_val = 'UNSUPPORTED TYPE'",
                "            print(f'\\t\\t{metric}: {param_to_string(metric_val)}')",
                "    print()",
                "    print('\\tSUPPORTED_CONFIG_KEYS (default values):')",
                "    for config_key in ie.get_metric(device, 'SUPPORTED_CONFIG_KEYS'):",
                "        try:",
                "            config_val = ie.get_config(device, config_key)",
                "        except TypeError:",
                "            config_val = 'UNSUPPORTED TYPE'",
                "        print(f'\\t\\t{config_key}: {param_to_string(config_val)}')",
                ""
            ],
            "id": 2,
            "tags": [
                "openvino"
            ]
        },
        {
            "name": "OpenVINO: do inference",
            "description": "Do inference on an OpenVINO vision model with one input and one output. Includes image loading and resizing/reshaping",
            "language": "Python",
            "code": [
                "import cv2",
                "import numpy as np",
                "from openvino.inference_engine import IECore",
                "",
                "# MODEL_XML and IMAGE_PATH can be str or Path",
                "MODEL_XML = ",
                "IMAGE_PATH = ",
                "DEVICE = \"CPU\"",
                "",
                "ie = IECore()",
                "net = ie.read_network(model=MODEL_XML)",
                "exec_net = ie.load_network(network=net, device_name=DEVICE)",
                "input_layer = next(iter(net.input_info))",
                "output_layer = next(iter(net.outputs))",
                "",
                "image = cv2.imread(str(IMAGE_PATH))",
                "# image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)",
                "N, C, H, W = net.input_info[input_layer].tensor_desc.dims",
                "resized_image = cv2.resize(src=image, dsize=(W, H))",
                "input_data = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0).astype(np.float32)",
                "result = exec_net.infer({input_layer: input_data})",
                "output = result[output_layer]"
            ],
            "id": 3,
            "tags": [
                "openvino"
            ]
        },
        {
            "name": "OpenVINO: time inference",
            "description": "Time inference. Assumes an exec_net network is already created and input_layer and input_data variables exist. This gives a rough indication of throughput and latency but inference on one image is not a proper benchmark.",
            "language": "Python",
            "code": [
                "import time",
                "start_time = time.perf_counter()",
                "result = exec_net.infer({input_layer: input_data})",
                "end_time = time.perf_counter()",
                "duration = end_time - start_time",
                "print(f\"Inference duration: {duration:.3f} seconds. FPS: {1/duration:.2f}\")"
            ],
            "id": 4,
            "tags": []
        },
        {
            "name": "OpenVINO: optimize a model",
            "description": "Convert model with Model Optimizer if model_xml does not yet exist. Adjust {MODEL_NAME}.onnx for other frameworks",
            "language": "Python",
            "code": [
                "import os",
                "from IPython.display import display, Markdown",
                "",
                "MODEL_XML_PATH = f\"{MODEL_NAME}.xml\"",
                "if not os.path.exists(MODEL_XML_PATH):",
                "    mo_command = f'mo --input_model {MODEL_NAME}.onnx --input_shape \"[1,3,512,512]\"'",
                "    display(Markdown(f\"Model Optimizer command to convert {MODEL_XML_PATH} to IR: `{mo_command}`\"))",
                "    display(Markdown(\"_Converting model to IR. This may take a few minutes..._\"))",
                "    ! $mo_command",
                "else:",
                "    print(f\"{MODEL_XML_PATH} already exists.\")"
            ],
            "id": 5,
            "tags": [
                "openvino"
            ]
        },
        {
            "name": "OpenVINO OMZ: download, convert, benchmark",
            "description": "Download, convert and benchmark the OMZ model given by model_name. If the model contains multiple files, the first model file (see model_info_output) will be used for benchmarking",
            "language": "Python",
            "code": [
                "from pathlib import Path",
                "from IPython.display import display, Markdown",
                "import json ",
                "",
                "model_name = \"yolo-v1-tiny-tf\"",
                "base_model_dir = Path(\"~/open_model_zoo_models\").expanduser()",
                "omz_cache_dir = Path(\"~/open_model_zoo_cache\").expanduser()",
                "precision = \"FP16\"",
                "",
                "download_command = f\"omz_downloader --name {model_name} --output_dir {base_model_dir} --cache_dir {omz_cache_dir}\"",
                "display(Markdown(f\"Download command: `{download_command}`\"))",
                "display(Markdown(f\"Downloading {model_name}...\"))",
                "! $download_command",
                "",
                "convert_command = f\"omz_converter --name {model_name} --precisions {precision} --download_dir {base_model_dir} --output_dir {base_model_dir}\"",
                "display(Markdown(f\"Convert command: `{convert_command}`\"))",
                "display(Markdown(f\"Converting {model_name}...\"))",
                "! $convert_command",
                "",
                "model_info_output = %sx omz_info_dumper --name $model_name",
                "model_info = json.loads(model_info_output.get_nlstr())[0]",
                "model_path = base_model_dir / Path(model_info[\"subdirectory\"]) / Path(f\"{precision}/{model_name}.xml\")",
                "print(model_path, \"exists:\", model_path.exists())",
                "",
                "benchmark_command = f\"benchmark_app -m {model_path} -t 15\"",
                "display(Markdown(f\"Benchmark command: `{benchmark_command}`\"))",
                "display(Markdown(\"Benchmarking {model_path}\"))",
                "",
                "! $benchmark_command"
            ],
            "id": 6,
            "tags": [
                "openvino"
            ]
        },
        {
            "name": "OpenVINO: compact benchmark",
            "description": "Run benchmark_app and show the output without INFO logging",
            "language": "Python",
            "code": [
                "from IPython.display import display, Markdown",
                "",
                "model_path = ",
                "device = \"CPU\"",
                "seconds = 15",
                "api = \"async\"",
                "batch = 1",
                "",
                "benchmark_command = f\"benchmark_app -m {model_path} -d {device} -t {seconds} -api {api} -b {batch}\"",
                "display(Markdown(f\"**Benchmark {model_path} with {device} for {seconds} seconds with {api} inference**\"))",
                "display(Markdown(f\"Benchmark command: `{benchmark_command}`\"))",
                "",
                "benchmark_output = %sx $benchmark_command",
                "benchmark_result = [line for line in benchmark_output if not (line.startswith(r\"[\") or line.startswith(\"  \") or line==\"\")]",
                "print(\"\\n\".join(benchmark_result))"
            ],
            "id": 7,
            "tags": []
        },
        {
            "name": "OpenVINO: reshape model",
            "description": "Reshape an IR model to a new input size. Assumes that IENetwork `net` exists",
            "language": "Python",
            "code": [
                "new_shape = (1, 3, 512, 512)",
                "input_layer = next(iter(net.input_info))",
                "net.reshape({input_layer: new_shape})",
                "exec_net = ie.load_network(network=net, device_name=\"CPU\")"
            ],
            "id": 8,
            "tags": []
        },
        {
            "name": "Matplotlib: show two images side by side",
            "description": "",
            "language": "Python",
            "code": [
                "import matplotlib.pyplot as plt",
                "",
                "fig, ax = plt.subplots(1, 2, figsize=(18, 7))",
                "ax[0].imshow(image)",
                "ax[1].imshow(image)",
                "for a in ax:",
                "    a.axis(\"off\")"
            ],
            "id": 9,
            "tags": []
        },
        {
            "name": "PyTorch: export to ONNX",
            "description": "Export a PyTorch model to ONNX if the ONNX file (onnx_path) does not exist yet",
            "language": "Python",
            "code": [
                "import torch",
                "",
                "if not onnx_path.exists():",
                "    dummy_input = torch.randn(1, 3, 512, 512)",
                "    torch.onnx.export(net, dummy_input, onnx_path, opset_version=11)",
                "    print(f\"ONNX model exported to {onnx_path}.\")",
                "else:",
                "    print(f\"ONNX model {onnx_path} already exists.\")"
            ],
            "id": 10,
            "tags": []
        }
    ]
}