diff --git a/README.md b/README.md index 86c3604d2b5..844e44a0ace 100644 --- a/README.md +++ b/README.md @@ -68,24 +68,24 @@ The OpenVINO™ Runtime can infer models on different hardware devices. This sec CPU - Intel CPU + Intel CPU openvino_intel_cpu_plugin Intel Xeon with Intel® Advanced Vector Extensions 2 (Intel® AVX2), Intel® Advanced Vector Extensions 512 (Intel® AVX-512), and AVX512_BF16, Intel Core Processors with Intel AVX2, Intel Atom Processors with Intel® Streaming SIMD Extensions (Intel® SSE) - ARM CPU + ARM CPU openvino_arm_cpu_plugin Raspberry Pi™ 4 Model B, Apple® Mac mini with M1 chip, NVIDIA® Jetson Nano™, Android™ devices GPU - Intel GPU + Intel GPU openvino_intel_gpu_plugin Intel Processor Graphics, including Intel HD Graphics and Intel Iris Graphics GNA - Intel GNA + Intel GNA openvino_intel_gna_plugin Intel Speech Enabling Developer Kit, Amazon Alexa* Premium Far-Field Developer Kit, Intel Pentium Silver J5005 Processor, Intel Pentium Silver N5000 Processor, Intel Celeron J4005 Processor, Intel Celeron J4105 Processor, Intel Celeron Processor N4100, Intel Celeron Processor N4000, Intel Core i3-8121U Processor, Intel Core i7-1065G7 Processor, Intel Core i7-1060G7 Processor, Intel Core i5-1035G4 Processor, Intel Core i5-1035G7 Processor, Intel Core i5-1035G1 Processor, Intel Core i5-1030G7 Processor, Intel Core i5-1030G4 Processor, Intel Core i3-1005G1 Processor, Intel Core i3-1000G1 Processor, Intel Core i3-1000G4 Processor @@ -103,22 +103,22 @@ OpenVINO™ Toolkit also contains several plugins which simplify loading models - Auto + Auto openvino_auto_plugin Auto plugin enables selecting Intel device for inference automatically - Auto Batch + Auto Batch openvino_auto_batch_plugin Auto batch plugin performs on-the-fly automatic batching (i.e. grouping inference requests together) to improve device utilization, with no programming effort from the user - Hetero + Hetero openvino_hetero_plugin Heterogeneous execution enables automatic inference splitting between several devices - Multi + Multi openvino_auto_plugin Multi plugin enables simultaneous inference of the same model on several devices in parallel @@ -155,10 +155,9 @@ The list of OpenVINO tutorials: ## System requirements The system requirements vary depending on platform and are available on dedicated pages: -- [Linux](https://docs.openvino.ai/2023.0/openvino_docs_install_guides_installing_openvino_linux_header.html) -- [Windows](https://docs.openvino.ai/2023.0/openvino_docs_install_guides_installing_openvino_windows_header.html) -- [macOS](https://docs.openvino.ai/2023.0/openvino_docs_install_guides_installing_openvino_macos_header.html) -- [Raspbian](https://docs.openvino.ai/2023.0/openvino_docs_install_guides_installing_openvino_raspbian.html) +- [Linux](https://docs.openvino.ai/2023.1/openvino_docs_install_guides_installing_openvino_linux_header.html) +- [Windows](https://docs.openvino.ai/2023.1/openvino_docs_install_guides_installing_openvino_windows_header.html) +- [macOS](https://docs.openvino.ai/2023.1/openvino_docs_install_guides_installing_openvino_macos_header.html) ## How to build @@ -196,7 +195,7 @@ Report questions, issues and suggestions, using: \* Other names and brands may be claimed as the property of others. [Open Model Zoo]:https://github.com/openvinotoolkit/open_model_zoo -[OpenVINO™ Runtime]:https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_OV_Runtime_User_Guide.html -[Model Optimizer]:https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html -[Post-Training Optimization Tool]:https://docs.openvino.ai/2023.0/pot_introduction.html +[OpenVINO™ Runtime]:https://docs.openvino.ai/2023.1/openvino_docs_OV_UG_OV_Runtime_User_Guide.html +[Model Optimizer]:https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html +[Post-Training Optimization Tool]:https://docs.openvino.ai/2023.1/pot_introduction.html [Samples]:https://github.com/openvinotoolkit/openvino/tree/master/samples diff --git a/docs/IE_PLUGIN_DG/Intro.md b/docs/IE_PLUGIN_DG/Intro.md index 80c01aa8af8..c33cf9589b3 100644 --- a/docs/IE_PLUGIN_DG/Intro.md +++ b/docs/IE_PLUGIN_DG/Intro.md @@ -94,7 +94,7 @@ Detailed Guides API References ############## -* `OpenVINO Plugin API `__ -* `OpenVINO Transformation API `__ +* `OpenVINO Plugin API `__ +* `OpenVINO Transformation API `__ @endsphinxdirective diff --git a/docs/IE_PLUGIN_DG/dev_api_references.md b/docs/IE_PLUGIN_DG/dev_api_references.md index 5e6cc22c57d..aa1a2a46407 100644 --- a/docs/IE_PLUGIN_DG/dev_api_references.md +++ b/docs/IE_PLUGIN_DG/dev_api_references.md @@ -15,7 +15,7 @@ The guides below provides extra API references needed for OpenVINO plugin development: -* `OpenVINO Plugin API `__ -* `OpenVINO Transformation API `__ +* `OpenVINO Plugin API `__ +* `OpenVINO Transformation API `__ @endsphinxdirective diff --git a/docs/MO_DG/prepare_model/convert_model/tf_specific/Convert_RetinaNet_From_Tensorflow.md b/docs/MO_DG/prepare_model/convert_model/tf_specific/Convert_RetinaNet_From_Tensorflow.md index 908135935e0..77da5d31049 100644 --- a/docs/MO_DG/prepare_model/convert_model/tf_specific/Convert_RetinaNet_From_Tensorflow.md +++ b/docs/MO_DG/prepare_model/convert_model/tf_specific/Convert_RetinaNet_From_Tensorflow.md @@ -10,7 +10,7 @@ This tutorial explains how to convert a RetinaNet model to the Intermediate Representation (IR). `Public RetinaNet model `__ does not contain pretrained TensorFlow weights. -To convert this model to the TensorFlow format, follow the `Reproduce Keras to TensorFlow Conversion tutorial `__. +To convert this model to the TensorFlow format, follow the `Reproduce Keras to TensorFlow Conversion tutorial `__. After converting the model to TensorFlow format, run the following command: diff --git a/docs/OV_Runtime_UG/integrate_with_your_application.md b/docs/OV_Runtime_UG/integrate_with_your_application.md index 08ff6c8f3f4..6a024ff13bb 100644 --- a/docs/OV_Runtime_UG/integrate_with_your_application.md +++ b/docs/OV_Runtime_UG/integrate_with_your_application.md @@ -437,9 +437,9 @@ To build your project using CMake with the default build tools currently availab Additional Resources #################### -* See the :doc:`OpenVINO Samples ` page or the `Open Model Zoo Demos `__ page for specific examples of how OpenVINO pipelines are implemented for applications like image classification, text prediction, and many others. +* See the :doc:`OpenVINO Samples ` page or the `Open Model Zoo Demos `__ page for specific examples of how OpenVINO pipelines are implemented for applications like image classification, text prediction, and many others. * :doc:`OpenVINO™ Runtime Preprocessing ` * :doc:`Using Encrypted Models with OpenVINO ` -* `Open Model Zoo Demos `__ +* `Open Model Zoo Demos `__ @endsphinxdirective diff --git a/docs/OV_Runtime_UG/ov_dynamic_shapes.md b/docs/OV_Runtime_UG/ov_dynamic_shapes.md index 782029223db..f318105a40b 100644 --- a/docs/OV_Runtime_UG/ov_dynamic_shapes.md +++ b/docs/OV_Runtime_UG/ov_dynamic_shapes.md @@ -62,7 +62,7 @@ Model input dimensions can be specified as dynamic using the model.reshape metho Some models may already have dynamic shapes out of the box and do not require additional configuration. This can either be because it was generated with dynamic shapes from the source framework, or because it was converted with Model Conversion API to use dynamic shapes. For more information, see the Dynamic Dimensions “Out of the Box” section. -The examples below show how to set dynamic dimensions with a model that has a static ``[1, 3, 224, 224]`` input shape (such as `mobilenet-v2 `__). The first example shows how to change the first dimension (batch size) to be dynamic. In the second example, the third and fourth dimensions (height and width) are set as dynamic. +The examples below show how to set dynamic dimensions with a model that has a static ``[1, 3, 224, 224]`` input shape (such as `mobilenet-v2 `__). The first example shows how to change the first dimension (batch size) to be dynamic. In the second example, the third and fourth dimensions (height and width) are set as dynamic. .. tab-set:: @@ -175,7 +175,7 @@ The lower and/or upper bounds of a dynamic dimension can also be specified. They .. tab-item:: C :sync: c - The dimension bounds can be coded as arguments for `ov_dimension `__, as shown in these examples: + The dimension bounds can be coded as arguments for `ov_dimension `__, as shown in these examples: .. doxygensnippet:: docs/snippets/ov_dynamic_shapes.c :language: cpp diff --git a/docs/OV_Runtime_UG/preprocessing_usecase_save.md b/docs/OV_Runtime_UG/preprocessing_usecase_save.md index b52c063c7fb..71de4a7e5cc 100644 --- a/docs/OV_Runtime_UG/preprocessing_usecase_save.md +++ b/docs/OV_Runtime_UG/preprocessing_usecase_save.md @@ -110,8 +110,8 @@ Additional Resources * :doc:`Layout API overview ` * :doc:`Model Optimizer - Optimize Preprocessing Computation ` * :doc:`Model Caching Overview ` -* The `ov::preprocess::PrePostProcessor `__ C++ class documentation -* The `ov::pass::Serialize `__ - pass to serialize model to XML/BIN -* The `ov::set_batch `__ - update batch dimension for a given model +* The `ov::preprocess::PrePostProcessor `__ C++ class documentation +* The `ov::pass::Serialize `__ - pass to serialize model to XML/BIN +* The `ov::set_batch `__ - update batch dimension for a given model @endsphinxdirective diff --git a/docs/benchmarks/performance_benchmarks.md b/docs/benchmarks/performance_benchmarks.md index fc2b582dd38..9c95329e184 100644 --- a/docs/benchmarks/performance_benchmarks.md +++ b/docs/benchmarks/performance_benchmarks.md @@ -13,7 +13,7 @@ openvino_docs_performance_benchmarks_faq OpenVINO Accuracy - Performance Data Spreadsheet (download xlsx) + Performance Data Spreadsheet (download xlsx) openvino_docs_MO_DG_Getting_Performance_Numbers diff --git a/docs/dev/cmake_options_for_custom_compilation.md b/docs/dev/cmake_options_for_custom_compilation.md index 5142645d8bc..1b4f3b7eb57 100644 --- a/docs/dev/cmake_options_for_custom_compilation.md +++ b/docs/dev/cmake_options_for_custom_compilation.md @@ -189,8 +189,8 @@ In this case OpenVINO CMake scripts take `TBBROOT` environment variable into acc [pugixml]:https://pugixml.org/ [ONNX]:https://onnx.ai/ [protobuf]:https://github.com/protocolbuffers/protobuf -[deployment manager]:https://docs.openvino.ai/2023.0/openvino_docs_install_guides_deployment_manager_tool.html -[OpenVINO Runtime Introduction]:https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_Integrate_OV_with_your_application.html +[deployment manager]:https://docs.openvino.ai/2023.1/openvino_docs_install_guides_deployment_manager_tool.html +[OpenVINO Runtime Introduction]:https://docs.openvino.ai/2023.1/openvino_docs_OV_UG_Integrate_OV_with_your_application.html [PDPD]:https://github.com/PaddlePaddle/Paddle [TensorFlow]:https://www.tensorflow.org/ [TensorFlow Lite]:https://www.tensorflow.org/lite diff --git a/docs/dev/debug_capabilities.md b/docs/dev/debug_capabilities.md index c576cd9879f..52c19eacdd2 100644 --- a/docs/dev/debug_capabilities.md +++ b/docs/dev/debug_capabilities.md @@ -2,7 +2,7 @@ OpenVINO components provides different debug capabilities, to get more information please read: -* [OpenVINO Model Debug Capabilities](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_Model_Representation.html#model-debug-capabilities) +* [OpenVINO Model Debug Capabilities](https://docs.openvino.ai/2023.1/openvino_docs_OV_UG_Model_Representation.html#model-debug-capabilities) * [OpenVINO Pass Manager Debug Capabilities](#todo) ## See also diff --git a/docs/gapi/face_beautification.md b/docs/gapi/face_beautification.md index b5201f19561..5b11a5c45e6 100644 --- a/docs/gapi/face_beautification.md +++ b/docs/gapi/face_beautification.md @@ -24,8 +24,8 @@ This sample requires: * OpenCV 4.2 or higher built with `Intel® Distribution of OpenVINO™ Toolkit `__ (building with `Intel® TBB `__ is a plus) * The following pre-trained models from the :doc:`Open Model Zoo ` - * `face-detection-adas-0001 `__ - * `facial-landmarks-35-adas-0002 `__ + * `face-detection-adas-0001 `__ + * `facial-landmarks-35-adas-0002 `__ To download the models from the Open Model Zoo, use the :doc:`Model Downloader ` tool. diff --git a/docs/gapi/gapi_face_analytics_pipeline.md b/docs/gapi/gapi_face_analytics_pipeline.md index e1c25c7d134..dc34bcbb03b 100644 --- a/docs/gapi/gapi_face_analytics_pipeline.md +++ b/docs/gapi/gapi_face_analytics_pipeline.md @@ -24,9 +24,9 @@ This sample requires: * OpenCV 4.2 or higher built with `Intel® Distribution of OpenVINO™ Toolkit `__ (building with `Intel® TBB `__ is a plus) * The following pre-trained models from the :doc:`Open Model Zoo ` - * `face-detection-adas-0001 `__ - * `age-gender-recognition-retail-0013 `__ - * `emotions-recognition-retail-0003 `__ + * `face-detection-adas-0001 `__ + * `age-gender-recognition-retail-0013 `__ + * `emotions-recognition-retail-0003 `__ To download the models from the Open Model Zoo, use the :doc:`Model Downloader ` tool. @@ -42,7 +42,7 @@ Starting with version 4.2, OpenCV offers a solution to this problem. OpenCV G-AP Pipeline Overview ################# -Our sample application is based on `Interactive Face Detection `__ demo from Open Model Zoo. A simplified pipeline consists of the following steps: +Our sample application is based on `Interactive Face Detection `__ demo from Open Model Zoo. A simplified pipeline consists of the following steps: 1. Image acquisition and decode 2. Detection with preprocessing diff --git a/docs/home.rst b/docs/home.rst index 0fd9241372e..02e94efe76e 100644 --- a/docs/home.rst +++ b/docs/home.rst @@ -23,10 +23,10 @@ OpenVINO 2023.0
diff --git a/docs/install_guides/installing-openvino-pip.md b/docs/install_guides/installing-openvino-pip.md index 3d586984c9d..00413eeae3d 100644 --- a/docs/install_guides/installing-openvino-pip.md +++ b/docs/install_guides/installing-openvino-pip.md @@ -111,16 +111,16 @@ Now that you've installed OpenVINO Runtime, you're ready to run your own machine .. image:: https://user-images.githubusercontent.com/15709723/127752390-f6aa371f-31b5-4846-84b9-18dd4f662406.gif :width: 400 -Try the `Python Quick Start Example `__ to estimate depth in a scene using an OpenVINO monodepth model in a Jupyter Notebook inside your web browser. +Try the `Python Quick Start Example `__ to estimate depth in a scene using an OpenVINO monodepth model in a Jupyter Notebook inside your web browser. Get started with Python +++++++++++++++++++++++ Visit the :doc:`Tutorials ` page for more Jupyter Notebooks to get you started with OpenVINO, such as: -* `OpenVINO Python API Tutorial `__ -* `Basic image classification program with Hello Image Classification `__ -* `Convert a PyTorch model and use it for image background removal `__ +* `OpenVINO Python API Tutorial `__ +* `Basic image classification program with Hello Image Classification `__ +* `Convert a PyTorch model and use it for image background removal `__ Run OpenVINO on accelerated devices +++++++++++++++++++++++++++++++++++ diff --git a/docs/install_guides/pypi-openvino-dev.md b/docs/install_guides/pypi-openvino-dev.md index 1826a5f3b2a..df7568f9a17 100644 --- a/docs/install_guides/pypi-openvino-dev.md +++ b/docs/install_guides/pypi-openvino-dev.md @@ -127,7 +127,7 @@ For example, to install and configure the components for working with TensorFlow ## Troubleshooting -For general troubleshooting steps and issues, see [Troubleshooting Guide for OpenVINO Installation](https://docs.openvino.ai/2023.0/openvino_docs_get_started_guide_troubleshooting.html). The following sections also provide explanations to several error messages. +For general troubleshooting steps and issues, see [Troubleshooting Guide for OpenVINO Installation](https://docs.openvino.ai/2023.1/openvino_docs_get_started_guide_troubleshooting.html). The following sections also provide explanations to several error messages. ### Errors with Installing via PIP for Users in China diff --git a/docs/install_guides/pypi-openvino-rt.md b/docs/install_guides/pypi-openvino-rt.md index 88cfccf4bb4..2007e88dc1a 100644 --- a/docs/install_guides/pypi-openvino-rt.md +++ b/docs/install_guides/pypi-openvino-rt.md @@ -5,7 +5,7 @@ Intel® Distribution of OpenVINO™ toolkit is an open-source toolkit for optimizing and deploying AI inference. It can be used to develop applications and solutions based on deep learning tasks, such as: emulation of human vision, automatic speech recognition, natural language processing, recommendation systems, etc. It provides high-performance and rich deployment options, from edge to cloud. -If you have already finished developing your models and converting them to the OpenVINO model format, you can install OpenVINO Runtime to deploy your applications on various devices. The [OpenVINO™ Runtime](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_OV_Runtime_User_Guide.html) Python package includes a set of libraries for an easy inference integration with your products. +If you have already finished developing your models and converting them to the OpenVINO model format, you can install OpenVINO Runtime to deploy your applications on various devices. The [OpenVINO™ Runtime](https://docs.openvino.ai/2023.1/openvino_docs_OV_UG_OV_Runtime_User_Guide.html) Python package includes a set of libraries for an easy inference integration with your products. ## System Requirements @@ -72,7 +72,7 @@ If installation was successful, you will see the list of available devices. ## Troubleshooting -For general troubleshooting steps and issues, see [Troubleshooting Guide for OpenVINO Installation](https://docs.openvino.ai/2023.0/openvino_docs_get_started_guide_troubleshooting.html). The following sections also provide explanations to several error messages. +For general troubleshooting steps and issues, see [Troubleshooting Guide for OpenVINO Installation](https://docs.openvino.ai/2023.1/openvino_docs_get_started_guide_troubleshooting.html). The following sections also provide explanations to several error messages. ### Errors with Installing via PIP for Users in China diff --git a/docs/notebooks/001-hello-world-with-output.rst b/docs/notebooks/001-hello-world-with-output.rst index b5fc484fc04..797cc193e53 100644 --- a/docs/notebooks/001-hello-world-with-output.rst +++ b/docs/notebooks/001-hello-world-with-output.rst @@ -7,7 +7,7 @@ This basic introduction to OpenVINO™ shows how to do inference with an image classification model. A pre-trained `MobileNetV3 -model `__ +model `__ from `Open Model Zoo `__ is used in this tutorial. For more information about how OpenVINO IR models are diff --git a/docs/notebooks/002-openvino-api-with-output.rst b/docs/notebooks/002-openvino-api-with-output.rst index ef4eca621d2..d66cee65452 100644 --- a/docs/notebooks/002-openvino-api-with-output.rst +++ b/docs/notebooks/002-openvino-api-with-output.rst @@ -104,7 +104,7 @@ After initializing OpenVINO Runtime, first read the model file with ``compile_model()`` method. `OpenVINO™ supports several model -formats `__ +formats `__ and enables developers to convert them to its own OpenVINO IR format using a tool dedicated to this task. @@ -123,7 +123,7 @@ file has a different filename, it can be specified using the ``weights`` parameter in ``read_model()``. The OpenVINO `model conversion -API `__ +API `__ tool is used to convert models to OpenVINO IR format. Model conversion API reads the original model and creates an OpenVINO IR model (``.xml`` and ``.bin`` files) so inference can be performed without delays due to @@ -299,7 +299,7 @@ TensorFlow models saved in frozen graph format can also be passed to support will be provided in the upcoming 2023 releases. Currently support is limited to only frozen graph inference format. Other TensorFlow model formats must be converted to OpenVINO IR using - `model conversion API `__. + `model conversion API `__. .. code:: ipython3 @@ -573,7 +573,7 @@ Doing Inference on a Model The diagram below shows a typical inference pipeline with OpenVINO -.. figure:: https://docs.openvino.ai/2023.0/_images/IMPLEMENT_PIPELINE_with_API_C.svg +.. figure:: https://docs.openvino.ai/2023.1/_images/IMPLEMENT_PIPELINE_with_API_C.svg :alt: image.png image.png diff --git a/docs/notebooks/003-hello-segmentation-with-output.rst b/docs/notebooks/003-hello-segmentation-with-output.rst index de8e1d16974..d745565da2c 100644 --- a/docs/notebooks/003-hello-segmentation-with-output.rst +++ b/docs/notebooks/003-hello-segmentation-with-output.rst @@ -6,7 +6,7 @@ Hello Image Segmentation A very basic introduction to using segmentation models with OpenVINO™. In this tutorial, a pre-trained -`road-segmentation-adas-0001 `__ +`road-segmentation-adas-0001 `__ model from the `Open Model Zoo `__ is used. ADAS stands for Advanced Driver Assistance Services. The model diff --git a/docs/notebooks/004-hello-detection-with-output.rst b/docs/notebooks/004-hello-detection-with-output.rst index 8a96d8e68f0..b5b1a183e60 100644 --- a/docs/notebooks/004-hello-detection-with-output.rst +++ b/docs/notebooks/004-hello-detection-with-output.rst @@ -7,7 +7,7 @@ A very basic introduction to using object detection models with OpenVINO™. The -`horizontal-text-detection-0001 `__ +`horizontal-text-detection-0001 `__ model from `Open Model Zoo `__ is used. It detects horizontal text in images and returns a blob of data in the diff --git a/docs/notebooks/101-tensorflow-classification-to-openvino-with-output.rst b/docs/notebooks/101-tensorflow-classification-to-openvino-with-output.rst index 6971a252d7d..50b81fc51ea 100644 --- a/docs/notebooks/101-tensorflow-classification-to-openvino-with-output.rst +++ b/docs/notebooks/101-tensorflow-classification-to-openvino-with-output.rst @@ -4,13 +4,13 @@ Convert a TensorFlow Model to OpenVINO™ | This short tutorial shows how to convert a TensorFlow - `MobileNetV3 `__ + `MobileNetV3 `__ image classification model to OpenVINO `Intermediate - Representation `__ + Representation `__ (OpenVINO IR) format, using `model conversion - API `__. + API `__. After creating the OpenVINO IR, load the model in `OpenVINO - Runtime `__ + Runtime `__ and do inference with a sample image. @@ -140,7 +140,7 @@ model directory and returns OpenVINO Model class instance which represents this model. Obtained model is ready to use and to be loaded on a device using ``compile_model`` or can be saved on a disk using the ``serialize`` function. See the -`tutorial `__ +`tutorial `__ for more information about using model conversion API with TensorFlow models. @@ -273,7 +273,7 @@ Timing `⇑ <#top>`__ Measure the time it takes to do inference on thousand images. This gives an indication of performance. For more accurate benchmarking, use the `Benchmark -Tool `__ +Tool `__ in OpenVINO. Note that many optimizations are possible to improve the performance. diff --git a/docs/notebooks/102-pytorch-onnx-to-openvino-with-output.rst b/docs/notebooks/102-pytorch-onnx-to-openvino-with-output.rst index 4ff0c24ecd7..ac8ce1e7bdf 100644 --- a/docs/notebooks/102-pytorch-onnx-to-openvino-with-output.rst +++ b/docs/notebooks/102-pytorch-onnx-to-openvino-with-output.rst @@ -210,7 +210,7 @@ Convert ONNX Model to OpenVINO IR Format `⇑ <#top>`__ To convert the ONNX model to OpenVINO IR with ``FP16`` precision, use model conversion API. The models are saved inside the current directory. For more information on how to convert models, see this -`page `__. +`page `__. .. code:: ipython3 @@ -452,7 +452,7 @@ Performance Comparison `⇑ <#top>`__ 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 `__. +Tool `__. Keep in mind that many optimizations are possible to improve the performance. @@ -549,6 +549,6 @@ References `⇑ <#top>`__ - `OpenVINO ONNX support `__ - `Model Conversion API - documentation `__ + documentation `__ - `Converting Pytorch - model `__ + model `__ diff --git a/docs/notebooks/102-pytorch-to-openvino-with-output.rst b/docs/notebooks/102-pytorch-to-openvino-with-output.rst index be0a9038b08..d2b0b57549b 100644 --- a/docs/notebooks/102-pytorch-to-openvino-with-output.rst +++ b/docs/notebooks/102-pytorch-to-openvino-with-output.rst @@ -239,7 +239,7 @@ Starting from the 2023.0 release OpenVINO supports direct PyTorch models conversion to OpenVINO Intermediate Representation (IR) format. Model Optimizer Python API should be used for these purposes. More details regarding PyTorch model conversion can be found in OpenVINO -`documentation `__ +`documentation `__ .. note:: @@ -268,7 +268,7 @@ parameters, such as: and any other advanced options supported by model conversion Python API. More details can be found on this -`page `__ +`page `__ .. code:: ipython3 diff --git a/docs/notebooks/103-paddle-to-openvino-classification-with-output.rst b/docs/notebooks/103-paddle-to-openvino-classification-with-output.rst index 94f284cf674..5c8a9fefd2b 100644 --- a/docs/notebooks/103-paddle-to-openvino-classification-with-output.rst +++ b/docs/notebooks/103-paddle-to-openvino-classification-with-output.rst @@ -267,7 +267,7 @@ accept path to PaddlePaddle model and returns OpenVINO Model class instance which represents this model. Obtained model is ready to use and loading on device using ``compile_model`` or can be saved on disk using ``serialize`` function. See the `Model Optimizer Developer -Guide `__ +Guide `__ for more information about Model Optimizer. .. code:: ipython3 @@ -368,7 +368,7 @@ Measure the time it takes to do inference on fifty images and compare the result. The timing information gives an indication of performance. For a fair comparison, we include the time it takes to process the image. For more accurate benchmarking, use the `OpenVINO benchmark -tool `__. +tool `__. Note that many optimizations are possible to improve the performance. .. code:: ipython3 @@ -498,6 +498,6 @@ References `⇑ <#top>`__ - `PaddleClas `__ - `OpenVINO PaddlePaddle - support `__ + support `__ - `OpenVINO Model Optimizer - Documentation `__ + Documentation `__ diff --git a/docs/notebooks/104-model-tools-with-output.rst b/docs/notebooks/104-model-tools-with-output.rst index 441028017b4..47cd5fd7e26 100644 --- a/docs/notebooks/104-model-tools-with-output.rst +++ b/docs/notebooks/104-model-tools-with-output.rst @@ -212,9 +212,9 @@ Converting mobilenet-v2-pytorch… Conversion command: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/python -- /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/mo --framework=onnx --output_dir=/tmp/tmp3q4nxrwu --model_name=mobilenet-v2-pytorch --input=data '--mean_values=data[123.675,116.28,103.53]' '--scale_values=data[58.624,57.12,57.375]' --reverse_input_channels --output=prob --input_model=model/public/mobilenet-v2-pytorch/mobilenet-v2.onnx '--layout=data(NCHW)' '--input_shape=[1, 3, 224, 224]' --compress_to_fp16=True [ INFO ] Generated IR will be compressed to FP16. If you get lower accuracy, please consider disabling compression by removing argument --compress_to_fp16 or set it to false --compress_to_fp16=False. - Find more information about compression to FP16 at https://docs.openvino.ai/latest/openvino_docs_MO_DG_FP16_Compression.html + Find more information about compression to FP16 at https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_FP16_Compression.html [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/latest/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /tmp/tmp3q4nxrwu/mobilenet-v2-pytorch.xml [ SUCCESS ] BIN file: /tmp/tmp3q4nxrwu/mobilenet-v2-pytorch.bin diff --git a/docs/notebooks/105-language-quantize-bert-with-output.rst b/docs/notebooks/105-language-quantize-bert-with-output.rst index c7cdfb21086..61c8d152e6b 100644 --- a/docs/notebooks/105-language-quantize-bert-with-output.rst +++ b/docs/notebooks/105-language-quantize-bert-with-output.rst @@ -594,7 +594,7 @@ Frames Per Second (FPS) for images. Finally, measure the inference performance of OpenVINO ``FP32`` and ``INT8`` models. For this purpose, use -`Benchmark Tool `__ +`Benchmark Tool `__ in OpenVINO. .. note:: diff --git a/docs/notebooks/106-auto-device-with-output.rst b/docs/notebooks/106-auto-device-with-output.rst index 98166495d23..b1e37e02f7a 100644 --- a/docs/notebooks/106-auto-device-with-output.rst +++ b/docs/notebooks/106-auto-device-with-output.rst @@ -2,19 +2,19 @@ Automatic Device Selection with OpenVINO™ ========================================= The `Auto -device `__ +device `__ (or AUTO in short) selects the most suitable device for inference by considering the model precision, power efficiency and processing capability of the available `compute -devices `__. +devices `__. The model precision (such as ``FP32``, ``FP16``, ``INT8``, etc.) is the first consideration to filter out the devices that cannot run the network efficiently. Next, if dedicated accelerators are available, these devices are preferred (for example, integrated and discrete -`GPU `__). -`CPU `__ +`GPU `__). +`CPU `__ is used as the default “fallback device”. Keep in mind that AUTO makes this selection only once, during the loading of a model. @@ -100,7 +100,7 @@ with ``openvino.runtime.Core().compile_model`` or serialized for next usage with ``openvino.runtime.serialize``. For more information about model conversion API, see this -`page `__. +`page `__. .. code:: ipython3 @@ -312,8 +312,8 @@ hints do not require any device-specific settings and they are completely portable between devices – meaning AUTO can configure the performance hint on whichever device is being used. -For more information, refer to the `Performance Hints `__ -section of `Automatic Device Selection `__ +For more information, refer to the `Performance Hints `__ +section of `Automatic Device Selection `__ article. Class and callback definition `⇑ <#top>`__ diff --git a/docs/notebooks/107-speech-recognition-quantization-data2vec-with-output.rst b/docs/notebooks/107-speech-recognition-quantization-data2vec-with-output.rst index 39cf07b4452..313abe78024 100644 --- a/docs/notebooks/107-speech-recognition-quantization-data2vec-with-output.rst +++ b/docs/notebooks/107-speech-recognition-quantization-data2vec-with-output.rst @@ -347,7 +347,7 @@ steps: 1. Create a Dataset for quantization. 2. Run ``nncf.quantize`` for getting an optimized model. The ``nncf.quantize`` function provides an interface for model quantization. It requires an instance of the OpenVINO Model and quantization dataset. Optionally, some additional parameters for the configuration quantization process (number of samples for quantization, preset, ignored scope, etc.) can be provided. For more accurate results, we should keep the operation in the postprocessing subgraph in floating point precision, using the ``ignored_scope`` parameter. ``advanced_parameters`` can be used to specify advanced quantization parameters for fine-tuning the quantization algorithm. In this tutorial we pass range estimator parameters for activations. For more information see -`Tune quantization parameters `__. +`Tune quantization parameters `__. 3. Serialize OpenVINO IR model using ``openvino.runtime.serialize`` function. .. code:: ipython3 @@ -661,7 +661,7 @@ Compare Performance of the Original and Quantized Models `⇑ <#top>`__ ############################################################################################################################### `Benchmark -Tool `__ +Tool `__ is used to measure the inference performance of the ``FP16`` and ``INT8`` models. diff --git a/docs/notebooks/108-gpu-device-with-output.rst b/docs/notebooks/108-gpu-device-with-output.rst index 9d7f69faec7..fc236c92b83 100644 --- a/docs/notebooks/108-gpu-device-with-output.rst +++ b/docs/notebooks/108-gpu-device-with-output.rst @@ -80,10 +80,10 @@ cards `__. To get started, first `install -OpenVINO `__ +OpenVINO `__ on a system equipped with one or more Intel GPUs. Follow the `GPU configuration -instructions `__ +instructions `__ to configure OpenVINO to work with your GPU. Then, read on to learn how to accelerate inference with GPUs in OpenVINO! @@ -150,12 +150,12 @@ the system has a CPU, an integrated and discrete GPU, we should expect to see a list like this: ``['CPU', 'GPU.0', 'GPU.1']``. To simplify its use, the “GPU.0” can also be addressed with just “GPU”. For more details, see the `Device Naming -Convention `__ +Convention `__ section. If the GPUs are installed correctly on the system and still do not appear in the list, follow the steps described -`here `__ +`here `__ to configure your GPU drivers to work with OpenVINO. Once we have the GPUs working with OpenVINO, we can proceed with the next sections. @@ -269,7 +269,7 @@ the key properties are: speed up compilation time. To learn more about devices and properties, see the `Query Device -Properties `__ +Properties `__ page. Compiling a Model on GPU `⇑ <#top>`__ @@ -279,7 +279,7 @@ Compiling a Model on GPU `⇑ <#top>`__ Now, we know how to list the GPUs in the system and check their properties. We can easily use one for compiling and running models with OpenVINO `GPU -plugin `__. +plugin `__. Download and Convert a Model `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -357,7 +357,7 @@ Convert the Model to OpenVINO IR format `⇑ <#top>`__ To convert the model to OpenVINO IR with ``FP16`` precision, use model conversion API. The models are saved to the ``model/ir_model/`` directory. For more details about model conversion, see this -`page `__. +`page `__. .. code:: ipython3 @@ -418,7 +418,7 @@ the ``available_devices`` method are valid device specifiers. You may also use “AUTO”, which will automatically select the best device for inference (which is often the GPU). To learn more about AUTO plugin, visit the `Automatic Device -Selection `__ +Selection `__ page as well as the `AUTO device tutorial `__. @@ -489,7 +489,7 @@ compile times with caching enabled and disabled as follows: The actual time improvements will depend on the environment as well as the model being used but it is definitely something to consider when optimizing an application. To read more about this, see the `Model -Caching `__ +Caching `__ docs. Throughput and Latency Performance Hints `⇑ <#top>`__ @@ -529,12 +529,12 @@ Using Multiple GPUs with Multi-Device and Cumulative Throughput `⇑ <#top>`__ The latency and throughput hints mentioned above are great and can make a difference when used adequately but they usually use just one device, either due to the `AUTO -plugin `__ +plugin `__ or by manual specification of the device name as above. When we have multiple devices, such as an integrated and discrete GPU, we may use both at the same time to improve the utilization of the resources. In order to do this, OpenVINO provides a virtual device called -`MULTI `__, +`MULTI `__, which is just a combination of the existent devices that knows how to split inference work between them, leveraging the capabilities of each device. @@ -563,7 +563,7 @@ manually specify devices to use. Below is an example showing how to use how to set up an asynchronous pipeline that takes advantage of parallelism to increase throughput. To learn more, see `Asynchronous - Inferencing `__ + Inferencing `__ in OpenVINO as well as the `Asynchronous Inference notebook `__. @@ -589,7 +589,7 @@ Note that benchmark_app only requires the model path to run but both the device and hint arguments will be useful to us. For more advanced usages, the tool itself has other options that can be checked by running ``benchmark_app -h`` or reading the -`docs `__. +`docs `__. The following example shows how to benchmark a simple model, using a GPU with a latency focus: @@ -1363,18 +1363,18 @@ To read more about any of these topics, feel free to visit their corresponding documentation: - `GPU - Plugin `__ + Plugin `__ - `AUTO - Plugin `__ + Plugin `__ - `Model - Caching `__ + Caching `__ - `MULTI Device - Mode `__ + Mode `__ - `Query Device - Properties `__ + Properties `__ - `Configurations for GPUs with - OpenVINO `__ + OpenVINO `__ - `Benchmark Python - Tool `__ + Tool `__ - `Asynchronous - Inferencing `__ + Inferencing `__ diff --git a/docs/notebooks/109-latency-tricks-with-output.rst b/docs/notebooks/109-latency-tricks-with-output.rst index 5d2d14fa85d..4ce64f56c5a 100644 --- a/docs/notebooks/109-latency-tricks-with-output.rst +++ b/docs/notebooks/109-latency-tricks-with-output.rst @@ -514,7 +514,7 @@ OpenVINO IR model + more inference threads `⇑ <#top>`__ There is a possibility to add a config for any device (CPU in this case). We will increase the number of threads to an equal number of our cores. It should help us a lot. There are `more -options `__ +options `__ to be changed, so it’s worth playing with them to see what works best in our case. @@ -546,7 +546,7 @@ OpenVINO IR model in latency mode `⇑ <#top>`__ OpenVINO offers a virtual device called -`AUTO `__, +`AUTO `__, which can select the best device for us based on a performance hint. There are three different hints: ``LATENCY``, ``THROUGHPUT``, and ``CUMULATIVE_THROUGHPUT``. As this notebook is focused on the latency @@ -665,6 +665,6 @@ object detection model. Even if you experience much better performance after running this notebook, please note this may not be valid for every hardware or every model. For the most accurate results, please use ``benchmark_app`` `command-line -tool `__. +tool `__. Note that ``benchmark_app`` cannot measure the impact of some tricks above, e.g., shared memory. diff --git a/docs/notebooks/109-throughput-tricks-with-output.rst b/docs/notebooks/109-throughput-tricks-with-output.rst index c5e7a2c9646..c9259e4b395 100644 --- a/docs/notebooks/109-throughput-tricks-with-output.rst +++ b/docs/notebooks/109-throughput-tricks-with-output.rst @@ -500,7 +500,7 @@ configuration of the device. There are three different hints: notebook is focused on the throughput mode, we will use the latter two. The hints can be used with other devices as well. Throughput mode implicitly triggers using the `Automatic -Batching `__ +Batching `__ feature, which sets the batch size to the optimal level. .. code:: ipython3 @@ -556,7 +556,7 @@ OpenVINO IR model in throughput mode on AUTO `⇑ <#top>`__ OpenVINO offers a virtual device called -`AUTO `__, +`AUTO `__, which can select the best device for us based on the aforementioned performance hint. @@ -671,7 +671,7 @@ There are other tricks for performance improvement, such as advanced options, quantization and pre-post-processing or dedicated to latency mode. To get even more from your model, please visit `advanced throughput -options `__, +options `__, `109-latency-tricks <109-latency-tricks-with-output.html>`__, `111-detection-quantization <111-yolov5-quantization-migration-with-output.html>`__, and `118-optimize-preprocessing <118-optimize-preprocessing-with-output.html>`__. @@ -722,6 +722,6 @@ object detection model. Even if you experience much better performance after running this notebook, please note this may not be valid for every hardware or every model. For the most accurate results, please use ``benchmark_app`` `command-line -tool `__. +tool `__. Note that ``benchmark_app`` cannot measure the impact of some tricks above. diff --git a/docs/notebooks/110-ct-scan-live-inference-with-output.rst b/docs/notebooks/110-ct-scan-live-inference-with-output.rst index 0f3e10cca74..9ae34d9db77 100644 --- a/docs/notebooks/110-ct-scan-live-inference-with-output.rst +++ b/docs/notebooks/110-ct-scan-live-inference-with-output.rst @@ -113,7 +113,7 @@ Benchmark Model Performance `⇑ <#top>`__ ############################################################################################################################### To measure the inference performance of the IR model, use -`Benchmark Tool `__ +`Benchmark Tool `__ - an inference performance measurement tool in OpenVINO. Benchmark tool is a command-line application that can be run in the notebook with ``! benchmark_app`` or ``%sx benchmark_app`` commands. @@ -297,7 +297,7 @@ model will be cached, so after the first time model loading will be faster. For more information on OpenVINO Runtime, including Model Caching, refer to the `OpenVINO API tutorial <002-openvino-api-with-output.html>`__. -We will use `AsyncInferQueue `__ +We will use `AsyncInferQueue `__ to perform asynchronous inference. It can be instantiated with compiled model and a number of jobs - parallel execution threads. If you don’t pass a number of jobs or pass ``0``, then OpenVINO will pick the optimal diff --git a/docs/notebooks/110-ct-segmentation-quantize-nncf-with-output.rst b/docs/notebooks/110-ct-segmentation-quantize-nncf-with-output.rst index b7089acadd6..898fa83b906 100644 --- a/docs/notebooks/110-ct-segmentation-quantize-nncf-with-output.rst +++ b/docs/notebooks/110-ct-segmentation-quantize-nncf-with-output.rst @@ -14,7 +14,7 @@ scratch; the data is from This third tutorial in the series shows how to: - Convert an Original model to OpenVINO IR with `model conversion - API `__ + API `__ - Quantize a PyTorch model with NNCF - Evaluate the F1 score metric of the original model and the quantized model @@ -577,7 +577,7 @@ Compare Performance of the FP32 IR Model and Quantized Models `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ To measure the inference performance of the ``FP32`` and ``INT8`` -models, we use `Benchmark Tool `__ +models, we use `Benchmark Tool `__ - OpenVINO’s inference performance measurement tool. Benchmark tool is a command line application, part of OpenVINO development tools, that can be run in the notebook with ``! benchmark_app`` or diff --git a/docs/notebooks/111-yolov5-quantization-migration-with-output.rst b/docs/notebooks/111-yolov5-quantization-migration-with-output.rst index 6181e22d000..b297f3425da 100644 --- a/docs/notebooks/111-yolov5-quantization-migration-with-output.rst +++ b/docs/notebooks/111-yolov5-quantization-migration-with-output.rst @@ -2,7 +2,7 @@ Migrate quantization from POT API to NNCF API ============================================= This tutorial demonstrates how to migrate quantization pipeline written -using the OpenVINO `Post-Training Optimization Tool (POT) `__ to +using the OpenVINO `Post-Training Optimization Tool (POT) `__ to `NNCF Post-Training Quantization API `__. This tutorial is based on `Ultralytics YOLOv5 `__ model and additionally it compares model accuracy between the FP32 precision and quantized INT8 @@ -160,7 +160,7 @@ following content: Convert the ONNX model to OpenVINO Intermediate Representation (IR) -model generated by `model conversion API `__. +model generated by `model conversion API `__. We will use the ``openvino.tools.mo.convert_model`` function of model conversion Python API to convert ONNX model to OpenVINO Model, then it can be serialized using ``openvino.runtime.serialize``. As the result, @@ -462,7 +462,7 @@ Quantization parameters ``preset``, ``model_type``, ``subset_size``, ``fast_bias_correction``, ``ignored_scope`` are arguments of function. More details about supported parameters and formats can be found in NNCF Post-Training Quantization -`documentation `__. +`documentation `__. NNCF also expect providing model object in inference framework format, in our case ``openvino.runtime.Model`` instance created using ``core.read_model`` or ``openvino.tools.mo.convert_model``. @@ -1193,8 +1193,8 @@ References `⇑ <#top>`__ - `Ultralytics YOLOv5 `__ - `OpenVINO Post-training Optimization - Tool `__ + Tool `__ - `NNCF Post-training quantization `__ - `Model Conversion - API `__ + API `__ diff --git a/docs/notebooks/112-pytorch-post-training-quantization-nncf-with-output.rst b/docs/notebooks/112-pytorch-post-training-quantization-nncf-with-output.rst index 69d0e04db13..4b054d59389 100644 --- a/docs/notebooks/112-pytorch-post-training-quantization-nncf-with-output.rst +++ b/docs/notebooks/112-pytorch-post-training-quantization-nncf-with-output.rst @@ -474,7 +474,7 @@ framework is designed so that modifications to your original training code are minor. Quantization is the simplest scenario and requires a few modifications. For more information about NNCF Post Training Quantization (PTQ) API, refer to the `Basic Quantization Flow -Guide `__. +Guide `__. 1. Create a transformation function that accepts a sample from the dataset and returns data suitable for model inference. This enables @@ -555,7 +555,7 @@ Python API . The models will be saved to the ‘OUTPUT’ directory for later benchmarking. For more information about model conversion, refer to this -`page `__. +`page `__. Before converting models, export them to ONNX. Executing the following command may take a while. @@ -668,7 +668,7 @@ IV. Compare performance of INT8 model and FP32 model in OpenVINO `⇑ <#top>`__ Finally, measure the inference performance of the ``FP32`` and ``INT8`` models, using `Benchmark -Tool `__ +Tool `__ - an inference performance measurement tool in OpenVINO. By default, Benchmark Tool runs inference for 60 seconds in asynchronous mode on CPU. It returns inference speed as latency (milliseconds per image) and diff --git a/docs/notebooks/113-image-classification-quantization-with-output.rst b/docs/notebooks/113-image-classification-quantization-with-output.rst index 15e6e52b6f5..95f2f7695c1 100644 --- a/docs/notebooks/113-image-classification-quantization-with-output.rst +++ b/docs/notebooks/113-image-classification-quantization-with-output.rst @@ -100,7 +100,7 @@ static shape. The converted model is ready to be loaded on a device for inference and can be saved on a disk for next usage via the ``serialize`` function. More details about model conversion Python API can be found on this -`page `__. +`page `__. .. code:: ipython3 @@ -206,7 +206,7 @@ dataset for performing basic quantization. Optionally, additional parameters like ``subset_size``, ``preset``, ``ignored_scope`` can be provided to improve quantization result if applicable. More details about supported parameters can be found on this -`page `__ +`page `__ .. code:: ipython3 @@ -323,7 +323,7 @@ Compare Performance of the Original and Quantized Models `⇑ <#top>`__ Finally, measure the inference performance of the ``FP32`` and ``INT8`` models, using `Benchmark -Tool `__ +Tool `__ - an inference performance measurement tool in OpenVINO. .. note:: diff --git a/docs/notebooks/115-async-api-with-output.rst b/docs/notebooks/115-async-api-with-output.rst index bec3bc9e219..06a43e3aeb2 100644 --- a/docs/notebooks/115-async-api-with-output.rst +++ b/docs/notebooks/115-async-api-with-output.rst @@ -467,7 +467,7 @@ Compare the performance `⇑ <#top>`__ Asynchronous mode pipelines can be supported with the -`AsyncInferQueue `__ +`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 diff --git a/docs/notebooks/116-sparsity-optimization-with-output.rst b/docs/notebooks/116-sparsity-optimization-with-output.rst index 532094888de..c5ccc6437e9 100644 --- a/docs/notebooks/116-sparsity-optimization-with-output.rst +++ b/docs/notebooks/116-sparsity-optimization-with-output.rst @@ -12,7 +12,7 @@ which has been quantized, sparsified, and tuned for `SST2 datasets `__. It demonstrates the inference performance advantage on 4th Gen Intel® Xeon® Scalable Processors by running it with `Sparse Weight -Decompression `__, +Decompression `__, a runtime option that seizes model sparsity for efficiency. The notebook consists of the following steps: @@ -369,5 +369,5 @@ small sequence length, for example, 32 and lower. For more details about asynchronous inference with OpenVINO, refer to the following documentation: -- `Deployment Optimization Guide `__ -- `Inference Request API `__ +- `Deployment Optimization Guide `__ +- `Inference Request API `__ diff --git a/docs/notebooks/117-model-server-with-output.rst b/docs/notebooks/117-model-server-with-output.rst index 7cf130e876b..272e3b3bdca 100644 --- a/docs/notebooks/117-model-server-with-output.rst +++ b/docs/notebooks/117-model-server-with-output.rst @@ -225,7 +225,7 @@ Check whether the OVMS container is running normally: The required Model Server parameters are listed below. For additional configuration options, see the -`Model Server Parameters section `__. +`Model Server Parameters section `__. .. raw:: html @@ -884,6 +884,6 @@ References `⇑ <#top>`__ 1. `OpenVINO™ Model Server - documentation `__ + documentation `__ 2. `OpenVINO™ Model Server GitHub repository `__ diff --git a/docs/notebooks/118-optimize-preprocessing-with-output.rst b/docs/notebooks/118-optimize-preprocessing-with-output.rst index e9f19e107c9..cebce914098 100644 --- a/docs/notebooks/118-optimize-preprocessing-with-output.rst +++ b/docs/notebooks/118-optimize-preprocessing-with-output.rst @@ -11,9 +11,9 @@ instrument, that enables integration of preprocessing steps into an execution graph and performing it on a selected device, which can improve device utilization. For more information about Preprocessing API, see this -`overview `__ +`overview `__ and -`details `__ +`details `__ This tutorial include following steps: @@ -217,7 +217,7 @@ Convert model to OpenVINO IR and setup preprocessing steps with model conversion To convert a TensorFlow model to OpenVINO IR, use the ``mo.convert_model`` python function of `model conversion -API `__. +API `__. The function returns instance of OpenVINO Model class, which is ready to use in Python interface but can also be serialized to OpenVINO IR format for future execution using ``openvino.runtime.serialize``. The models @@ -240,7 +240,7 @@ Setup the following conversions: Also converting of layout could be specified with ``layout`` option. More information and parameters described in the `Embedding Preprocessing Computation -article `__. +article `__. .. code:: ipython3 @@ -326,7 +326,7 @@ Graph modifications of a model shall be performed after the model is read from a drive and before it is loaded on the actual device. Pre-processing support following operations (please, see more details -`here `__) +`here `__) - Mean/Scale Normalization - Converting Precision @@ -360,7 +360,7 @@ Create ``PrePostProcessor`` Object `⇑ <#top>`__ The -`PrePostProcessor() `__ +`PrePostProcessor() `__ class enables specifying the preprocessing and postprocessing steps for a model. @@ -384,7 +384,7 @@ about user’s input tensor will be initialized to same data (type/shape/etc) as model’s input parameter. User application can override particular parameters according to application’s data. Refer to the following -`page `__ +`page `__ for more information about parameters for overriding. Below is all the specified input information: @@ -423,7 +423,7 @@ Declaring Model Layout `⇑ <#top>`__ Model input already has information about precision and shape. Preprocessing API is not intended to modify this. The only thing that may be specified is input data -`layout `__. +`layout `__. .. code:: ipython3 @@ -452,7 +452,7 @@ Preprocessing Steps `⇑ <#top>`__ Now, the sequence of preprocessing steps can be defined. For more information about preprocessing steps, see -`here `__. +`here `__. Perform the following: @@ -461,7 +461,7 @@ Perform the following: dynamic size, for example, ``{?, 3, ?, ?}`` resize will not know how to resize the picture. Therefore, in this case, target height/ width should be specified. For more details, see also the - `PreProcessSteps.resize() `__. + `PreProcessSteps.resize() `__. - Subtract mean from each channel. - Divide each pixel data to appropriate scale value. diff --git a/docs/notebooks/119-tflite-to-openvino-with-output.rst b/docs/notebooks/119-tflite-to-openvino-with-output.rst index 6bf4b8924cc..07d330269f8 100644 --- a/docs/notebooks/119-tflite-to-openvino-with-output.rst +++ b/docs/notebooks/119-tflite-to-openvino-with-output.rst @@ -10,11 +10,11 @@ machine learning models to edge devices. This short tutorial shows how to convert a TensorFlow Lite `EfficientNet-Lite-B0 `__ image classification model to OpenVINO `Intermediate -Representation `__ +Representation `__ (OpenVINO IR) format, using `Model -Optimizer `__. +Optimizer `__. After creating the OpenVINO IR, load the model in `OpenVINO -Runtime `__ +Runtime `__ and do inference with a sample image. .. _top: @@ -111,9 +111,9 @@ using ``serialize`` function, reducing loading time for next running. Optionally, we can apply compression to the FP16 model weights, using the ``compress_to_fp16=True`` option and integrate preprocessing using this approach. For more information about model conversion, see this -`page `__. +`page `__. For TensorFlow Lite models support, refer to this -`tutorial `__. +`tutorial `__. .. code:: ipython3 @@ -222,7 +222,7 @@ Select device from dropdown list for running inference using OpenVINO: Estimate Model Performance `⇑ <#top>`__ ############################################################################################################################### -`Benchmark Tool `__ +`Benchmark Tool `__ is used to measure the inference performance of the model on CPU and GPU. diff --git a/docs/notebooks/120-tensorflow-object-detection-to-openvino-with-output.rst b/docs/notebooks/120-tensorflow-object-detection-to-openvino-with-output.rst index 9e2ee531349..a66dcefb6a4 100644 --- a/docs/notebooks/120-tensorflow-object-detection-to-openvino-with-output.rst +++ b/docs/notebooks/120-tensorflow-object-detection-to-openvino-with-output.rst @@ -19,9 +19,9 @@ This tutorial shows how to convert a TensorFlow `Faster R-CNN with Resnet-50 V1 `__ object detection model to OpenVINO `Intermediate -Representation `__ +Representation `__ (OpenVINO IR) format, using `Model -Optimizer `__. +Optimizer `__. After creating the OpenVINO IR, load the model in `OpenVINO Runtime `__ and do inference with a sample image. @@ -182,9 +182,9 @@ or saved on disk using the ``serialize`` function to reduce loading time when the model is run in the future. See the `Model Optimizer Developer -Guide `__ +Guide `__ for more information about Model Optimizer and TensorFlow `models -support `__. +support `__. .. code:: ipython3 @@ -694,5 +694,4 @@ utilization. For more information, refer to the `Optimize Preprocessing tutorial <118-optimize-preprocessing-with-output.html>`__ -and to the overview of `Preprocessing -API `__. +and to the overview of :doc:`Preprocessing API ` . diff --git a/docs/notebooks/121-convert-to-openvino-with-output.rst b/docs/notebooks/121-convert-to-openvino-with-output.rst index cf93b94ac74..13bca81bd9e 100644 --- a/docs/notebooks/121-convert-to-openvino-with-output.rst +++ b/docs/notebooks/121-convert-to-openvino-with-output.rst @@ -50,7 +50,7 @@ OpenVINO IR format ------------------ OpenVINO `Intermediate Representation -(IR) `__ is the +(IR) `__ is the proprietary model format of OpenVINO. It is produced after converting a model with model conversion API. Model conversion API translates the frequently used deep learning operations to their respective similar @@ -68,7 +68,7 @@ tool. You can choose one of them based on whichever is most convenient for you. There should not be any differences in the results of model conversion if the same set of parameters is used. For more details, refer to `Model -Preparation `__ +Preparation `__ documentation. .. code:: ipython3 @@ -956,7 +956,7 @@ To convert a model to OpenVINO IR, use the following command: - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/distilbert.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/distilbert.bin @@ -991,20 +991,20 @@ Both Python conversion API and Model Optimizer command-line tool provide the following capabilities: \* overriding original input shapes for model conversion with ``input`` and ``input_shape`` parameters. `Setting Input Shapes -guide `__. +guide `__. \* cutting off unwanted parts of a model (such as unsupported operations and training sub-graphs) using the ``input`` and ``output`` parameters to define new inputs and outputs of the converted model. `Cutting Off Parts of a Model -guide `__. +guide `__. \* inserting additional input pre-processing sub-graphs into the converted model by using the ``mean_values``, ``scales_values``, ``layout``, and other parameters. `Embedding Preprocessing Computation -article `__. +article `__. \* compressing the model weights (for example, weights for convolutions and matrix multiplications) to FP16 data type using ``compress_to_fp16`` compression parameter. `Compression of a Model to FP16 -guide `__. +guide `__. If the out-of-the-box conversion (only the ``input_model`` parameter is specified) is not successful, it may be required to use the parameters @@ -1023,7 +1023,7 @@ up static shapes, model conversion API provides the ``input`` and ``input_shape`` parameters. For more information refer to `Setting Input Shapes -guide `__. +guide `__. .. code:: ipython3 @@ -1042,7 +1042,7 @@ guide `__. +guide `__. .. code:: ipython3 @@ -1181,7 +1181,7 @@ guide `__. +article `__. Specifying Layout ^^^^^^^^^^^^^^^^^ @@ -1232,7 +1232,7 @@ for both inputs and outputs. Some preprocessing requires to set input layouts, for example, setting a batch, applying mean or scales, and reversing input channels (BGR<->RGB). For the layout syntax, check the `Layout API -overview `__. +overview `__. To specify the layout, you can use the layout option followed by the layout value. @@ -1253,7 +1253,7 @@ Resnet50 model that was exported to the ONNX format: - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin @@ -1291,7 +1291,7 @@ presented by input data. Use either ``layout`` or ``source_layout`` with - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin @@ -1300,7 +1300,7 @@ presented by input data. Use either ``layout`` or ``source_layout`` with - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin @@ -1342,7 +1342,7 @@ that the preprocessing takes negligible time for inference. - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin @@ -1351,7 +1351,7 @@ that the preprocessing takes negligible time for inference. - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin @@ -1390,7 +1390,7 @@ the color channels before inference. - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin @@ -1427,9 +1427,9 @@ models, this decrease is negligible. - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) [ INFO ] Generated IR will be compressed to FP16. If you get lower accuracy, please consider disabling compression by removing argument --compress_to_fp16 or set it to false --compress_to_fp16=False. - Find more information about compression to FP16 at https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_FP16_Compression.html + Find more information about compression to FP16 at https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_FP16_Compression.html [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.xml [ SUCCESS ] BIN file: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/notebooks/121-convert-to-openvino/model/resnet.bin diff --git a/docs/notebooks/201-vision-monodepth-with-output.rst b/docs/notebooks/201-vision-monodepth-with-output.rst index e98e4c37d8f..b26e82ff4e7 100644 --- a/docs/notebooks/201-vision-monodepth-with-output.rst +++ b/docs/notebooks/201-vision-monodepth-with-output.rst @@ -5,7 +5,7 @@ Monodepth Estimation with OpenVINO This tutorial demonstrates Monocular Depth Estimation with MidasNet in OpenVINO. Model information can be found -`here `__. +`here `__. .. figure:: https://user-images.githubusercontent.com/36741649/127173017-a0bbcf75-db24-4d2c-81b9-616e04ab7cd9.gif :alt: monodepth diff --git a/docs/notebooks/202-vision-superresolution-image-with-output.rst b/docs/notebooks/202-vision-superresolution-image-with-output.rst index 2a9c26e5342..6dd4a440732 100644 --- a/docs/notebooks/202-vision-superresolution-image-with-output.rst +++ b/docs/notebooks/202-vision-superresolution-image-with-output.rst @@ -7,7 +7,7 @@ Super Resolution is the process of enhancing the quality of an image by increasing the pixel count using deep learning. This notebook shows the Single Image Super Resolution (SISR) which takes just one low resolution image. A model called -`single-image-super-resolution-1032 `__, +`single-image-super-resolution-1032 `__, which is available in Open Model Zoo, is used in this tutorial. It is based on the research paper cited below. diff --git a/docs/notebooks/202-vision-superresolution-video-with-output.rst b/docs/notebooks/202-vision-superresolution-video-with-output.rst index 7b48a8c64ed..52152cad081 100644 --- a/docs/notebooks/202-vision-superresolution-video-with-output.rst +++ b/docs/notebooks/202-vision-superresolution-video-with-output.rst @@ -7,7 +7,7 @@ Super Resolution is the process of enhancing the quality of an image by increasing the pixel count using deep learning. This notebook applies Single Image Super Resolution (SISR) to frames in a 360p (480×360) video in 360p resolution. A model called -`single-image-super-resolution-1032 `__, +`single-image-super-resolution-1032 `__, which is available in Open Model Zoo, is used in this tutorial. It is based on the research paper cited below. diff --git a/docs/notebooks/203-meter-reader-with-output.rst b/docs/notebooks/203-meter-reader-with-output.rst index eeec4746977..e426fec36bd 100644 --- a/docs/notebooks/203-meter-reader-with-output.rst +++ b/docs/notebooks/203-meter-reader-with-output.rst @@ -571,7 +571,7 @@ Select device from dropdown list for running inference using OpenVINO: The number of detected meter from detection network can be arbitrary in some scenarios, which means the batch size of segmentation network input is a `dynamic -dimension `__, +dimension `__, and it should be specified as ``-1`` or the ``ov::Dimension()`` instead of a positive number used for static dimensions. In this case, for memory consumption optimization, we can specify the lower and/or upper diff --git a/docs/notebooks/204-segmenter-semantic-segmentation-with-output.rst b/docs/notebooks/204-segmenter-semantic-segmentation-with-output.rst index 29f412a4194..750508af698 100644 --- a/docs/notebooks/204-segmenter-semantic-segmentation-with-output.rst +++ b/docs/notebooks/204-segmenter-semantic-segmentation-with-output.rst @@ -450,7 +450,7 @@ While ONNX models are directly supported by OpenVINO runtime, it can be useful to convert them to IR format to take advantage of OpenVINO optimization tools and features. The ``mo.convert_model`` function of `model conversion -API `__ +API `__ can be used. The function returns instance of OpenVINO Model class, which is ready to use in Python interface but can also be serialized to OpenVINO IR format for future execution. @@ -603,7 +603,7 @@ Benchmarking performance of converted model `⇑ <#top>`__ Finally, use the OpenVINO `Benchmark -Tool `__ +Tool `__ to measure the inference performance of the model. Note that for more accurate performance, it is recommended to run diff --git a/docs/notebooks/205-vision-background-removal-with-output.rst b/docs/notebooks/205-vision-background-removal-with-output.rst index 1c4ae2d1696..976361459d5 100644 --- a/docs/notebooks/205-vision-background-removal-with-output.rst +++ b/docs/notebooks/205-vision-background-removal-with-output.rst @@ -223,7 +223,7 @@ repository `__ and multiplied by 255 to support images with pixel values from 0-255. For more information about model conversion, refer to this -`page `__. +`page `__. Executing the following command may take a while. @@ -422,7 +422,7 @@ References `⇑ <#top>`__ - `PIP install openvino-dev `__ - `Model Conversion - API `__ + API `__ - `U^2-Net `__ - U^2-Net research paper: `U^2-Net: Going Deeper with Nested U-Structure for Salient Object diff --git a/docs/notebooks/206-vision-paddlegan-anime-with-output.rst b/docs/notebooks/206-vision-paddlegan-anime-with-output.rst index 32cafa0c20c..0dc6a88ad4c 100644 --- a/docs/notebooks/206-vision-paddlegan-anime-with-output.rst +++ b/docs/notebooks/206-vision-paddlegan-anime-with-output.rst @@ -359,9 +359,9 @@ inputs are known, you can use model conversion API and convert the model to OpenVINO IR with these values. Use ``FP16`` precision and set log level to ``CRITICAL`` to ignore warnings that are irrelevant for this demo. For information about setting the parameters, see this -`page `__. +`page `__. -**Convert ONNX Model to OpenVINO IR with** `Model Conversion Python API `__ +**Convert ONNX Model to OpenVINO IR with** `Model Conversion Python API `__ .. code:: ipython3 @@ -596,7 +596,7 @@ References `⇑ <#top>`__ - `PaddleGAN `__ - `Paddle2ONNX `__ - `OpenVINO ONNX support `__ -- `Model Conversion API `__ +- `Model Conversion API `__ The PaddleGAN code that is shown in this notebook is written by PaddlePaddle Authors and licensed under the Apache 2.0 license. The diff --git a/docs/notebooks/208-optical-character-recognition-with-output.rst b/docs/notebooks/208-optical-character-recognition-with-output.rst index 871f7110dd1..30524055a60 100644 --- a/docs/notebooks/208-optical-character-recognition-with-output.rst +++ b/docs/notebooks/208-optical-character-recognition-with-output.rst @@ -9,9 +9,9 @@ This tutorial demonstrates how to perform optical character recognition tutorial, which shows only text detection. The -`horizontal-text-detection-0001 `__ +`horizontal-text-detection-0001 `__ and -`text-recognition-resnet `__ +`text-recognition-resnet `__ models are used together for text detection and then text recognition. In this tutorial, Open Model Zoo tools including Model Downloader, Model @@ -343,9 +343,9 @@ Converting text-recognition-resnet-fc… Conversion command: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/python -- /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/mo --framework=onnx --output_dir=/tmp/tmppkwl27u7 --model_name=text-recognition-resnet-fc --input=input '--mean_values=input[127.5]' '--scale_values=input[127.5]' --output=output --input_model=model/public/text-recognition-resnet-fc/resnet_fc.onnx '--layout=input(NCHW)' '--input_shape=[1, 1, 32, 100]' --compress_to_fp16=True [ INFO ] Generated IR will be compressed to FP16. If you get lower accuracy, please consider disabling compression by removing argument --compress_to_fp16 or set it to false --compress_to_fp16=False. - Find more information about compression to FP16 at https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_FP16_Compression.html + Find more information about compression to FP16 at https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_FP16_Compression.html [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /tmp/tmppkwl27u7/text-recognition-resnet-fc.xml [ SUCCESS ] BIN file: /tmp/tmppkwl27u7/text-recognition-resnet-fc.bin diff --git a/docs/notebooks/209-handwritten-ocr-with-output.rst b/docs/notebooks/209-handwritten-ocr-with-output.rst index 8aa26383d21..454802bf631 100644 --- a/docs/notebooks/209-handwritten-ocr-with-output.rst +++ b/docs/notebooks/209-handwritten-ocr-with-output.rst @@ -10,9 +10,9 @@ Latin alphabet is available in `notebook This model is capable of processing only one line of symbols at a time. The models used in this notebook are -`handwritten-japanese-recognition-0001 `__ +`handwritten-japanese-recognition-0001 `__ and -`handwritten-simplified-chinese-0001 `__. +`handwritten-simplified-chinese-0001 `__. To decode model outputs as readable text `kondate_nakayosi `__ and diff --git a/docs/notebooks/215-image-inpainting-with-output.rst b/docs/notebooks/215-image-inpainting-with-output.rst index f9ecfbafeeb..c431ee55da9 100644 --- a/docs/notebooks/215-image-inpainting-with-output.rst +++ b/docs/notebooks/215-image-inpainting-with-output.rst @@ -50,7 +50,7 @@ Download ``gmcnn-places2-tf``\ model (this step will be skipped if the model is unzip it. Downloaded model stored in TensorFlow frozen graph format. The steps how this frozen graph can be obtained from original model checkpoint can be found in this -`instruction `__ +`instruction `__ .. code:: ipython3 @@ -82,7 +82,7 @@ Convert Tensorflow model to OpenVINO IR format `⇑ <#top>`__ The pre-trained model is in TensorFlow format. To use it with OpenVINO, convert it to OpenVINO IR format with model conversion API. For more information about model conversion, see this -`page `__. +`page `__. This step is also skipped if the model is already converted. .. code:: ipython3 diff --git a/docs/notebooks/216-attention-center-with-output.rst b/docs/notebooks/216-attention-center-with-output.rst index 2a5dcfc7c8a..0e50d17ec85 100644 --- a/docs/notebooks/216-attention-center-with-output.rst +++ b/docs/notebooks/216-attention-center-with-output.rst @@ -124,7 +124,7 @@ format. In this Notebook the model will be converted to OpenVINO IR format with Model Optimizer. This step will be skipped if the model have already been converted. For more information about Model Optimizer, please, see the `Model Optimizer Developer -Guide `__. +Guide `__. Also TFLite models format is supported in OpenVINO by TFLite frontend, so the model can be passed directly to ``core.read_model()``. You can diff --git a/docs/notebooks/217-vision-deblur-with-output.rst b/docs/notebooks/217-vision-deblur-with-output.rst index 6e0f7067823..1241fab1900 100644 --- a/docs/notebooks/217-vision-deblur-with-output.rst +++ b/docs/notebooks/217-vision-deblur-with-output.rst @@ -30,7 +30,7 @@ DeblurGAN-v2 in OpenVINO, by first converting the `VITA-Group/DeblurGANv2 `__ model to OpenVINO Intermediate Representation (OpenVINO IR) format. For more information about the model, see the -`documentation `__. +`documentation `__. What is deblurring? `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -219,7 +219,7 @@ an OpenVINO model ready to load on a device and start making predictions. We can save it on a disk for next usage with ``openvino.runtime.serialize``. For more information about model conversion Python API, see this -`page `__. +`page `__. Model conversion may take a while. diff --git a/docs/notebooks/219-knowledge-graphs-conve-with-output.rst b/docs/notebooks/219-knowledge-graphs-conve-with-output.rst index 07fd9413bca..67c8776cff2 100644 --- a/docs/notebooks/219-knowledge-graphs-conve-with-output.rst +++ b/docs/notebooks/219-knowledge-graphs-conve-with-output.rst @@ -371,7 +371,7 @@ To evaluate performance with OpenVINO, we can either convert the trained PyTorch model to an intermediate representation (IR) format or to an ONNX representation. This notebook uses the ONNX format. For more details on model optimization, refer to: -https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html +https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html .. code:: ipython3 @@ -486,7 +486,7 @@ The OpenVINO toolkit provides a benchmarking application to gauge the platform specific runtime performance that can be obtained under optimal configuration parameters for a given model. For more details refer to: -https://docs.openvino.ai/2023.0/openvino_inference_engine_tools_benchmark_tool_README.html +https://docs.openvino.ai/2023.1/openvino_inference_engine_tools_benchmark_tool_README.html Here, we use the benchmark application to obtain performance estimates under optimal configuration for the knowledge graph model inference. We @@ -533,7 +533,7 @@ perform a sample evaluation on the knowledge graph. Then, we determine the platform specific speedup in runtime performance that can be obtained through OpenVINO graph optimizations. To learn more about the OpenVINO performance optimizations, refer to: -https://docs.openvino.ai/2023.0/openvino_docs_optimization_guide_dldt_optimization_guide.html +https://docs.openvino.ai/2023.1/openvino_docs_deployment_optimization_guide_dldt_optimization_guide.html References `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ diff --git a/docs/notebooks/220-cross-lingual-books-alignment-with-output.rst b/docs/notebooks/220-cross-lingual-books-alignment-with-output.rst index 88d0874160f..b007cc024a3 100644 --- a/docs/notebooks/220-cross-lingual-books-alignment-with-output.rst +++ b/docs/notebooks/220-cross-lingual-books-alignment-with-output.rst @@ -484,7 +484,7 @@ Optimize the Model with OpenVINO `⇑ <#top>`__ The LaBSE model is quite large and can be slow to infer on some hardware, so let’s optimize it with OpenVINO. `Model conversion Python -API `__ +API `__ accepts the PyTorch/Transformers model object and additional information about model inputs. An ``example_input`` is needed to trace the model execution graph, as PyTorch constructs it dynamically during inference. @@ -878,7 +878,7 @@ the pipeline - getting embeddings. You might wonder why, when using OpenVINO, you need to compile the model after reading it. There are two main reasons for this: 1. Compatibility with different devices. The model can be compiled to run on a `specific -device `__, +device `__, like CPU, GPU or GNA. Each device may work with different data types, support different features, and gain performance by changing the neural network for a specific computing model. With OpenVINO, you do not need @@ -887,13 +887,13 @@ hardware. A universal OpenVINO model representation is enough. 1. Optimization for different scenarios. For example, one scenario prioritizes minimizing the *time between starting and finishing model inference* (`latency-oriented -optimization `__). +optimization `__). In our case, it is more important *how many texts per second the model can process* (`throughput-oriented -optimization `__). +optimization `__). To get a throughput-optimized model, pass a `performance -hint `__ +hint `__ as a configuration during compilation. Then OpenVINO selects the optimal parameters for execution on the available hardware. @@ -912,7 +912,7 @@ parameters for execution on the available hardware. To further optimize hardware utilization, let’s change the inference mode from synchronous (Sync) to asynchronous (Async). While the synchronous API may be easier to start with, it is -`recommended `__ +`recommended `__ to use the asynchronous (callbacks-based) API in production code. It is the most general and scalable way to implement flow control for any number of requests. @@ -960,7 +960,7 @@ Let’s compare the models and plot the results. .. note:: To get a more accurate benchmark, use the `Benchmark Python - Tool `__ + Tool `__ .. code:: ipython3 @@ -1076,8 +1076,8 @@ boost. Here are useful links with information about the techniques used in this notebook: - `OpenVINO performance -hints `__ +hints `__ - `OpenVINO Async -API `__ +API `__ - `Throughput -Optimizations `__ +Optimizations `__ diff --git a/docs/notebooks/222-vision-image-colorization-with-output.rst b/docs/notebooks/222-vision-image-colorization-with-output.rst index 5d3d32c0655..8d11c9030fc 100644 --- a/docs/notebooks/222-vision-image-colorization-with-output.rst +++ b/docs/notebooks/222-vision-image-colorization-with-output.rst @@ -213,9 +213,9 @@ respectively Conversion command: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/python -- /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/mo --framework=onnx --output_dir=/tmp/tmp7wsuasz7 --model_name=colorization-v2 --input=data_l --output=color_ab --input_model=models/public/colorization-v2/colorization-v2-eccv16.onnx '--layout=data_l(NCHW)' '--input_shape=[1, 1, 256, 256]' --compress_to_fp16=True [ INFO ] Generated IR will be compressed to FP16. If you get lower accuracy, please consider disabling compression by removing argument --compress_to_fp16 or set it to false --compress_to_fp16=False. - Find more information about compression to FP16 at https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_FP16_Compression.html + Find more information about compression to FP16 at https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_FP16_Compression.html [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /tmp/tmp7wsuasz7/colorization-v2.xml [ SUCCESS ] BIN file: /tmp/tmp7wsuasz7/colorization-v2.bin diff --git a/docs/notebooks/223-text-prediction-with-output.rst b/docs/notebooks/223-text-prediction-with-output.rst index eeb9f79f0f2..97a7a1d8d85 100644 --- a/docs/notebooks/223-text-prediction-with-output.rst +++ b/docs/notebooks/223-text-prediction-with-output.rst @@ -192,7 +192,7 @@ While ONNX models are directly supported by OpenVINO runtime, it can be useful to convert them to IR format to take advantage of OpenVINO optimization tools and features. The ``mo.convert_model`` Python function of `model conversion -API `__ +API `__ can be used for converting the model. The function returns instance of OpenVINO Model class, which is ready to use in Python interface but can also be serialized to OpenVINO IR format for future execution using diff --git a/docs/notebooks/224-3D-segmentation-point-clouds-with-output.rst b/docs/notebooks/224-3D-segmentation-point-clouds-with-output.rst index 8934a54ec2e..8dcb6fa3b7f 100644 --- a/docs/notebooks/224-3D-segmentation-point-clouds-with-output.rst +++ b/docs/notebooks/224-3D-segmentation-point-clouds-with-output.rst @@ -79,7 +79,7 @@ function returns an OpenVINO model ready to load on a device and start making predictions. We can save it on a disk for next usage with ``openvino.runtime.serialize``. For more information about model conversion Python API, see this -`page `__. +`page `__. .. code:: ipython3 diff --git a/docs/notebooks/226-yolov7-optimization-with-output.rst b/docs/notebooks/226-yolov7-optimization-with-output.rst index 5867c26429a..e87f4de9564 100644 --- a/docs/notebooks/226-yolov7-optimization-with-output.rst +++ b/docs/notebooks/226-yolov7-optimization-with-output.rst @@ -911,7 +911,7 @@ Compare Performance of the Original and Quantized Models `⇑ <#top>`__ ############################################################################################################################### Finally, use the OpenVINO `Benchmark -Tool `__ +Tool `__ to measure the inference performance of the ``FP32`` and ``INT8`` models. diff --git a/docs/notebooks/229-distilbert-sequence-classification-with-output.rst b/docs/notebooks/229-distilbert-sequence-classification-with-output.rst index 018993b6f03..4095cec55bf 100644 --- a/docs/notebooks/229-distilbert-sequence-classification-with-output.rst +++ b/docs/notebooks/229-distilbert-sequence-classification-with-output.rst @@ -77,7 +77,7 @@ understand the context of a sentence. Here, we will use Convert Model to OpenVINO Intermediate Representation format. `⇑ <#top>`__ ############################################################################################################################### -`Model conversion API `__ +`Model conversion API `__ facilitates the transition between training and deployment environments, performs static model analysis, and adjusts deep learning models for optimal execution on end-point target devices. @@ -97,14 +97,14 @@ optimal execution on end-point target devices. mask, torch.tensor(torch.finfo(scores.dtype).min) -OpenVINO™ Runtime uses the `Infer Request `__ +OpenVINO™ Runtime uses the `Infer Request `__ mechanism which enables running models on different devices in asynchronous or synchronous manners. The model graph is sent as an argument to the OpenVINO API and an inference request is created. The default inference mode is AUTO but it can be changed according to requirements and hardware available. You can explore the different inference modes and their usage `in -documentation. `__ +documentation. `__ .. code:: ipython3 diff --git a/docs/notebooks/230-yolov8-optimization-with-output.rst b/docs/notebooks/230-yolov8-optimization-with-output.rst index f3083e063aa..e8a9f31bcd6 100644 --- a/docs/notebooks/230-yolov8-optimization-with-output.rst +++ b/docs/notebooks/230-yolov8-optimization-with-output.rst @@ -1199,7 +1199,7 @@ Compare Performance of the Original and Quantized Models `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Finally, use the OpenVINO `Benchmark -Tool `__ +Tool `__ to measure the inference performance of the ``FP32`` and ``INT8`` models. @@ -1680,8 +1680,7 @@ on a selected device (CPU/GPU etc.) rather than always being executed on CPU as part of an application. This will improve selected device utilization. -For more information, refer to the overview of `Preprocessing -API `__. +For more information, refer to the overview of :doc:`Preprocessing API ` . For example, we can integrate converting input data layout and normalization defined in ``image_to_tensor`` function. diff --git a/docs/notebooks/232-clip-language-saliency-map-with-output.rst b/docs/notebooks/232-clip-language-saliency-map-with-output.rst index e211581e457..c7bd680d282 100644 --- a/docs/notebooks/232-clip-language-saliency-map-with-output.rst +++ b/docs/notebooks/232-clip-language-saliency-map-with-output.rst @@ -410,7 +410,7 @@ text encoder. You can split the CLIP into two models and call them separately. To convert the model to IR, you can use `Model Optimizer -(MO) `__. +(MO) `__. When you convert a model to the OpenVINO format, Model Optimizer enables specifying the inputs and outputs you want to use. During the conversion, it will trim the remaining parts of the model. Therefore, diff --git a/docs/notebooks/235-controlnet-stable-diffusion-with-output.rst b/docs/notebooks/235-controlnet-stable-diffusion-with-output.rst index 3ab1065358f..471e72ca3d0 100644 --- a/docs/notebooks/235-controlnet-stable-diffusion-with-output.rst +++ b/docs/notebooks/235-controlnet-stable-diffusion-with-output.rst @@ -329,7 +329,7 @@ example, input and output names or dynamic shapes). While ONNX models are directly supported by OpenVINO™ runtime, it can be useful to convert them to IR format to take the advantage of advanced OpenVINO optimization tools and features. We will use `model conversion -API `__ +API `__ to convert a model to IR format and compression weights to ``FP16`` format. diff --git a/docs/notebooks/236-stable-diffusion-v2-infinite-zoom-with-output.rst b/docs/notebooks/236-stable-diffusion-v2-infinite-zoom-with-output.rst index 4a1e447144f..75656ed47aa 100644 --- a/docs/notebooks/236-stable-diffusion-v2-infinite-zoom-with-output.rst +++ b/docs/notebooks/236-stable-diffusion-v2-infinite-zoom-with-output.rst @@ -470,7 +470,7 @@ generated latents channels + 4 for latent representation of masked image Text Encoder successfully converted to ONNX [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/text_encoder.xml [ SUCCESS ] BIN file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/text_encoder.bin @@ -515,7 +515,7 @@ generated latents channels + 4 for latent representation of masked image U-Net successfully converted to ONNX [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/unet.xml [ SUCCESS ] BIN file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/unet.bin @@ -561,7 +561,7 @@ generated latents channels + 4 for latent representation of masked image VAE encoder successfully converted to ONNX [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/vae_encoder.xml [ SUCCESS ] BIN file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/vae_encoder.bin @@ -582,7 +582,7 @@ generated latents channels + 4 for latent representation of masked image VAE decoder successfully converted to ONNX [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/vae_decoder.xml [ SUCCESS ] BIN file: /home/ea/work/openvino_notebooks/notebooks/236-stable-diffusion-v2/sd2_inpainting/vae_decoder.bin diff --git a/docs/notebooks/236-stable-diffusion-v2-optimum-demo-with-output.rst b/docs/notebooks/236-stable-diffusion-v2-optimum-demo-with-output.rst index f44eda207c3..bfa6ef6dce9 100644 --- a/docs/notebooks/236-stable-diffusion-v2-optimum-demo-with-output.rst +++ b/docs/notebooks/236-stable-diffusion-v2-optimum-demo-with-output.rst @@ -55,7 +55,7 @@ in this notebook is `helenai/stabilityai-stable-diffusion-2-1-base-ov `__. Let’s download the pre-converted model Stable Diffusion 2.1 `Intermediate Representation Format -(IR) `__ +(IR) `__ Showing Info Available Devices `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ diff --git a/docs/notebooks/236-stable-diffusion-v2-text-to-image-with-output.rst b/docs/notebooks/236-stable-diffusion-v2-text-to-image-with-output.rst index f8cb417e3cf..33a4df82bfd 100644 --- a/docs/notebooks/236-stable-diffusion-v2-text-to-image-with-output.rst +++ b/docs/notebooks/236-stable-diffusion-v2-text-to-image-with-output.rst @@ -185,7 +185,7 @@ example, input and output names or dynamic shapes). While ONNX models are directly supported by OpenVINO™ runtime, it can be useful to convert them to IR format to take the advantage of advanced OpenVINO optimization tools and features. We will use OpenVINO `Model -Optimizer `__ +Optimizer `__ to convert a model to IR format. The pipeline consists of three important parts: diff --git a/docs/notebooks/237-segment-anything-with-output.rst b/docs/notebooks/237-segment-anything-with-output.rst index 25969d47260..2db34401ec9 100644 --- a/docs/notebooks/237-segment-anything-with-output.rst +++ b/docs/notebooks/237-segment-anything-with-output.rst @@ -1962,7 +1962,7 @@ Compare Performance of the Original and Quantized Models `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Finally, use the OpenVINO `Benchmark -Tool `__ +Tool `__ to measure the inference performance of the ``FP32`` and ``INT8`` models. diff --git a/docs/notebooks/238-deep-floyd-if-with-output.rst b/docs/notebooks/238-deep-floyd-if-with-output.rst index 5701933a9ef..4f46b3c9ead 100644 --- a/docs/notebooks/238-deep-floyd-if-with-output.rst +++ b/docs/notebooks/238-deep-floyd-if-with-output.rst @@ -313,7 +313,7 @@ shape, type, and value within a single argument, providing greater flexibility. To learn more, refer to this -`page `__ +`page `__ .. code:: ipython3 diff --git a/docs/notebooks/239-image-bind-convert-with-output.rst b/docs/notebooks/239-image-bind-convert-with-output.rst index ffd69a13191..a9354866a28 100644 --- a/docs/notebooks/239-image-bind-convert-with-output.rst +++ b/docs/notebooks/239-image-bind-convert-with-output.rst @@ -237,7 +237,7 @@ While ONNX models are directly supported by OpenVINO™ runtime, it can be useful to convert them to IR format to take advantage of advanced OpenVINO optimization tools and features. You will use `model conversion Python -API `__ +API `__ to convert model to IR format and compress weights to ``FP16`` format. The ``mo.convert_model`` function returns OpenVINO Model class instance ready to load on a device or save on a disk for next loading. diff --git a/docs/notebooks/242-freevc-voice-conversion-with-output.rst b/docs/notebooks/242-freevc-voice-conversion-with-output.rst index 1c39257b4a7..0a372bf31c8 100644 --- a/docs/notebooks/242-freevc-voice-conversion-with-output.rst +++ b/docs/notebooks/242-freevc-voice-conversion-with-output.rst @@ -288,7 +288,7 @@ model. The obtained model is ready to use and to be loaded on a device using ``compile_model`` or can be saved on a disk using the ``serialize`` function. The ``read_model`` method loads a saved model from a disk. For more information about model conversion, see this -`page `__. +`page `__. Convert Prior Encoder. `⇑ <#top>`__ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ diff --git a/docs/notebooks/243-tflite-selfie-segmentation-with-output.rst b/docs/notebooks/243-tflite-selfie-segmentation-with-output.rst index c709cd516e9..f989c47a6e0 100644 --- a/docs/notebooks/243-tflite-selfie-segmentation-with-output.rst +++ b/docs/notebooks/243-tflite-selfie-segmentation-with-output.rst @@ -135,9 +135,9 @@ next running. Optionally, we can apply compression to the FP16 model weights, using the ``compress_to_fp16=True`` option and integrate preprocessing, using this approach. For more information about model conversion, see this -`page `__. +`page `__. For TensorFlow Lite, refer to the `models -support `__. +support `__. .. code:: ipython3 diff --git a/docs/notebooks/245-typo-detector-with-output.rst b/docs/notebooks/245-typo-detector-with-output.rst index b5e609416e8..a9248929307 100644 --- a/docs/notebooks/245-typo-detector-with-output.rst +++ b/docs/notebooks/245-typo-detector-with-output.rst @@ -77,9 +77,9 @@ hardware. First the Pytorch model is converted to the ONNX format and then the `Model -Optimizer `__ +Optimizer `__ tool will be used to convert to `OpenVINO IR -format `__. This +format `__. This method provides much more insight to how to set up a pipeline from model loading to model converting, compiling and running inference with OpenVINO, so that you could conveniently use OpenVINO to optimize and @@ -379,14 +379,14 @@ Model Optimizer ''''''''''''''' `Model -Optimizer `__ +Optimizer `__ is a cross-platform command-line tool that facilitates the transition between training and deployment environments, performs static model analysis, and adjusts deep learning models for optimal execution on end-point target devices. Model Optimizer converts the model to the OpenVINO Intermediate Representation format (IR), which you can infer later with `OpenVINO -runtime `__. +runtime `__. .. code:: ipython3 @@ -399,7 +399,7 @@ Inference OpenVINO™ Runtime Python API is used to compile the model in OpenVINO IR format. The -`Core `__ +`Core `__ class from the ``openvino.runtime`` module is imported first. This class provides access to the OpenVINO Runtime API. The ``core`` object, which is an instance of the ``Core`` class, represents the API and it is used diff --git a/docs/notebooks/246-depth-estimation-videpth-with-output.rst b/docs/notebooks/246-depth-estimation-videpth-with-output.rst index eb91c99950a..98c52ee17fe 100644 --- a/docs/notebooks/246-depth-estimation-videpth-with-output.rst +++ b/docs/notebooks/246-depth-estimation-videpth-with-output.rst @@ -64,7 +64,7 @@ repository `__ for the pre-processing, model transformations and basic utility code. A part of it has already been kept as it is in the `utils `__ directory. At the same time we will learn how to perform `model -conversion `__ +conversion `__ for converting a model in a different format to the standard OpenVINO™ IR model representation *via* another format. @@ -312,7 +312,7 @@ Dummy input creation ^^^^^^^^^^^^^^^^^^^^ Dummy inputs are necessary for `PyTorch to -ONNX `__ +ONNX `__ conversion. Although `torch.onnx.export `__ accepts any dummy input for a single pass through the model and thereby diff --git a/docs/notebooks/247-code-language-id-with-output.rst b/docs/notebooks/247-code-language-id-with-output.rst index 778ddf7e6e1..2d0c9d3019b 100644 --- a/docs/notebooks/247-code-language-id-with-output.rst +++ b/docs/notebooks/247-code-language-id-with-output.rst @@ -7,7 +7,7 @@ Overview This tutorial will be divided in 2 parts: 1. Create a simple inference pipeline with a pre-trained model using the OpenVINO™ IR format. -2. Conduct `post-training quantization `__ +2. Conduct `post-training quantization `__ on a pre-trained model using Hugging Face Optimum and benchmark performance. Feel free to use the notebook outline in Jupyter or your IDE for easy @@ -257,7 +257,7 @@ Part 2: OpenVINO post-training quantization with HuggingFace Optimum In this section, we will quantize a trained model. At a high-level, this process consists of using lower precision numbers in the model, which results in a smaller model size and faster inference at the cost of a -potential marginal performance degradation. `Learn more `__. +potential marginal performance degradation. `Learn more `__. The HuggingFace Optimum library supports post-training quantization for OpenVINO. `Learn more `__. diff --git a/docs/notebooks/250-music-generation-with-output.rst b/docs/notebooks/250-music-generation-with-output.rst index 733e303c35f..564fe33f99f 100644 --- a/docs/notebooks/250-music-generation-with-output.rst +++ b/docs/notebooks/250-music-generation-with-output.rst @@ -206,7 +206,7 @@ a time and this vector will just consist of ones. We use OpenVINO Converter (OVC) below to convert the PyTorch model to the OpenVINO Intermediate Representation format (IR), which you can infer later with `OpenVINO -runtime `__ +runtime `__ .. code:: ipython3 @@ -364,7 +364,7 @@ Embedding the converted models into the original pipeline `⇑ <#top>`__ OpenVINO™ Runtime Python API is used to compile the model in OpenVINO IR format. The -`Core `__ +`Core `__ class provides access to the OpenVINO Runtime API. The ``core`` object, which is an instance of the ``Core`` class represents the API and it is used to compile the model. diff --git a/docs/notebooks/301-tensorflow-training-openvino-nncf-with-output.rst b/docs/notebooks/301-tensorflow-training-openvino-nncf-with-output.rst index 6054fb8ae8c..bce43dba739 100644 --- a/docs/notebooks/301-tensorflow-training-openvino-nncf-with-output.rst +++ b/docs/notebooks/301-tensorflow-training-openvino-nncf-with-output.rst @@ -399,11 +399,11 @@ Download Intermediate Representation (IR) model. ir_model = ie.read_model(model_xml) Use `Basic Quantization -Flow `__. +Flow `__. 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 `__. +control `__. .. code:: ipython3 @@ -584,7 +584,7 @@ Compare Inference Speed ----------------------- Measure inference speed with the `OpenVINO Benchmark -App `__. +App `__. Benchmark App is a command line tool that measures raw inference performance for a specified OpenVINO IR model. Run @@ -594,7 +594,7 @@ 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 `__ +`documentation `__ for more information. This tutorial uses a wrapper function from `Notebook @@ -875,7 +875,7 @@ cached to the ``model_cache`` directory. 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 `__. +Plugin `__. 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. diff --git a/docs/notebooks/301-tensorflow-training-openvino-with-output.rst b/docs/notebooks/301-tensorflow-training-openvino-with-output.rst index 0b02ba0ee4f..6bb74ee2b89 100644 --- a/docs/notebooks/301-tensorflow-training-openvino-with-output.rst +++ b/docs/notebooks/301-tensorflow-training-openvino-with-output.rst @@ -924,7 +924,7 @@ Convert the TensorFlow model with OpenVINO Model Optimizer `⇑ <#top>`__ To convert the model to OpenVINO IR with ``FP16`` precision, use model conversion Python API. For more information, see this -`page `__. +`page `__. .. code:: ipython3 diff --git a/docs/notebooks/302-pytorch-quantization-aware-training-with-output.rst b/docs/notebooks/302-pytorch-quantization-aware-training-with-output.rst index 3cc99a837ea..0448bcbd2c1 100644 --- a/docs/notebooks/302-pytorch-quantization-aware-training-with-output.rst +++ b/docs/notebooks/302-pytorch-quantization-aware-training-with-output.rst @@ -703,7 +703,7 @@ scale the input with the standard deviation by the ``mean_values`` and before propagating it through the network with these options. For more information about model conversion, see this -`page `__. +`page `__. .. code:: ipython3 @@ -733,7 +733,7 @@ Benchmark Model Performance by Computing Inference Time `⇑ <#top>`__ Finally, measure the inference performance of the ``FP32`` and ``INT8`` models, using `Benchmark -Tool `__ +Tool `__ - inference performance measurement tool in OpenVINO. By default, Benchmark Tool runs inference for 60 seconds in asynchronous mode on CPU. It returns inference speed as latency (milliseconds per image) and diff --git a/docs/notebooks/305-tensorflow-quantization-aware-training-with-output.rst b/docs/notebooks/305-tensorflow-quantization-aware-training-with-output.rst index 8f0ad9a7f72..7d6e7934675 100644 --- a/docs/notebooks/305-tensorflow-quantization-aware-training-with-output.rst +++ b/docs/notebooks/305-tensorflow-quantization-aware-training-with-output.rst @@ -431,7 +431,7 @@ Export Models to OpenVINO Intermediate Representation (IR) `⇑ <#top>`__ Use model conversion Python API to convert the models to OpenVINO IR. For more information about model conversion, see this -`page `__. +`page `__. Executing this command may take a while. @@ -473,7 +473,7 @@ Benchmark Model Performance by Computing Inference Time `⇑ <#top>`__ Finally, measure the inference performance of the ``FP32`` and ``INT8`` models, using `Benchmark -Tool `__ +Tool `__ - an inference performance measurement tool in OpenVINO. By default, Benchmark Tool runs inference for 60 seconds in asynchronous mode on CPU. It returns inference speed as latency (milliseconds per image) and diff --git a/docs/notebooks/401-object-detection-with-output.rst b/docs/notebooks/401-object-detection-with-output.rst index 45ee50e220e..da6f2e47f99 100644 --- a/docs/notebooks/401-object-detection-with-output.rst +++ b/docs/notebooks/401-object-detection-with-output.rst @@ -156,7 +156,7 @@ Convert the Model `⇑ <#top>`__ The pre-trained model is in TensorFlow format. To use it with OpenVINO, convert it to OpenVINO IR format, using `model conversion Python -API `__ +API `__ (``mo.convert_model`` function). If the model has been already converted, this step is skipped. diff --git a/docs/notebooks/406-3D-pose-estimation-with-output.rst b/docs/notebooks/406-3D-pose-estimation-with-output.rst index 121a5d44326..4cef53e5c7f 100644 --- a/docs/notebooks/406-3D-pose-estimation-with-output.rst +++ b/docs/notebooks/406-3D-pose-estimation-with-output.rst @@ -212,7 +212,7 @@ format. Conversion command: /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/python -- /opt/home/k8sworker/ci-ai/cibuilds/ov-notebook/OVNotebookOps-475/.workspace/scm/ov-notebook/.venv/bin/mo --framework=onnx --output_dir=/tmp/tmpgwxi10io --model_name=human-pose-estimation-3d-0001 --input=data '--mean_values=data[128.0,128.0,128.0]' '--scale_values=data[255.0,255.0,255.0]' --output=features,heatmaps,pafs --input_model=model/public/human-pose-estimation-3d-0001/human-pose-estimation-3d-0001.onnx '--layout=data(NCHW)' '--input_shape=[1, 3, 256, 448]' --compress_to_fp16=False [ INFO ] The model was converted to IR v11, the latest model format that corresponds to the source DL framework input/output format. While IR v11 is backwards compatible with OpenVINO Inference Engine API v1.0, please use API v2.0 (as of 2022.1) to take advantage of the latest improvements in IR v11. - Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html + Find more information about API v2.0 and IR v11 at https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html [ SUCCESS ] Generated IR version 11 model. [ SUCCESS ] XML file: /tmp/tmpgwxi10io/human-pose-estimation-3d-0001.xml [ SUCCESS ] BIN file: /tmp/tmpgwxi10io/human-pose-estimation-3d-0001.bin diff --git a/docs/notebooks/407-person-tracking-with-output.rst b/docs/notebooks/407-person-tracking-with-output.rst index b267e6bd9ec..9e11051c3f4 100644 --- a/docs/notebooks/407-person-tracking-with-output.rst +++ b/docs/notebooks/407-person-tracking-with-output.rst @@ -184,15 +184,15 @@ Representation (OpenVINO IR). Using a model outside the list can require different pre- and post-processing. -In this case, `person detection model `__ +In this case, `person detection model `__ is deployed to detect the person in each frame of the video, and -`reidentification model `__ +`reidentification model `__ is used to output embedding vector to match a pair of images of a person by the cosine distance. If you want to download another model (``person-detection-xxx`` from -`Object Detection Models list `__, -``person-reidentification-retail-xxx`` from `Reidentification Models list `__), +`Object Detection Models list `__, +``person-reidentification-retail-xxx`` from `Reidentification Models list `__), replace the name of the model in the code below. .. code:: ipython3 diff --git a/docs/optimization_guide/dldt_deployment_optimization_common.md b/docs/optimization_guide/dldt_deployment_optimization_common.md index b4ad86fb593..347c8417f1c 100644 --- a/docs/optimization_guide/dldt_deployment_optimization_common.md +++ b/docs/optimization_guide/dldt_deployment_optimization_common.md @@ -60,7 +60,7 @@ Below are example-codes for the regular and async-based approaches to compare: The technique can be generalized to any available parallel slack. For example, you can do inference and simultaneously encode the resulting or previous frames or run further inference, like emotion detection on top of the face detection results. -Refer to the `Object Detection C++ Demo `__ , `Object Detection Python Demo `__ (latency-oriented Async API showcase) and :doc:`Benchmark App Sample ` for complete examples of the Async API in action. +Refer to the `Object Detection C++ Demo `__ , `Object Detection Python Demo `__ (latency-oriented Async API showcase) and :doc:`Benchmark App Sample ` for complete examples of the Async API in action. .. note:: diff --git a/docs/resources/prerelease_information.md b/docs/resources/prerelease_information.md index c8a90cc5815..42f85cb6e6d 100644 --- a/docs/resources/prerelease_information.md +++ b/docs/resources/prerelease_information.md @@ -79,7 +79,7 @@ Please file a github Issue on these with the label “pre-release” so we can g * PyTorch FE: * Added support for 6 new operations. To know how to enjoy PyTorch models conversion follow - this `Link `__ + this `Link `__ * aten::concat * aten::masked_scatter diff --git a/samples/c/hello_nv12_input_classification/README.md b/samples/c/hello_nv12_input_classification/README.md index 9bd811e7143..0056c897448 100644 --- a/samples/c/hello_nv12_input_classification/README.md +++ b/samples/c/hello_nv12_input_classification/README.md @@ -140,7 +140,7 @@ See Also - :doc:`Using OpenVINO™ Samples ` - :doc:`Model Downloader ` - :doc:`Convert a Model ` -- `C API Reference `__ +- `C API Reference `__ @endsphinxdirective diff --git a/samples/python/classification_sample_async/README.md b/samples/python/classification_sample_async/README.md index 57d26c9e682..274b05e04e6 100644 --- a/samples/python/classification_sample_async/README.md +++ b/samples/python/classification_sample_async/README.md @@ -34,11 +34,11 @@ Models with only 1 input and output are supported. +--------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------+ | Feature | API | Description | +====================+===========================================================================================================================================================================================================+===========================+ - | Asynchronous Infer | `openvino.runtime.AsyncInferQueue `__ , | Do asynchronous inference | - | | `openvino.runtime.AsyncInferQueue.set_callback `__ , | | - | | `openvino.runtime.AsyncInferQueue.start_async `__ , | | - | | `openvino.runtime.AsyncInferQueue.wait_all `__ , | | - | | `openvino.runtime.InferRequest.results `__ | | + | Asynchronous Infer | `openvino.runtime.AsyncInferQueue `__ , | Do asynchronous inference | + | | `openvino.runtime.AsyncInferQueue.set_callback `__ , | | + | | `openvino.runtime.AsyncInferQueue.start_async `__ , | | + | | `openvino.runtime.AsyncInferQueue.wait_all `__ , | | + | | `openvino.runtime.InferRequest.results `__ | | +--------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------------------------+ Basic OpenVINO™ Runtime API is covered by :doc:`Hello Classification Python Sample `. diff --git a/samples/python/hello_classification/README.md b/samples/python/hello_classification/README.md index 1001948656d..8e97151fb54 100644 --- a/samples/python/hello_classification/README.md +++ b/samples/python/hello_classification/README.md @@ -34,23 +34,23 @@ Models with only 1 input and output are supported. +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Feature | API | Description | +=============================+===========================================================================================================================================================================================================================================+============================================================================================================================================================================================+ - | Basic Infer Flow | `openvino.runtime.Core `__ , | | - | | `openvino.runtime.Core.read_model `__ , | | - | | `openvino.runtime.Core.compile_model `__ | Common API to do inference | + | Basic Infer Flow | `openvino.runtime.Core `__ , | | + | | `openvino.runtime.Core.read_model `__ , | | + | | `openvino.runtime.Core.compile_model `__ | Common API to do inference | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ - | Synchronous Infer | `openvino.runtime.CompiledModel.infer_new_request `__ | Do synchronous inference | + | Synchronous Infer | `openvino.runtime.CompiledModel.infer_new_request `__ | Do synchronous inference | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ - | Model Operations | `openvino.runtime.Model.inputs `__ , | Managing of model | - | | `openvino.runtime.Model.outputs `__ | | + | Model Operations | `openvino.runtime.Model.inputs `__ , | Managing of model | + | | `openvino.runtime.Model.outputs `__ | | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ - | Preprocessing | `openvino.preprocess.PrePostProcessor `__ , | Set image of the original size as input for a model with other input size. Resize and layout conversions will be performed automatically by the corresponding plugin just before inference | - | | `openvino.preprocess.InputTensorInfo.set_element_type `__ , | | - | | `openvino.preprocess.InputTensorInfo.set_layout `__ , | | - | | `openvino.preprocess.InputTensorInfo.set_spatial_static_shape `__ , | | - | | `openvino.preprocess.PreProcessSteps.resize `__ , | | - | | `openvino.preprocess.InputModelInfo.set_layout `__ , | | - | | `openvino.preprocess.OutputTensorInfo.set_element_type `__ , | | - | | `openvino.preprocess.PrePostProcessor.build `__ | | + | Preprocessing | `openvino.preprocess.PrePostProcessor `__ , | Set image of the original size as input for a model with other input size. Resize and layout conversions will be performed automatically by the corresponding plugin just before inference | + | | `openvino.preprocess.InputTensorInfo.set_element_type `__ , | | + | | `openvino.preprocess.InputTensorInfo.set_layout `__ , | | + | | `openvino.preprocess.InputTensorInfo.set_spatial_static_shape `__ , | | + | | `openvino.preprocess.PreProcessSteps.resize `__ , | | + | | `openvino.preprocess.InputModelInfo.set_layout `__ , | | + | | `openvino.preprocess.OutputTensorInfo.set_element_type `__ , | | + | | `openvino.preprocess.PrePostProcessor.build `__ | | +-----------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. tab-item:: Sample Code diff --git a/samples/python/hello_query_device/README.md b/samples/python/hello_query_device/README.md index 0745bcd646a..a43ec4bf01f 100644 --- a/samples/python/hello_query_device/README.md +++ b/samples/python/hello_query_device/README.md @@ -29,11 +29,11 @@ This sample demonstrates how to show OpenVINO™ Runtime devices and prints thei +---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------+ | Feature | API | Description | +=======================================+============================================================================================================================================================================================+========================================+ - | Basic | `openvino.runtime.Core `__ | Common API | + | Basic | `openvino.runtime.Core `__ | Common API | +---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------+ - | Query Device | `openvino.runtime.Core.available_devices `__ , | Get device properties | - | | `openvino.runtime.Core.get_metric `__ , | | - | | `openvino.runtime.Core.get_config `__ | | + | Query Device | `openvino.runtime.Core.available_devices `__ , | Get device properties | + | | `openvino.runtime.Core.get_metric `__ , | | + | | `openvino.runtime.Core.get_config `__ | | +---------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------+ .. tab-item:: Sample Code diff --git a/samples/python/hello_reshape_ssd/README.md b/samples/python/hello_reshape_ssd/README.md index 0b5587f51af..90deed2c269 100644 --- a/samples/python/hello_reshape_ssd/README.md +++ b/samples/python/hello_reshape_ssd/README.md @@ -37,10 +37,10 @@ Models with only 1 input and output are supported. +------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------+ | Feature | API | Description | +====================================+================================================================================================================================================================================+======================================+ - | Model Operations | `openvino.runtime.Model.reshape `__ , | Managing of model | - | | `openvino.runtime.Model.input `__ , | | - | | `openvino.runtime.Output.get_any_name `__ , | | - | | `openvino.runtime.PartialShape `__ | | + | Model Operations | `openvino.runtime.Model.reshape `__ , | Managing of model | + | | `openvino.runtime.Model.input `__ , | | + | | `openvino.runtime.Output.get_any_name `__ , | | + | | `openvino.runtime.PartialShape `__ | | +------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------+ Basic OpenVINO™ Runtime API is covered by :doc:`Hello Classification Python* Sample `. diff --git a/samples/python/model_creation_sample/README.md b/samples/python/model_creation_sample/README.md index 72de5335247..bd2aa44b12e 100644 --- a/samples/python/model_creation_sample/README.md +++ b/samples/python/model_creation_sample/README.md @@ -33,19 +33,19 @@ This sample demonstrates how to run inference using a :doc:`model `__ , | Managing of model | - | | `openvino.runtime.set_batch `__ , | | - | | `openvino.runtime.Model.input `__ | | + | Model Operations | `openvino.runtime.Model `__ , | Managing of model | + | | `openvino.runtime.set_batch `__ , | | + | | `openvino.runtime.Model.input `__ | | +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+ - | Opset operations | `openvino.runtime.op.Parameter `__ , | Description of a model topology using OpenVINO Python API | - | | `openvino.runtime.op.Constant `__ , | | - | | `openvino.runtime.opset8.convolution `__ , | | - | | `openvino.runtime.opset8.add `__ , | | - | | `openvino.runtime.opset1.max_pool `__ , | | - | | `openvino.runtime.opset8.reshape `__ , | | - | | `openvino.runtime.opset8.matmul `__ , | | - | | `openvino.runtime.opset8.relu `__ , | | - | | `openvino.runtime.opset8.softmax `__ | | + | Opset operations | `openvino.runtime.op.Parameter `__ , | Description of a model topology using OpenVINO Python API | + | | `openvino.runtime.op.Constant `__ , | | + | | `openvino.runtime.opset8.convolution `__ , | | + | | `openvino.runtime.opset8.add `__ , | | + | | `openvino.runtime.opset1.max_pool `__ , | | + | | `openvino.runtime.opset8.reshape `__ , | | + | | `openvino.runtime.opset8.matmul `__ , | | + | | `openvino.runtime.opset8.relu `__ , | | + | | `openvino.runtime.opset8.softmax `__ | | +------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------+ Basic OpenVINO™ Runtime API is covered by :doc:`Hello Classification Python* Sample `. diff --git a/samples/python/speech_sample/README.md b/samples/python/speech_sample/README.md index 55408247fc3..6ededaabaa7 100644 --- a/samples/python/speech_sample/README.md +++ b/samples/python/speech_sample/README.md @@ -45,17 +45,17 @@ The sample works with Kaldi ARK or Numpy* uncompressed NPZ files, so it does not +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ | Feature | API | Description | +===================================================================+================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================+=======================================================================+ - | Import/Export Model | `openvino.runtime.Core.import_model `__ , `openvino.runtime.CompiledModel.export_model `__ | The GNA plugin supports loading and saving of the GNA-optimized model | + | Import/Export Model | `openvino.runtime.Core.import_model `__ , `openvino.runtime.CompiledModel.export_model `__ | The GNA plugin supports loading and saving of the GNA-optimized model | +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ - | Model Operations | `openvino.runtime.Model.add_outputs `__ , `openvino.runtime.set_batch `__ , `openvino.runtime.CompiledModel.inputs `__ , `openvino.runtime.CompiledModel.outputs `__ , `openvino.runtime.ConstOutput.any_name `__ | Managing of model: configure batch_size, input and output tensors | + | Model Operations | `openvino.runtime.Model.add_outputs `__ , `openvino.runtime.set_batch `__ , `openvino.runtime.CompiledModel.inputs `__ , `openvino.runtime.CompiledModel.outputs `__ , `openvino.runtime.ConstOutput.any_name `__ | Managing of model: configure batch_size, input and output tensors | +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ - | Synchronous Infer | `openvino.runtime.CompiledModel.create_infer_request `__ , `openvino.runtime.InferRequest.infer `__ | Do synchronous inference | + | Synchronous Infer | `openvino.runtime.CompiledModel.create_infer_request `__ , `openvino.runtime.InferRequest.infer `__ | Do synchronous inference | +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ - | InferRequest Operations | `openvino.runtime.InferRequest.get_input_tensor `__ , `openvino.runtime.InferRequest.model_outputs `__ , `openvino.runtime.InferRequest.model_inputs `__ , | Get info about model using infer request API | + | InferRequest Operations | `openvino.runtime.InferRequest.get_input_tensor `__ , `openvino.runtime.InferRequest.model_outputs `__ , `openvino.runtime.InferRequest.model_inputs `__ , | Get info about model using infer request API | +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ - | InferRequest Operations | `openvino.runtime.InferRequest.query_state `__ , `openvino.runtime.VariableState.reset `__ | Gets and resets CompiledModel state control | + | InferRequest Operations | `openvino.runtime.InferRequest.query_state `__ , `openvino.runtime.VariableState.reset `__ | Gets and resets CompiledModel state control | +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ - | Profiling | `openvino.runtime.InferRequest.profiling_info `__ , `openvino.runtime.ProfilingInfo.real_time `__ | Get infer request profiling info | + | Profiling | `openvino.runtime.InferRequest.profiling_info `__ , `openvino.runtime.ProfilingInfo.real_time `__ | Get infer request profiling info | +-------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------+ Basic OpenVINO™ Runtime API is covered by :doc:`Hello Classification Python* Sample `. diff --git a/src/README.md b/src/README.md index 380d24fe719..7d3d028bd00 100644 --- a/src/README.md +++ b/src/README.md @@ -59,7 +59,7 @@ OpenVINO provides bindings for different languages. To get the full list of supp ## Core developer topics * [OpenVINO architecture](./docs/architecture.md) - * [Plugin Development](https://docs.openvino.ai/2023.0/openvino_docs_ie_plugin_dg_overview.html) + * [Plugin Development](https://docs.openvino.ai/2023.1/openvino_docs_ie_plugin_dg_overview.html) * [Thread safety](#todo) * [Performance](#todo) diff --git a/src/bindings/c/README.md b/src/bindings/c/README.md index 225c976d49c..1367c2b8b28 100644 --- a/src/bindings/c/README.md +++ b/src/bindings/c/README.md @@ -25,7 +25,7 @@ People from the [openvino-c-api-maintainers](https://github.com/orgs/openvinotoo OpenVINO C API has the following structure: * [docs](./docs) contains developer documentation for OpenVINO C APIs. - * [include](./include) contains all provided C API headers. [Learn more](https://docs.openvino.ai/2023.0/api/api_reference.html). + * [include](./include) contains all provided C API headers. [Learn more](https://docs.openvino.ai/2023.1/api/api_reference.html). * [src](./src) contains the implementations of all C APIs. * [tests](./tests) contains all tests for OpenVINO C APIs. [Learn more](./docs/how_to_write_unit_test.md). @@ -33,7 +33,7 @@ OpenVINO C API has the following structure: ## Tutorials -* [How to integrate OpenVINO C API with Your Application](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_Integrate_OV_with_your_application.html) +* [How to integrate OpenVINO C API with Your Application](https://docs.openvino.ai/2023.1/openvino_docs_OV_UG_Integrate_OV_with_your_application.html) * [How to wrap OpenVINO objects with C](./docs/how_to_wrap_openvino_objects_with_c.md) * [How to wrap OpenVINO interfaces with C](./docs/how_to_wrap_openvino_interfaces_with_c.md) * [Samples implemented by OpenVINO C API](../../../samples/c/) @@ -47,5 +47,5 @@ See [CONTRIBUTING](../../../CONTRIBUTING.md) for details. ## See also * [OpenVINO™ README](../../../README.md) - * [OpenVINO Runtime C API User Guide](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_Integrate_OV_with_your_application.html) - * [Migration of OpenVINO C API](https://docs.openvino.ai/2023.0/openvino_2_0_transition_guide.html) + * [OpenVINO Runtime C API User Guide](https://docs.openvino.ai/2023.1/openvino_docs_OV_UG_Integrate_OV_with_your_application.html) + * [Migration of OpenVINO C API](https://docs.openvino.ai/2023.1/openvino_2_0_transition_guide.html) diff --git a/src/bindings/c/docs/how_to_wrap_openvino_interfaces_with_c.md b/src/bindings/c/docs/how_to_wrap_openvino_interfaces_with_c.md index 435e2e35529..8508e3e87ce 100644 --- a/src/bindings/c/docs/how_to_wrap_openvino_interfaces_with_c.md +++ b/src/bindings/c/docs/how_to_wrap_openvino_interfaces_with_c.md @@ -78,4 +78,4 @@ The tensor create needs to specify the shape info, so C shape need to be convert ## See also * [OpenVINO™ README](../../../../README.md) * [C API developer guide](../README.md) - * [C API Reference](https://docs.openvino.ai/2023.0/api/api_reference.html) + * [C API Reference](https://docs.openvino.ai/2023.1/api/api_reference.html) diff --git a/src/bindings/c/docs/how_to_wrap_openvino_objects_with_c.md b/src/bindings/c/docs/how_to_wrap_openvino_objects_with_c.md index 092f37138ac..a6c9982ca47 100644 --- a/src/bindings/c/docs/how_to_wrap_openvino_objects_with_c.md +++ b/src/bindings/c/docs/how_to_wrap_openvino_objects_with_c.md @@ -73,4 +73,4 @@ https://github.com/openvinotoolkit/openvino/blob/d96c25844d6cfd5ad131539c8a09282 ## See also * [OpenVINO™ README](../../../../README.md) * [C API developer guide](../README.md) - * [C API Reference](https://docs.openvino.ai/2023.0/api/api_reference.html) \ No newline at end of file + * [C API Reference](https://docs.openvino.ai/2023.1/api/api_reference.html) \ No newline at end of file diff --git a/src/bindings/c/docs/how_to_write_unit_test.md b/src/bindings/c/docs/how_to_write_unit_test.md index 0cc2f0e1681..2db1a7ac88e 100644 --- a/src/bindings/c/docs/how_to_write_unit_test.md +++ b/src/bindings/c/docs/how_to_write_unit_test.md @@ -14,5 +14,5 @@ https://github.com/openvinotoolkit/openvino/blob/d96c25844d6cfd5ad131539c8a09282 ## See also * [OpenVINO™ README](../../../../README.md) * [C API developer guide](../README.md) - * [C API Reference](https://docs.openvino.ai/2023.0/api/api_reference.html) + * [C API Reference](https://docs.openvino.ai/2023.1/api/api_reference.html) diff --git a/src/plugins/auto/docs/integration.md b/src/plugins/auto/docs/integration.md index 9b719b01f9e..8a567a4614e 100644 --- a/src/plugins/auto/docs/integration.md +++ b/src/plugins/auto/docs/integration.md @@ -1,7 +1,7 @@ # AUTO Plugin Integration ## Implement a New Plugin -Refer to [OpenVINO Plugin Developer Guide](https://docs.openvino.ai/latest/openvino_docs_ie_plugin_dg_overview.html) for detailed information on how to implement a new plugin. +Refer to [OpenVINO Plugin Developer Guide](https://docs.openvino.ai/2023.1/openvino_docs_ie_plugin_dg_overview.html) for detailed information on how to implement a new plugin. Query model method `ov::IPlugin::query_model()` is recommended as it is important for AUTO to quickly make decisions and save selection time. diff --git a/src/plugins/proxy/README.md b/src/plugins/proxy/README.md index 5d5ae6b136c..fbd4caf627d 100644 --- a/src/plugins/proxy/README.md +++ b/src/plugins/proxy/README.md @@ -47,5 +47,5 @@ After the creation the proxy plugin has next properties: * [OpenVINO Core Components](../../README.md) * [OpenVINO Plugins](../README.md) * [Developer documentation](../../../docs/dev/index.md) - * [OpenVINO Plugin Developer Guide](https://docs.openvino.ai/latest/openvino_docs_ie_plugin_dg_overview.html) + * [OpenVINO Plugin Developer Guide](https://docs.openvino.ai/2023.1/openvino_docs_ie_plugin_dg_overview.html) diff --git a/tools/pot/README.md b/tools/pot/README.md index 15230642719..766d6e10439 100644 --- a/tools/pot/README.md +++ b/tools/pot/README.md @@ -12,14 +12,14 @@ and run on CPU with the OpenVINO™. Figure below shows the optimization workflow: ![](docs/images/workflow_simple.svg) -To get started with POT tool refer to the corresponding OpenVINO™ [documentation](https://docs.openvino.ai/2023.0/openvino_docs_model_optimization_guide.html). +To get started with POT tool refer to the corresponding OpenVINO™ [documentation](https://docs.openvino.ai/2023.1/openvino_docs_model_optimization_guide.html). ## Installation ### From PyPI -POT is distributed as a part of OpenVINO™ Development Tools package. For installation instruction please refer to this [document](https://docs.openvino.ai/2023.0/openvino_docs_install_guides_install_dev_tools.html). +POT is distributed as a part of OpenVINO™ Development Tools package. For installation instruction please refer to this [document](https://docs.openvino.ai/2023.1/openvino_docs_install_guides_install_dev_tools.html). ### From GitHub -As prerequisites, you should install [OpenVINO™ Runtime](https://docs.openvino.ai/2023.0/openvino_docs_install_guides_install_runtime.html) and other dependencies such as [Model Optimizer](https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html) and [Accuracy Checker](https://docs.openvino.ai/2023.0/omz_tools_accuracy_checker.html). +As prerequisites, you should install [OpenVINO™ Runtime](https://docs.openvino.ai/2023.1/openvino_docs_install_guides_overview.html) and other dependencies such as [Model Optimizer](https://docs.openvino.ai/2023.1/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html) and [Accuracy Checker](https://docs.openvino.ai/2023.1/omz_tools_accuracy_checker.html). To install POT from source: - Clone OpenVINO repository @@ -40,7 +40,7 @@ After installation POT is available as a Python library under `openvino.tools.po OpenVINO provides several examples to demonstrate the POT optimization workflow: * Command-line example: - * [Quantization of Image Classification model](https://docs.openvino.ai/2023.0/pot_configs_examples_README.html) + * [Quantization of Image Classification model](https://docs.openvino.ai/2023.1/pot_configs_examples_README.html) * API tutorials: * [Quantization of Image Classification model](https://github.com/openvinotoolkit/openvino_notebooks/tree/main/notebooks/301-tensorflow-training-openvino) * [Quantization of Object Detection model from Model Zoo](https://github.com/openvinotoolkit/openvino_notebooks/tree/main/notebooks/111-yolov5-quantization-migration) @@ -55,4 +55,4 @@ OpenVINO provides several examples to demonstrate the POT optimization workflow: ## See Also -* [Performance Benchmarks](https://docs.openvino.ai/2023.0/openvino_docs_performance_benchmarks.html) +* [Performance Benchmarks](https://docs.openvino.ai/2023.1/openvino_docs_performance_benchmarks.html) diff --git a/tools/pot/docs/ModelRepresentation.md b/tools/pot/docs/ModelRepresentation.md index 8bb9f3d3fbc..c6f693cf30e 100644 --- a/tools/pot/docs/ModelRepresentation.md +++ b/tools/pot/docs/ModelRepresentation.md @@ -8,7 +8,7 @@ Currently, there are two groups of optimization methods that can change the IR a ## Representation of quantized models -The OpenVINO Toolkit represents all the quantized models using the so-called [FakeQuantize](https://docs.openvino.ai/2023.0/openvino_docs_MO_DG_prepare_model_convert_model_Legacy_IR_Layers_Catalog_Spec.html#fakequantize-layer) operation. This operation is very expressive and allows mapping values from arbitrary input and output ranges. We project (discretize) the input values to the low-precision data type using affine transformation (with clamp and rounding) and then re-project discrete values back to the original range and data type. It can be considered as an emulation of the quantization/dequantization process which happens at runtime. The figure below shows a part of the DL model, namely the Convolutional layer, that undergoes various transformations, from being a floating-point model to an integer model executed in the OpenVINO runtime. Column 2 of this figure below shows a model quantized with [Neural Network Compression Framework (NNCF)](https://github.com/openvinotoolkit/nncf). +The OpenVINO Toolkit represents all the quantized models using the so-called [FakeQuantize](https://docs.openvino.ai/2021.4/openvino_docs_MO_DG_prepare_model_convert_model_Legacy_IR_Layers_Catalog_Spec.html#fakequantize-layer) operation. This operation is very expressive and allows mapping values from arbitrary input and output ranges. We project (discretize) the input values to the low-precision data type using affine transformation (with clamp and rounding) and then re-project discrete values back to the original range and data type. It can be considered as an emulation of the quantization/dequantization process which happens at runtime. The figure below shows a part of the DL model, namely the Convolutional layer, that undergoes various transformations, from being a floating-point model to an integer model executed in the OpenVINO runtime. Column 2 of this figure below shows a model quantized with [Neural Network Compression Framework (NNCF)](https://github.com/openvinotoolkit/nncf). ![](images/model_flow.png) To reduce memory footprint weights of quantized models are transformed to a target data type, e.g. in the case of 8-bit quantization, this is int8. During this transformation, the floating-point weights tensor and one of the FakeQuantize operations that correspond to it are replaced with 8-bit weight tensor and the sequence of Convert, Subtract, Multiply operations that represent the typecast and dequantization parameters (scale and zero-point) as it is shown in column 3 of the figure.