notebooks/102-pytorch-onnx-to-openvino/102-pytorch-onnx-to-openvino.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "af86d01b",
   "metadata": {
    "id": "JwEAhQVzkAwA"
   },
   "source": [
    "# Convert a PyTorch Model to ONNX and OpenVINO™ IR\n",
    "\n",
    "This tutorial demonstrates step-by-step instructions on how to do inference on a PyTorch semantic segmentation model, using OpenVINO Runtime.\n",
    "\n",
    "First, the PyTorch model is exported in [ONNX](https://onnx.ai/) format and then converted to OpenVINO IR. Then the respective ONNX and OpenVINO IR models are loaded into OpenVINO Runtime to show model predictions.\n",
    "In this tutorial, we will use LR-ASPP model with MobileNetV3 backbone.\n",
    "\n",
    "According to the paper, [Searching for MobileNetV3](https://arxiv.org/pdf/1905.02244.pdf), LR-ASPP or Lite Reduced Atrous Spatial Pyramid Pooling has a lightweight and efficient segmentation decoder architecture. The diagram below illustrates the model architecture:\n",
    "\n",
    "![image](https://user-images.githubusercontent.com/29454499/207099169-48dca3dc-a8eb-4e11-be92-40cebeec7a88.png)\n",
    "\n",
    "The model is pre-trained on the [MS COCO](https://cocodataset.org/#home) dataset. Instead of training on all 80 classes, the segmentation model has been trained on 20 classes from the [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) dataset:\n",
    "***background*, *aeroplane*, *bicycle*, *bird*, *boat*, *bottle*, *bus*, *car*, *cat*, *chair*, *cow*, *dining table*, *dog*, *horse*, *motorbike*, *person*, *potted plant*, *sheep*, *sofa*, *train*, *tvmonitor***\n",
    "\n",
    "More information about the model is available in the [torchvision documentation](https://pytorch.org/vision/main/models/lraspp.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdf8008",
   "metadata": {
    "id": "QB4Yo-rGGLmV"
   },
   "source": [
    "## Preparation\n",
    "\n",
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2573d828",
   "metadata": {
    "id": "2ynWRum4iiTz"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import time\n",
    "import warnings\n",
    "from pathlib import Path\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import torch\n",
    "from IPython.display import Markdown, display\n",
    "from torchvision.models.segmentation import lraspp_mobilenet_v3_large, LRASPP_MobileNet_V3_Large_Weights\n",
    "from openvino.runtime import Core\n",
    "\n",
    "sys.path.append(\"../utils\")\n",
    "from notebook_utils import segmentation_map_to_image, viz_result_image, SegmentationMap, Label, download_file"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "37b80fe4",
   "metadata": {},
   "source": [
    "### Settings\n",
    "\n",
    "Set a name for the model, then define width and height of the image that will be used by the network during inference. According to the input transforms function, the model is pre-trained on images with a height of 520 and width of 780."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a9303a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "IMAGE_WIDTH = 780\n",
    "IMAGE_HEIGHT = 520\n",
    "DIRECTORY_NAME = \"model\"\n",
    "BASE_MODEL_NAME = DIRECTORY_NAME + \"/lraspp_mobilenet_v3_large\"\n",
    "weights_path = Path(BASE_MODEL_NAME + \".pt\")\n",
    "\n",
    "# Paths where ONNX and OpenVINO IR models will be stored.\n",
    "onnx_path = weights_path.with_suffix('.onnx')\n",
    "if not onnx_path.parent.exists():\n",
    "    onnx_path.parent.mkdir()\n",
    "ir_path = onnx_path.with_suffix(\".xml\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2b33033e",
   "metadata": {
    "id": "u5xKw0hR0jq6"
   },
   "source": [
    "### Load Model\n",
    "\n",
    "Generally, PyTorch models represent an instance of `torch.nn.Module` class, initialized by a state dictionary with model weights.\n",
    "Typical steps for getting a pre-trained model:\n",
    "1. Create instance of model class\n",
    "2. Load checkpoint state dict, which contains pre-trained model weights\n",
    "3. Turn model to evaluation for switching some operations to inference mode\n",
    "\n",
    "The `torchvision` module provides a ready to use set of functions for model class initialization. We will use `torchvision.models.segmentation.lraspp_mobilenet_v3_large`. You can directly pass pre-trained model weights to the model initialization function using weights enum `LRASPP_MobileNet_V3_Large_Weights.COCO_WITH_VOC_LABELS_V1`. However, for demonstration purposes, we will create it separately. Download the pre-trained weights and load the model. This may take some time if you have not downloaded the model before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9600481",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xGKkMRfvi0op",
    "outputId": "4eb1f9af-a4c5-424c-f808-dd9cc2600975"
   },
   "outputs": [],
   "source": [
    "print(\"Downloading the LRASPP MobileNetV3 model (if it has not been downloaded already)...\") \n",
    "download_file(LRASPP_MobileNet_V3_Large_Weights.COCO_WITH_VOC_LABELS_V1.url, filename=weights_path.name, directory=weights_path.parent)\n",
    "# create model object\n",
    "model = lraspp_mobilenet_v3_large()\n",
    "# read state dict, use map_location argument to avoid a situation where weights are saved in cuda (which may not be unavailable on the system)\n",
    "state_dict = torch.load(weights_path, map_location='cpu')\n",
    "# load state dict to model\n",
    "model.load_state_dict(state_dict)\n",
    "# switch model from training to inference mode\n",
    "model.eval()\n",
    "print(\"Loaded PyTorch LRASPP MobileNetV3 model\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bad92bb9",
   "metadata": {
    "id": "Rhc_7EObUypw"
   },
   "source": [
    "## ONNX Model Conversion\n",
    "\n",
    "### Convert PyTorch model to ONNX\n",
    "\n",
    "OpenVINO supports PyTorch models that are exported in ONNX format. We will use the `torch.onnx.export` function to obtain the ONNX model, you can learn more about this feature in the [PyTorch documentation](https://pytorch.org/docs/stable/onnx.html). We need to provide a model object, example input for model tracing and path where the model will be saved. When providing example input, it is not necessary to use real data, dummy input data with specified shape is sufficient. Optionally, we can provide a target onnx opset for conversion and/or other parameters specified in documentation (e.g. input and output names or dynamic shapes).\n",
    "\n",
    "Sometimes a warning will be shown, but in most cases it is harmless, so let us just filter it out. When the conversion is successful, the last line of the output will read: `ONNX model exported to model/lraspp_mobilenet_v3_large.onnx.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "659aeac7",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ipQWpbgQUxoo",
    "outputId": "bbc1734a-c2a2-4261-ed45-264b9e3edd00"
   },
   "outputs": [],
   "source": [
    "with warnings.catch_warnings():\n",
    "    warnings.filterwarnings(\"ignore\")\n",
    "    if not onnx_path.exists():\n",
    "        dummy_input = torch.randn(1, 3, IMAGE_HEIGHT, IMAGE_WIDTH)\n",
    "        torch.onnx.export(\n",
    "            model,\n",
    "            dummy_input,\n",
    "            onnx_path,\n",
    "        )\n",
    "        print(f\"ONNX model exported to {onnx_path}.\")\n",
    "    else:\n",
    "        print(f\"ONNX model {onnx_path} already exists.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b490241b",
   "metadata": {
    "id": "6JSoEIk60uxV"
   },
   "source": [
    "### Convert ONNX Model to OpenVINO IR Format\n",
    "\n",
    "Use Model Optimizer to convert the ONNX model to OpenVINO IR with `FP16` precision. The models are saved inside the current directory. For more information about Model Optimizer, see the [Model Optimizer Developer Guide](https://docs.openvino.ai/latest/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f99ea10",
   "metadata": {},
   "source": [
    "Executing this command may take a while. There may be some errors or warnings in the output. When Model Optimization is successful, the last lines of the output will include: `[ SUCCESS ] Generated IR version 11 model.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c1e8029",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Construct the command for Model Optimizer.\n",
    "mo_command = f\"\"\"mo\n",
    "                 --input_model \"{onnx_path}\"\n",
    "                 --compress_to_fp16\n",
    "                 --output_dir \"{ir_path.parent}\"\n",
    "                 \"\"\"\n",
    "mo_command = \" \".join(mo_command.split())\n",
    "print(\"Model Optimizer command to convert the ONNX model to OpenVINO:\")\n",
    "display(Markdown(f\"`{mo_command}`\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e48d30a7",
   "metadata": {
    "id": "6YUwrq7QWSzw",
    "tags": []
   },
   "outputs": [],
   "source": [
    "if not ir_path.exists():\n",
    "    print(\"Exporting ONNX model to IR... This may take a few minutes.\")\n",
    "    mo_result = %sx $mo_command\n",
    "    print(\"\\n\".join(mo_result))\n",
    "else:\n",
    "    print(f\"IR model {ir_path} already exists.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "608279bb",
   "metadata": {
    "id": "FAGmlKQ83ecE"
   },
   "source": [
    "## Show Results\n",
    "\n",
    "Confirm that the segmentation results look as expected by comparing model predictions on the ONNX, OpenVINO IR and PyTorch models."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "08d2a742",
   "metadata": {
    "id": "JyD5EKka34Wd"
   },
   "source": [
    "### Load and Preprocess an Input Image\n",
    "\n",
    "Images need to be normalized before propagating through the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "738cb5e7",
   "metadata": {
    "id": "QTOoQnSetzQM",
    "tags": []
   },
   "outputs": [],
   "source": [
    "def normalize(image: np.ndarray) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Normalize the image to the given mean and standard deviation\n",
    "    for CityScapes models.\n",
    "    \"\"\"\n",
    "    image = image.astype(np.float32)\n",
    "    mean = (0.485, 0.456, 0.406)\n",
    "    std = (0.229, 0.224, 0.225)\n",
    "    image /= 255.0\n",
    "    image -= mean\n",
    "    image /= std\n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b92da2c",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DGFW5VXL3x9G",
    "outputId": "300eacff-c6de-4eb5-e99a-8def5260da1a",
    "tags": []
   },
   "outputs": [],
   "source": [
    "image_filename = \"../data/image/coco.jpg\"\n",
    "image = cv2.cvtColor(cv2.imread(image_filename), cv2.COLOR_BGR2RGB)\n",
    "\n",
    "resized_image = cv2.resize(image, (IMAGE_WIDTH, IMAGE_HEIGHT))\n",
    "normalized_image = normalize(resized_image)\n",
    "\n",
    "# Convert the resized images to network input shape.\n",
    "input_image = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0)\n",
    "normalized_input_image = np.expand_dims(np.transpose(normalized_image, (2, 0, 1)), 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57bab671",
   "metadata": {
    "id": "FnEiEbNq4Csh"
   },
   "source": [
    "### Load the OpenVINO IR Network and Run Inference on the ONNX model\n",
    "\n",
    "OpenVINO Runtime can load ONNX models directly. First, load the ONNX model, do inference and show the results. Then, load the model that was converted to OpenVINO Intermediate Representation (OpenVINO IR) with Model Optimizer and do inference on that model, and show the results on an image.\n",
    "\n",
    "#### 1. ONNX Model in OpenVINO Runtime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "194b8bc2",
   "metadata": {
    "id": "otfT6EDk03KV",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Load the network to OpenVINO Runtime.\n",
    "ie = Core()\n",
    "model_onnx = ie.read_model(model=onnx_path)\n",
    "compiled_model_onnx = ie.compile_model(model=model_onnx, device_name=\"CPU\")\n",
    "\n",
    "output_layer_onnx = compiled_model_onnx.output(0)\n",
    "\n",
    "# Run inference on the input image.\n",
    "res_onnx = compiled_model_onnx([normalized_input_image])[output_layer_onnx]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc95ece2",
   "metadata": {},
   "source": [
    "Model predicts probabilities for how well each pixel corresponds to a specific label. To get the label with highest probability for each pixel, operation argmax should be applied. After that, color coding can be applied to each label for more convenient visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "064a14ba",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 348
    },
    "id": "q8NRH8hLuWeV",
    "outputId": "8b17f90e-b3bc-456f-b6f3-e9cd4f743b2f",
    "tags": []
   },
   "outputs": [],
   "source": [
    "voc_labels = [\n",
    "    Label(index=0, color=(0, 0, 0), name=\"background\"),\n",
    "    Label(index=1, color=(128, 0, 0), name=\"aeroplane\"),\n",
    "    Label(index=2, color=(0, 128, 0), name=\"bicycle\"),\n",
    "    Label(index=3, color=(128, 128, 0), name=\"bird\"),\n",
    "    Label(index=4, color=(0, 0, 128), name=\"boat\"),\n",
    "    Label(index=5, color=(128, 0, 128), name=\"bottle\"),\n",
    "    Label(index=6, color=(0, 128, 128), name=\"bus\"),\n",
    "    Label(index=7, color=(128, 128, 128), name=\"car\"),\n",
    "    Label(index=8, color=(64, 0, 0), name=\"cat\"),\n",
    "    Label(index=9, color=(192, 0, 0), name=\"chair\"),\n",
    "    Label(index=10, color=(64, 128, 0), name=\"cow\"),\n",
    "    Label(index=11, color=(192, 128, 0), name=\"dining table\"),\n",
    "    Label(index=12, color=(64, 0, 128), name=\"dog\"),\n",
    "    Label(index=13, color=(192, 0, 128), name=\"horse\"),\n",
    "    Label(index=14, color=(64, 128, 128), name=\"motorbike\"),\n",
    "    Label(index=15, color=(192, 128, 128), name=\"person\"),\n",
    "    Label(index=16, color=(0, 64, 0), name=\"potted plant\"),\n",
    "    Label(index=17, color=(128, 64, 0), name=\"sheep\"),\n",
    "    Label(index=18, color=(0, 192, 0), name=\"sofa\"),\n",
    "    Label(index=19, color=(128, 192, 0), name=\"train\"),\n",
    "    Label(index=20, color=(0, 64, 128), name=\"tv monitor\")\n",
    "]\n",
    "VOCLabels = SegmentationMap(voc_labels)\n",
    "\n",
    "# Convert the network result to a segmentation map and display the result.\n",
    "result_mask_onnx = np.squeeze(np.argmax(res_onnx, axis=1)).astype(np.uint8)\n",
    "viz_result_image(\n",
    "    image,\n",
    "    segmentation_map_to_image(result_mask_onnx, VOCLabels.get_colormap()),\n",
    "    resize=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70c0e7d8",
   "metadata": {
    "id": "FnEiEbNq4Csh"
   },
   "source": [
    "#### 2. OpenVINO IR Model in OpenVINO Runtime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b628c3a4",
   "metadata": {
    "id": "otfT6EDk03KV",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Load the network in OpenVINO Runtime.\n",
    "ie = Core()\n",
    "model_ir = ie.read_model(model=ir_path)\n",
    "compiled_model_ir = ie.compile_model(model=model_ir, device_name=\"CPU\")\n",
    "\n",
    "# Get input and output layers.\n",
    "output_layer_ir = compiled_model_ir.output(0)\n",
    "\n",
    "# Run inference on the input image.\n",
    "res_ir = compiled_model_ir([normalized_input_image])[output_layer_ir]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e625d64a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 348
    },
    "id": "q8NRH8hLuWeV",
    "outputId": "8b17f90e-b3bc-456f-b6f3-e9cd4f743b2f",
    "tags": []
   },
   "outputs": [],
   "source": [
    "result_mask_ir = np.squeeze(np.argmax(res_ir, axis=1)).astype(np.uint8)\n",
    "viz_result_image(\n",
    "    image,\n",
    "    segmentation_map_to_image(result=result_mask_ir, colormap=VOCLabels.get_colormap()),\n",
    "    resize=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b8de873",
   "metadata": {
    "id": "w3UUduQEGsQm"
   },
   "source": [
    "## PyTorch Comparison\n",
    "\n",
    "Do inference on the PyTorch model to verify that the output visually looks the same as the output on the ONNX/OpenVINO IR models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44b4f32b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 348
    },
    "id": "1l1JtgeV4Wuw",
    "outputId": "f21c8904-83da-438c-df39-4620bb679554",
    "tags": []
   },
   "outputs": [],
   "source": [
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    result_torch = model(torch.as_tensor(normalized_input_image).float())\n",
    "\n",
    "result_mask_torch = torch.argmax(result_torch['out'], dim=1).squeeze(0).numpy().astype(np.uint8)\n",
    "viz_result_image(\n",
    "    image,\n",
    "    segmentation_map_to_image(result=result_mask_torch, colormap=VOCLabels.get_colormap()),\n",
    "    resize=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9feb7b4",
   "metadata": {},
   "source": [
    "## Performance Comparison\n",
    "\n",
    "Measure the time it takes to do inference on twenty images. This gives an indication of performance. For more accurate benchmarking, use the [Benchmark Tool](https://docs.openvino.ai/latest/openvino_inference_engine_tools_benchmark_tool_README.html). Keep in mind that many optimizations are possible to improve the performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "835b75e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_images = 100\n",
    "\n",
    "with torch.no_grad():\n",
    "    start = time.perf_counter()\n",
    "    for _ in range(num_images):\n",
    "        model(torch.as_tensor(input_image).float())\n",
    "    end = time.perf_counter()\n",
    "    time_torch = end - start\n",
    "print(\n",
    "    f\"PyTorch model on CPU: {time_torch/num_images:.3f} seconds per image, \"\n",
    "    f\"FPS: {num_images/time_torch:.2f}\"\n",
    ")\n",
    "\n",
    "start = time.perf_counter()\n",
    "for _ in range(num_images):\n",
    "    compiled_model_onnx([normalized_input_image])\n",
    "end = time.perf_counter()\n",
    "time_onnx = end - start\n",
    "print(\n",
    "    f\"ONNX model in OpenVINO Runtime/CPU: {time_onnx/num_images:.3f} \"\n",
    "    f\"seconds per image, FPS: {num_images/time_onnx:.2f}\"\n",
    ")\n",
    "\n",
    "start = time.perf_counter()\n",
    "for _ in range(num_images):\n",
    "    compiled_model_ir([input_image])\n",
    "end = time.perf_counter()\n",
    "time_ir = end - start\n",
    "print(\n",
    "    f\"OpenVINO IR model in OpenVINO Runtime/CPU: {time_ir/num_images:.3f} \"\n",
    "    f\"seconds per image, FPS: {num_images/time_ir:.2f}\"\n",
    ")\n",
    "\n",
    "if \"GPU\" in ie.available_devices:\n",
    "    compiled_model_onnx_gpu = ie.compile_model(model=model_onnx, device_name=\"GPU\")\n",
    "    start = time.perf_counter()\n",
    "    for _ in range(num_images):\n",
    "        compiled_model_onnx_gpu([input_image])\n",
    "    end = time.perf_counter()\n",
    "    time_onnx_gpu = end - start\n",
    "    print(\n",
    "        f\"ONNX model in OpenVINO/GPU: {time_onnx_gpu/num_images:.3f} \"\n",
    "        f\"seconds per image, FPS: {num_images/time_onnx_gpu:.2f}\"\n",
    "    )\n",
    "\n",
    "    compiled_model_ir_gpu = ie.compile_model(model=model_ir, device_name=\"GPU\")\n",
    "    start = time.perf_counter()\n",
    "    for _ in range(num_images):\n",
    "        compiled_model_ir_gpu([input_image])\n",
    "    end = time.perf_counter()\n",
    "    time_ir_gpu = end - start\n",
    "    print(\n",
    "        f\"IR model in OpenVINO/GPU: {time_ir_gpu/num_images:.3f} \"\n",
    "        f\"seconds per image, FPS: {num_images/time_ir_gpu:.2f}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ca50ca",
   "metadata": {},
   "source": [
    "**Show Device Information**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab884bb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "devices = ie.available_devices\n",
    "for device in devices:\n",
    "    device_name = ie.get_property(device, \"FULL_DEVICE_NAME\")\n",
    "    print(f\"{device}: {device_name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8ed2610",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "* [Torchvision](https://pytorch.org/vision/stable/index.html)\n",
    "* [Pytorch ONNX Documentation](https://pytorch.org/docs/stable/onnx.html)\n",
    "* [PIP install openvino-dev](https://pypi.org/project/openvino-dev/)\n",
    "* [OpenVINO ONNX support](https://docs.openvino.ai/2021.4/openvino_docs_IE_DG_ONNX_Support.html)\n",
    "* [Model Optimizer Documentation](https://docs.openvino.ai/latest/openvino_docs_MO_DG_prepare_model_convert_model_Converting_Model_General.html)\n",
    "* [Model Optimizer Pytorch conversion guide](https://docs.openvino.ai/latest/openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_PyTorch.html)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "e0404472fd7b5b63117a9fa5c50283296e2708c2449c6090d2cdf8903f95897f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}