Bump deps py versions to fix severity issues (#21106)

* [Core] Safe loading of default plugins (#15073)

* Fix "(un)register_plugin(s)" C and Py tests (#15291)

* Update test in order to save behaviour

.ci/azure/android_arm64.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -18,7 +17,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/linux.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude:
     - docs/
@@ -17,7 +16,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude:
     - docs/
@@ -263,12 +261,19 @@ jobs:
     displayName: 'Remove debian dependencies'
     condition: eq(variables['CMAKE_CPACK_GENERATOR'], 'DEB')
     continueOnError: false
+
   - script: cmake -DCOMPONENT=python_wheels -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -P $(BUILD_DIR)/cmake_install.cmake
     displayName: 'Install wheel packages'
+
   - script: cmake -DCOMPONENT=tests -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -P $(BUILD_LAYER_TESTS_DIR)/cmake_install.cmake
     displayName: 'Install Layer Tests'
-  - script: python3 -m pip install openvino-dev --find-links=$(INSTALL_DIR)/tools
+
+  - script: |
+      set -e
+      python3 -m pip install $(INSTALL_DIR)/tools/openvino-*
+      python3 -m pip install $(INSTALL_DIR)/tools/openvino_dev-*
     displayName: 'Install python wheels'
+
   - script: |
       set -e
       cmake -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -DCOMPONENT=tests -P $(BUILD_DIR)/cmake_install.cmake

.ci/azure/linux_arm64.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -18,7 +17,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/linux_conditional_compilation.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -17,7 +16,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/linux_cuda.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -18,7 +17,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -140,6 +138,7 @@ jobs:
       -DENABLE_PYTHON=OFF
       -DENABLE_NVIDIA=ON
       -DENABLE_TESTS=ON
+      -DENABLE_DATA=OFF
       /root/repos/openvino &&
       /root/w/ninja -v CudaFuncTests CudaUnitTests"
     workingDirectory: $(WORK_DIR)

.ci/azure/linux_debian.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude:
     - docs/
@@ -17,7 +16,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude:
     - docs/

.ci/azure/linux_ngraph_onnx.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -18,7 +17,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/linux_onnxruntime.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -18,7 +17,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/mac.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -17,7 +16,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/windows.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -17,7 +16,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.ci/azure/windows_conditional_compilation.yml

@@ -3,7 +3,6 @@ trigger:
     include:
     - master 
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/
@@ -17,7 +16,6 @@ pr:
     include:
     - master
     - releases/*
-    - customer_A
   paths:
     exclude: 
     - docs/

.github/workflows/build_doc.yml

@@ -62,6 +62,8 @@ jobs:
           python3 -m pip install -r docs/requirements.txt --user
           cd docs/openvino_sphinx_theme
           python3 setup.py install --user
+          cd ../openvino_custom_sphinx_sitemap
+          python3 setup.py install --user
           cd ../..
           # install doxyrest
           wget https://github.com/vovkos/doxyrest/releases/download/doxyrest-2.1.3/doxyrest-2.1.3-linux-amd64.tar.xz

.github/workflows/code_style.yml

@@ -92,8 +92,8 @@ jobs:
       - name: Install Clang dependency
         run: |
           sudo apt update
-          sudo apt --assume-yes remove clang-7 clang-8 clang-9 clang-10 clang-11 clang-12 clang-13
-          sudo apt --assume-yes install libclang-14-dev
+          sudo apt --assume-yes remove clang-7 clang-8 clang-9 clang-10 clang-11 clang-12 clang-13 clang-15
+          sudo apt --assume-yes install clang-14 libclang-14-dev
 
       - name: Install Python-based dependencies
         run: python3 -m pip install -r cmake/developer_package/ncc_naming_style/requirements_dev.txt

cmake/dependencies.cmake

@@ -101,10 +101,10 @@ function(ov_download_tbb)
     if(WIN32 AND X86_64)
         # TODO: add target_path to be platform specific as well, to avoid following if
         RESOLVE_DEPENDENCY(TBB
-                ARCHIVE_WIN "tbb2020_617e9a71_win.zip"
+                ARCHIVE_WIN "tbb2020_81e4471_win.zip"
                 TARGET_PATH "${TEMP}/tbb"
                 ENVIRONMENT "TBBROOT"
-                SHA256 "01cac3cc48705bd52b83a6e1fa1ed95c708928be76160f5b9c5c37f954d56df4"
+                SHA256 "5e7c9dc430e8a61becd0b149668cb336ff44d0b4f8f823fc695b181880e213d2"
                 USE_NEW_LOCATION TRUE)
     elseif(ANDROID AND X86_64)
         RESOLVE_DEPENDENCY(TBB

cmake/developer_package/compile_flags/os_flags.cmake

@@ -363,6 +363,8 @@ else()
     endif()
 endif()
 
+check_cxx_compiler_flag("-Wunused-but-set-variable" UNUSED_BUT_SET_VARIABLE_SUPPORTED)
+
 # Links provided libraries and include their INTERFACE_INCLUDE_DIRECTORIES as SYSTEM
 function(link_system_libraries TARGET_NAME)
     set(MODE PRIVATE)

cmake/features.cmake

@@ -110,12 +110,12 @@ ie_dependent_option (GAPI_TEST_PERF "if GAPI unit tests should examine performan
 
 ie_dependent_option (ENABLE_MYRIAD_MVNC_TESTS "functional and behavior tests for mvnc api" OFF "ENABLE_TESTS;ENABLE_INTEL_MYRIAD" OFF)
 
-ie_dependent_option (ENABLE_DATA "fetch models from testdata repo" ON "ENABLE_FUNCTIONAL_TESTS;NOT ANDROID" OFF)
-
 ie_dependent_option (ENABLE_BEH_TESTS "tests oriented to check OpenVINO Runtime API correctness" ON "ENABLE_TESTS" OFF)
 
 ie_dependent_option (ENABLE_FUNCTIONAL_TESTS "functional tests" ON "ENABLE_TESTS" OFF)
 
+ie_dependent_option (ENABLE_DATA "fetch models from testdata repo" ON "ENABLE_FUNCTIONAL_TESTS;NOT ANDROID" OFF)
+
 ie_option (ENABLE_SAMPLES "console samples are part of OpenVINO Runtime package" ON)
 
 ie_option (ENABLE_OPENCV "enables custom OpenCV download" OFF)

cmake/templates/InferenceEngineConfig.cmake.in

@@ -37,6 +37,7 @@ include(CMakeFindDependencyMacro)
 
 find_dependency(OpenVINO
                 PATHS "${CMAKE_CURRENT_LIST_DIR}"
+                      "${CMAKE_CURRENT_LIST_DIR}/../openvino${InferenceEngine_VERSION}"
                 NO_CMAKE_FIND_ROOT_PATH
                 NO_DEFAULT_PATH)
 

cmake/templates/OpenVINOConfig.cmake.in

@@ -274,6 +274,14 @@ endfunction()
 # OpenVINO config
 #
 
+cmake_policy(PUSH)
+# we need CMP0057 to allow IN_LIST in if() command
+if(POLICY CMP0057)
+    cmake_policy(SET CMP0057 NEW)
+else()
+    message(FATAL_ERROR "OpenVINO requires CMake 3.3 or newer")
+endif()
+
 # need to store current PACKAGE_PREFIX_DIR, because it's overwritten by sub-package one
 set(_ov_package_prefix_dir "${PACKAGE_PREFIX_DIR}")
 
@@ -289,10 +297,30 @@ _ov_find_dependency(Threads)
 
 unset(_OV_ENABLE_OPENVINO_BUILD_SHARED)
 
+set(RUNTIME_AND_FRONTEND_TARGETS openvino::runtime openvino::runtime::c
+                                 openvino::frontend::onnx openvino::frontend::paddle
+                                 openvino::frontend::tensorflow)
+
 if(NOT TARGET openvino)
     set(_ov_as_external_package ON)
     include("${CMAKE_CURRENT_LIST_DIR}/OpenVINOTargets.cmake")
 
+    foreach(target ${RUNTIME_AND_FRONTEND_TARGETS})
+        if(TARGET ${target})
+            get_target_property(ORIGINAL_NAME ${target} ALIASED_TARGET)
+            if (ORIGINAL_NAME MATCHES "ORIGINAL_NAME-NOTFOUND")
+                set (ORIGINAL_NAME ${target})
+            endif()
+            get_target_property(imported_configs ${target} IMPORTED_CONFIGURATIONS)
+            if(RELWITHDEBINFO IN_LIST imported_configs)
+                set (MAP_CONFIG RELWITHDEBINFO)
+            else()
+                set (MAP_CONFIG RELEASE)
+            endif()
+            set_property(TARGET ${ORIGINAL_NAME} PROPERTY MAP_IMPORTED_CONFIG_RELWITHDEBINFO ${MAP_CONFIG})
+        endif()
+    endforeach()
+
     # WA for cmake version < 3.16 which does not export
     # IMPORTED_LINK_DEPENDENT_LIBRARIES_** properties if no PUBLIC dependencies for the library
     if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") AND TBB_FOUND)
@@ -332,8 +360,7 @@ endif()
 # Apply common functions
 #
 
-foreach(target openvino::runtime openvino::runtime::c
-               openvino::frontend::onnx openvino::frontend::paddle openvino::frontend::tensorflow)
+foreach(target ${RUNTIME_AND_FRONTEND_TARGETS})
     if(TARGET ${target} AND _ov_as_external_package)
         _ov_target_no_deprecation_error(${target})
     endif()
@@ -351,7 +378,10 @@ if(_need_package_name_reset)
     unset(_need_package_name_reset)
 endif()
 
+unset(RUNTIME_AND_FRONTEND_TARGETS)
 unset(${CMAKE_FIND_PACKAGE_NAME}_IR_FOUND)
 unset(${CMAKE_FIND_PACKAGE_NAME}_Paddle_FOUND)
 unset(${CMAKE_FIND_PACKAGE_NAME}_ONNX_FOUND)
 unset(${CMAKE_FIND_PACKAGE_NAME}_TensorFlow_FOUND)
+
+cmake_policy(POP)

cmake/templates/ngraphConfig.cmake.in

@@ -1,5 +1,5 @@
 # ******************************************************************************
-# Copyright 2017-2022 Intel Corporation
+# Copyright 2017-2023 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
 # ******************************************************************************
 #
 #
-# FindNGraph
+# ngraph config file
 # ------
 #
 # This script defines the following variables and imported targets:
@@ -44,7 +44,7 @@ include(CMakeFindDependencyMacro)
 
 find_dependency(OpenVINO
                 PATHS "${CMAKE_CURRENT_LIST_DIR}"
-                      "${CMAKE_CURRENT_LIST_DIR}/ngraph"
+                      "${CMAKE_CURRENT_LIST_DIR}/../openvino${ngraph_VERSION}"
                 NO_CMAKE_FIND_ROOT_PATH
                 NO_DEFAULT_PATH)
 

docs/Documentation/datumaro.md

@@ -0,0 +1,71 @@
+# Datumaro {#datumaro_documentation}
+
+@sphinxdirective 
+
+Datumaro provides a suite of basic data import/export (IE) for more than 35 public vision data
+formats and manipulation functionalities such as validation, correction, filtration, and some
+transformations. To achieve the web-scale training, this further aims to merge multiple
+heterogeneous datasets through comparator and merger. Datumaro is integrated into Geti™, OpenVINO™
+Training Extensions, and CVAT for the ease of data preparation. Datumaro is open-sourced and
+available on `GitHub <https://github.com/openvinotoolkit/datumaro>`__.
+Refer to the official `documentation <https://openvinotoolkit.github.io/datumaro/stable/docs/get-started/introduction.html>`__ to learn more.
+Plus, enjoy `Jupyter notebooks <https://github.com/openvinotoolkit/datumaro/tree/develop/notebooks>`__ for the real Datumaro practices.
+
+Detailed Workflow
+#################
+
+.. image:: ./_static/images/datumaro.png
+
+1. To start working with Datumaro, download public datasets or prepare your own annotated dataset.
+
+   .. note:: 
+      Datumaro provides a CLI `datum download` for downloading `TensorFlow Datasets <https://www.tensorflow.org/datasets>`__.
+
+2. Import data into Datumaro and manipulate the dataset for the data quality using `Validator`, `Corrector`, and `Filter`.
+
+3. Compare two datasets and transform the label schemas (category information) before merging them.
+
+4. Merge two datasets to a large-scale dataset.
+
+   .. note:: 
+      There are some choices of merger, i.e., `ExactMerger`, `IntersectMerger`, and `UnionMerger`.
+
+5. Split the unified dataset into subsets, e.g., `train`, `valid`, and `test` through `Splitter`.
+
+   .. note:: 
+      We can split data with a given ratio of subsets according to both the number of samples or
+      annotations. Please see `SplitTask` for the task-specific split.
+
+6. Export the cleaned and unified dataset for follow-up workflows such as model training.
+Go to :doc:`OpenVINO™ Training Extensions <ote_documentation>`.
+
+If the results are unsatisfactory, add datasets and perform the same steps, starting with dataset annotation.
+
+Datumaro Components
+###################
+
+* `Datumaro CLIs <https://openvinotoolkit.github.io/datumaro/stable/docs/command-reference/overview.html>`__
+* `Datumaro APIs <https://openvinotoolkit.github.io/datumaro/stable/docs/reference/datumaro_module.html>`__
+* `Datumaro data format <https://openvinotoolkit.github.io/datumaro/stable/docs/data-formats/datumaro_format.html>`__
+* `Supported data formats <https://openvinotoolkit.github.io/datumaro/stable/docs/data-formats/formats/index.html>`__
+
+Tutorials
+#########
+
+* `Basic skills <https://openvinotoolkit.github.io/datumaro/stable/docs/level-up/basic_skills/index.html>`__
+* `Intermediate skills <https://openvinotoolkit.github.io/datumaro/stable/docs/level-up/intermediate_skills/index.html>`__
+* `Advanced skills <https://openvinotoolkit.github.io/datumaro/stable/docs/level-up/advanced_skills/index.html>`__
+
+Python Hands-on Examples
+########################
+
+* `Data IE <https://openvinotoolkit.github.io/datumaro/stable/docs/jupyter_notebook_examples/dataset_IO.html>`__
+* `Data manipulation <https://openvinotoolkit.github.io/datumaro/stable/docs/jupyter_notebook_examples/manipulate.html>`__
+* `Data exploration <https://openvinotoolkit.github.io/datumaro/stable/docs/jupyter_notebook_examples/explore.html>`__
+* `Data refinement <https://openvinotoolkit.github.io/datumaro/stable/docs/jupyter_notebook_examples/refine.html>`__
+* `Data transformation <https://openvinotoolkit.github.io/datumaro/stable/docs/jupyter_notebook_examples/transform.html>`__
+* `Deep learning end-to-end use-cases <https://openvinotoolkit.github.io/datumaro/stable/docs/jupyter_notebook_examples/e2e_example.html>`__
+
+
+@endsphinxdirective 
+

docs/Documentation/deployment_guide_introduction.md

@@ -33,5 +33,4 @@ Once you have a model that meets both OpenVINO™ and your requirements, you can
 @endsphinxdirective
 
 
-
-Apart from the default deployment options, you may also [deploy your application for the TensorFlow framework with OpenVINO Integration](./openvino_ecosystem_ovtf.md).
+OpenVINO 2023.0 provides more options, providing inference of  TensorFlow models with no additional conversion.

docs/Documentation/openvino_ecosystem.md

@@ -7,7 +7,7 @@
    :hidden:
 
    ote_documentation
-   ovtf_integration
+   datumaro_documentation
    ovsa_get_started
    openvino_inference_engine_tools_compile_tool_README
    openvino_docs_tuning_utilities
@@ -36,6 +36,16 @@ More resources:
 * [GitHub](https://github.com/openvinotoolkit/training_extensions)
 * [Documentation](https://openvinotoolkit.github.io/training_extensions/stable/guide/get_started/introduction.html)
 
+### Dataset Management Framework (Datumaro)
+A framework and CLI tool to build, transform, and analyze datasets.
+
+More resources:
+ 
+* [Overview](@ref datumaro_documentation) 
+* [PyPI](https://pypi.org/project/datumaro/) 
+* [GitHub](https://github.com/openvinotoolkit/datumaro)
+* [Documentation](https://openvinotoolkit.github.io/datumaro/stable/docs/get-started/introduction.html)
+
 ### OpenVINO™ Security Add-on	 
 A solution for Model Developers and Independent Software Vendors to use secure packaging and secure model execution.	 
 
@@ -47,6 +57,8 @@ More resources:
 ### OpenVINO™ integration with TensorFlow (OVTF)
 A solution empowering TensorFlow developers with OpenVINO's optimization capabilities. With just two lines of code in your application, you can offload inference to OpenVINO, while keeping the TensorFlow API.
 
+OpenVINO™ Integration with TensorFlow will no longer be supported as of OpenVINO release 2023.0. As part of the 2023.0 release, OpenVINO will feature a significantly enhanced TensorFlow user experience within native OpenVINO without needing offline model conversions.
+
 More resources:
 * [documentation](https://github.com/openvinotoolkit/openvino_tensorflow)	 
 * [PyPI](https://pypi.org/project/openvino-tensorflow/) 
@@ -77,11 +89,3 @@ More resources:
 * [Docker Hub](https://hub.docker.com/r/openvino/cvat_server) 
 * [GitHub](https://github.com/openvinotoolkit/cvat)
 
-### Dataset Management Framework (Datumaro)
-A framework and CLI tool to build, transform, and analyze datasets.
-
-More resources:
-* [documentation on GitHub](https://openvinotoolkit.github.io/datumaro/docs/)
-* [PyPI](https://pypi.org/project/datumaro/)
-* [GitHub](https://github.com/openvinotoolkit/datumaro)
-

docs/Documentation/openvino_ecosystem_ovtf.md

@@ -1,44 +0,0 @@
-# OpenVINO™ integration with TensorFlow {#ovtf_integration}
-
-**OpenVINO™ integration with TensorFlow** is a solution for TensorFlow developers who want to get started with OpenVINO™ in their inferencing applications. By adding just two lines of code you can now take advantage of OpenVINO™ toolkit optimizations with TensorFlow inference applications across a range of Intel® computation devices.
-
-This is all you need:
-```bash
-import openvino_tensorflow
-openvino_tensorflow.set_backend('<backend_name>')
-```
-
-**OpenVINO™ integration with TensorFlow** accelerates inference across many AI models on a variety of Intel® technologies, such as:
-- Intel® CPUs
-- Intel® integrated GPUs
-- Intel® Movidius™ Vision Processing Units - referred to as VPU
-- Intel® Vision Accelerator Design with 8 Intel Movidius™ MyriadX VPUs - referred to as VAD-M or HDDL
-
-> **NOTE**: For maximum performance, efficiency, tooling customization, and hardware control, we recommend developers to adopt native OpenVINO™ solutions.
-To find out more about the product itself, as well as learn how to use it in your project, check its dedicated [GitHub repository](https://github.com/openvinotoolkit/openvino_tensorflow/tree/master/docs). 
-
-
-To see what you can do with **OpenVINO™ integration with TensorFlow**, explore the demos located in the [examples folder](https://github.com/openvinotoolkit/openvino_tensorflow/tree/master/examples) in our GitHub repository.  
-
-Sample tutorials are also hosted on [Intel® DevCloud](https://www.intel.com/content/www/us/en/developer/tools/devcloud/edge/build/ovtfoverview.html). The demo applications are implemented using Jupyter Notebooks. You can interactively execute them on Intel® DevCloud nodes, compare the results of **OpenVINO™ integration with TensorFlow**, native TensorFlow, and OpenVINO™. 
-
-## License
-**OpenVINO™ integration with TensorFlow** is licensed under [Apache License Version 2.0](https://github.com/openvinotoolkit/openvino_tensorflow/blob/master/LICENSE).
-By contributing to the project, you agree to the license and copyright terms therein
-and release your contribution under these terms.
-
-## Support
-
-Submit your questions, feature requests and bug reports via [GitHub issues](https://github.com/openvinotoolkit/openvino_tensorflow/issues).
-
-## How to Contribute
-
-We welcome community contributions to **OpenVINO™ integration with TensorFlow**. If you have an idea for improvement:
-
-* Share your proposal via [GitHub issues](https://github.com/openvinotoolkit/openvino_tensorflow/issues).
-* Submit a [pull request](https://github.com/openvinotoolkit/openvino_tensorflow/pulls).
-
-We will review your contribution as soon as possible. If any additional fixes or modifications are necessary, we will guide you and provide feedback. Before you make your contribution, make sure you can build **OpenVINO™ integration with TensorFlow** and run all the examples with your fix/patch. If you want to introduce a large feature, create test cases for your feature. Upon our verification of your pull request, we will merge it to the repository provided that the pull request has met the above mentioned requirements and proved acceptable.
-
----
-\* Other names and brands may be claimed as the property of others.

docs/Documentation/openvino_training_extensions.md

@@ -26,14 +26,15 @@ If the results are unsatisfactory, add datasets and perform the same steps, star
 OpenVINO Training Extensions Components
 #######################################
 
-- `OpenVINO Training Extensions SDK <https://github.com/openvinotoolkit/training_extensions/tree/master/ote_sdk>`__
-- `OpenVINO Training Extensions CLI <https://github.com/openvinotoolkit/training_extensions/tree/master/ote_cli>`__
-- `OpenVINO Training Extensions Algorithms <https://github.com/openvinotoolkit/training_extensions/tree/master/external>`__
+* `OpenVINO Training Extensions API <https://github.com/openvinotoolkit/training_extensions/tree/develop/otx/api>`__
+* `OpenVINO Training Extensions CLI <https://github.com/openvinotoolkit/training_extensions/tree/develop/otx/cli>`__
+* `OpenVINO Training Extensions Algorithms <https://github.com/openvinotoolkit/training_extensions/tree/develop/otx/algorithms>`__
 
 Tutorials
 #########
 
-`Object Detection <https://github.com/openvinotoolkit/training_extensions/blob/master/ote_cli/notebooks/train.ipynb>`__
+* `Base tutorial <https://openvinotoolkit.github.io/training_extensions/stable/guide/tutorials/base/index.html>`__
+* `Advanced tutorial <https://openvinotoolkit.github.io/training_extensions/stable/guide/tutorials/advanced/index.html>`__
 
 @endsphinxdirective 
 

docs/Doxyfile.config

@@ -1010,7 +1010,6 @@ EXCLUDE_SYMBOLS        = InferenceEngine::details \
                          ie_api::BlobBuffer \
                          *impl* \
                          *device_name* \
-                         *num_requests* \
                          *exec_net* \
                          *c_config* \
                          *ie_core_impl* \

docs/Extensibility_UG/VPU_Extensibility.md

@@ -1,5 +1,7 @@
 # How to Implement Custom Layers for VPU (Intel® Neural Compute Stick 2) {#openvino_docs_Extensibility_UG_VPU_Kernel}
 
+
+
 To enable operations not supported by OpenVINO™ out of the box, you need a custom extension for Model Optimizer, a custom nGraph operation set, and a custom kernel for the device you will target. This page describes custom kernel support for one the VPU, the Intel® Neural Compute Stick 2 device, which uses the MYRIAD device plugin.
 
 > **NOTE:**

docs/Extensibility_UG/frontend_extensions.md

@@ -1,14 +1,18 @@
 # Frontend Extensions {#openvino_docs_Extensibility_UG_Frontend_Extensions}
 
-The goal of this chapter is to explain how to use Frontend extension classes to facilitate mapping of custom operations from framework model representation to OpenVINO representation. Refer to [Introduction to OpenVINO Extension](Intro.md) to understand entire flow.
+@sphinxdirective
 
-This API is applicable for new frontends only, which exist for ONNX and PaddlePaddle. If a different model format is used, follow legacy [Model Optimizer Extensions](../MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md) guide.
+The goal of this chapter is to explain how to use Frontend extension classes to facilitate mapping of custom operations from framework model representation to OpenVINO representation. Refer to :doc:`Introduction to OpenVINO Extension <openvino_docs_Extensibility_UG_Intro>` to understand entire flow.
 
-> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/src/core/template_extension/new), which demonstrates extension development details based on minimalistic `Identity` operation that is a placeholder for your real custom operation. You can review the complete code, which is fully compliable, to see how it works.
+This API is applicable for new frontends only, which exist for ONNX and PaddlePaddle. If a different model format is used, follow legacy :doc:`Model Optimizer Extensions <openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Customize_Model_Optimizer>` guide.
 
-## Single Operation Mapping with OpExtension
+.. note:: 
+   This documentation is written based on the `Template extension <https://github.com/openvinotoolkit/openvino/tree/master/src/core/template_extension/new>`__, which demonstrates extension development details based on minimalistic ``Identity`` operation that is a placeholder for your real custom operation. You can review the complete code, which is fully compliable, to see how it works.
 
-This section covers the case when a single operation in framework representation is mapped to a single operation in OpenVINO representation. This is called *one-to-one mapping*. There is `OpExtension` class that works well if all the following conditions are satisfied:
+Single Operation Mapping with OpExtension
+######################################### 
+
+This section covers the case when a single operation in framework representation is mapped to a single operation in OpenVINO representation. This is called *one-to-one mapping*. There is ``OpExtension`` class that works well if all the following conditions are satisfied:
 
 1. Number of inputs to operation in the Framework representation is the same as in the OpenVINO representation.
 
@@ -20,54 +24,87 @@ This section covers the case when a single operation in framework representation
 
 5. Each attribute in OpenVINO operation can be initialized from one of the attributes of original operation or by some predefined constant value. Value of copied attributes cannot contain expressions, value is accepted as-is, so type of a value should be compatible.
 
-> **NOTE**: `OpExtension` class is currently available for ONNX frontend only. PaddlePaddle frontend has named inputs and outputs for operation (not indexed) therefore OpExtension mapping is not applicable for this case.
+.. note::
+   ``OpExtension`` class is currently available for ONNX frontend. PaddlePaddle frontend has named inputs and outputs for operation (not indexed) therefore OpExtension mapping is not applicable for this case.
 
-The next example maps ONNX operation with type [“Identity”]( https://github.com/onnx/onnx/blob/main/docs/Operators.md#Identity) to OpenVINO template extension `Identity` class.
+The next example maps ONNX operation with type `Identity <https://github.com/onnx/onnx/blob/main/docs/Operators.md#Identity>`__ to OpenVINO template extension ``Identity`` class.
 
-@snippet ov_extensions.cpp frontend_extension_Identity_header
-@snippet ov_extensions.cpp frontend_extension_Identity
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_Identity_header]
+
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_Identity]
 
 The mapping doesn’t involve any attributes, as operation Identity doesn’t have them.
 
-Extension objects, like just constructed `extension` can be used to add to the OpenVINO runtime just before the loading a model that contains custom operations:
+Extension objects, like just constructed ``extension`` can be used to add to the OpenVINO runtime just before the loading a model that contains custom operations:
 
-@snippet ov_extensions.cpp frontend_extension_read_model
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_read_model]
 
-Or extensions can be constructed in a separately compiled shared library. Separately compiled library can be used in Model Optimizer or `benchmark_app`. Read about how to build and load such library in chapter “Create library with extensions” in [Introduction to OpenVINO Extension](Intro.md).
+Or extensions can be constructed in a separately compiled shared library. Separately compiled library can be used in Model Optimizer or ``benchmark_app``. Read about how to build and load such library in chapter “Create library with extensions” in :doc:`Introduction to OpenVINO Extension <openvino_docs_Extensibility_UG_Intro>`.
 
-If operation have multiple inputs and/or outputs they will be mapped in order. The type of elements in input/output tensors should match expected types in the surrounding operations. For example, if custom operation produces `f32` data type then operation that consumes this output should also support `f32`. Otherwise, model conversion fails with an error, there are no automatic type conversion happens.
+If operation have multiple inputs and/or outputs they will be mapped in order. The type of elements in input/output tensors should match expected types in the surrounding operations. For example, if custom operation produces ``f32`` data type then operation that consumes this output should also support ``f32``. Otherwise, model conversion fails with an error, there are no automatic type conversion happens.
 
-### Converting to Standard OpenVINO Operation
+Converting to Standard OpenVINO Operation
++++++++++++++++++++++++++++++++++++++++++
 
-`OpExtension` class can be used when mapping to one of the operations from standard OpenVINO operation set is what you need and there is no class like `TemplateExtension::Identity` implemented.
+``OpExtension`` class can be used when mapping to one of the operations from standard OpenVINO operation set is what you need and there is no class like ``TemplateExtension::Identity`` implemented.
 
-Here is an example for a custom framework operation “MyRelu”. Suppose it is mathematically equivalent to standard `Relu` that exists in OpenVINO operation set, but for some reason has type name “MyRelu”. In this case you can directly say that “MyRelu” -> `Relu` mapping should be used:
+Here is an example for a custom framework operation “MyRelu”. Suppose it is mathematically equivalent to standard `Relu` that exists in OpenVINO operation set, but for some reason has type name “MyRelu”. In this case you can directly say that “MyRelu” -> ``Relu`` mapping should be used:
 
-@snippet ov_extensions.cpp frontend_extension_MyRelu
+.. tab-set::
 
-In the resulting converted OpenVINO model, “MyRelu” operation will be replaced by the standard operation `Relu` from the latest available OpenVINO operation set. Notice that when standard operation is used, it can be specified using just a type string (“Relu”) instead of using a `ov::opset8::Relu` class name as a template parameter for `OpExtension`. This method is available for operations from the standard operation set only. For a user custom OpenVINO operation the corresponding class should be always specified as a template parameter as it was demonstrated with `TemplateExtension::Identity`.
+   .. tab-item:: C++
+      :sync: cpp
 
-### Attributes Mapping
+      .. doxygensnippet:: docs/snippets/ov_extensions.cpp
+         :language: cpp
+         :fragment: [frontend_extension_MyRelu]
 
-As described above, `OpExtension` is useful when attributes can be mapped one by one or initialized by a constant. If the set of attributes in framework representation and OpenVINO representation completely match by their names and types, nothing should be specified in OpExtension constructor parameters. The attributes are discovered and mapped automatically based on `visit_attributes` method that should be defined for any OpenVINO operation.
+   .. tab-item:: Python
+      :sync: python
+   
+      .. doxygensnippet:: docs/snippets/ov_extensions.py
+         :language: python
+         :fragment: [py_frontend_extension_MyRelu]
 
-Imagine you have CustomOperation class implementation that has two attributes with names `attr1` and `attr2`:
 
-@snippet ov_extensions.cpp frontend_extension_CustomOperation
+In the resulting converted OpenVINO model, “MyRelu” operation will be replaced by the standard operation ``Relu`` from the latest available OpenVINO operation set. Notice that when standard operation is used, it can be specified using just a type string (“Relu”) instead of using a ``ov::opset8::Relu`` class name as a template parameter for ``OpExtension``. This method is available for operations from the standard operation set only. For a user custom OpenVINO operation the corresponding class should be always specified as a template parameter as it was demonstrated with ``TemplateExtension::Identity``.
 
-And original model in framework representation also has operation with name “CustomOperatoin” with the same `attr1` and `attr2` attributes. Then with the following code:
+Attributes Mapping
+++++++++++++++++++
 
-@snippet ov_extensions.cpp frontend_extension_CustomOperation_as_is
+As described above, ``OpExtension`` is useful when attributes can be mapped one by one or initialized by a constant. If the set of attributes in framework representation and OpenVINO representation completely match by their names and types, nothing should be specified in OpExtension constructor parameters. The attributes are discovered and mapped automatically based on ``visit_attributes`` method that should be defined for any OpenVINO operation.
 
-both `attr1` and `attr2` are copied from framework representation to OpenVINO representation automatically. If for some reason names of attributes are different but values still can be copied “as-is” you can pass attribute names mapping in `OpExtension` constructor:
+Imagine you have CustomOperation class implementation that has two attributes with names ``attr1`` and ``attr2``:
 
-@snippet ov_extensions.cpp frontend_extension_CustomOperation_rename
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_CustomOperation]
 
-Where `fw_attr1` and `fw_attr2` are names for corresponding attributes in framework operation representation.
+And original model in framework representation also has operation with name “CustomOperatoin” with the same ``attr1`` and ``attr2`` attributes. Then with the following code:
 
-If copying of an attribute is not what you need, `OpExtension` also can set attribute to predefined constant value. For the same `CustomOperation`, imagine you want to set `attr2` to value 5 instead of copying from `fw_attr2`, to achieve that do the following:
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_CustomOperation_as_is]
 
-@snippet ov_extensions.cpp frontend_extension_CustomOperation_rename_set
+both ``attr1`` and ``attr2`` are copied from framework representation to OpenVINO representation automatically. If for some reason names of attributes are different but values still can be copied “as-is” you can pass attribute names mapping in ``OpExtension`` constructor:
+
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_CustomOperation_rename]
+
+Where ``fw_attr1`` and ``fw_attr2`` are names for corresponding attributes in framework operation representation.
+
+If copying of an attribute is not what you need, ``OpExtension`` also can set attribute to predefined constant value. For the same ``CustomOperation``, imagine you want to set ``attr2`` to value 5 instead of copying from ``fw_attr2``, to achieve that do the following:
+
+.. doxygensnippet:: docs/snippets/ov_extensions.cpp
+   :language: cpp
+   :fragment: [frontend_extension_CustomOperation_rename_set]
 
 So the conclusion is that each attribute of target OpenVINO operation should be initialized either by
 
@@ -79,27 +116,62 @@ So the conclusion is that each attribute of target OpenVINO operation should be
 
 This is achieved by specifying maps as arguments for `OpExtension` constructor.
 
+Mapping to Multiple Operations with ConversionExtension
+#######################################################
 
-## Mapping to Multiple Operations with ConversionExtension
+Previous sections cover the case when a single operation is mapped to a single operation with optional adjustment in names and attribute values. That is likely enough for your own custom operation with existing C++ kernel implementation. In this case your framework representation and OpenVINO representation for the operation are under your control and inputs/outpus/attributes can be aligned to make ``OpExtension`` usable.
 
-Previous sections cover the case when a single operation is mapped to a single operation with optional adjustment in names and attribute values. That is likely enough for your own custom operation with existing C++ kernel implementation. In this case your framework representation and OpenVINO representation for the operation are under your control and inputs/outpus/attributes can be aligned to make `OpExtension` usable.
+In case if one-to-one mapping is not possible, *decomposition to multiple operations* should be considered. It is achieved by using more verbose and less automated ``ConversionExtension`` class. It enables writing arbitrary code to replace a single framework operation by multiple connected OpenVINO operations constructing dependency graph of any complexity.
 
-In case if one-to-one mapping is not possible, *decomposition to multiple operations* should be considered. It is achieved by using more verbose and less automated `ConversionExtension` class. It enables writing arbitrary code to replace a single framework operation by multiple connected OpenVINO operations constructing dependency graph of any complexity.
+``ConversionExtension`` maps a single operation to a function which builds a graph using OpenVINO operation classes. Follow chapter :ref:`Build a Model in OpenVINO Runtime <ov_ug_build_model>` to learn how to use OpenVINO operation classes to build a fragment of model for replacement.
 
-`ConversionExtension` maps a single operation to a function which builds a graph using OpenVINO operation classes. Follow chapter [Build a Model in OpenVINO Runtime](@ref ov_ug_build_model) to learn how to use OpenVINO operation classes to build a fragment of model for replacement.
+The next example illustrates using ``ConversionExtension`` for conversion of “ThresholdedRelu” from ONNX according to the formula: ``ThresholdedRelu(x, alpha) -> Multiply(x, Convert(Greater(x, alpha), type=float))``.
 
-The next example illustrates using `ConversionExtension` for conversion of “ThresholdedRelu” from ONNX according to the formula: `ThresholdedRelu(x, alpha) -> Multiply(x, Convert(Greater(x, alpha), type=float))`.
+.. note:: 
+   ``ThresholdedRelu`` is one of the standard ONNX operators which is supported by ONNX frontend natively out-of-the-box. Here we are re-implementing it to illustrate how you can add a similar support for your custom operation instead of ``ThresholdedRelu``.
 
-> **NOTE**: `ThresholdedRelu` is one of the standard ONNX operators which is supported by ONNX frontend natively out-of-the-box. Here we are re-implementing it to illustrate how you can add a similar support for your custom operation instead of `ThresholdedRelu`.
+.. tab-set::
 
-@snippet ov_extensions.cpp frontend_extension_ThresholdedReLU_header
-@snippet ov_extensions.cpp frontend_extension_ThresholdedReLU
+   .. tab-item:: C++
+      :sync: cpp
+ 
+      .. doxygensnippet:: docs/snippets/ov_extensions.cpp
+         :language: cpp
+         :fragment: [frontend_extension_ThresholdedReLU_header]
 
-To access original framework operation attribute value and connect to inputs, `node` object of type `NodeContext` is used. It has two main methods:
+   .. tab-item:: Python
+      :sync: python
 
-* `NodeContext::get_input` to get input with a given index,
+      .. doxygensnippet:: docs/snippets/ov_extensions.py
+         :language: python
+         :fragment: [py_frontend_extension_ThresholdedReLU_header]
 
-* `NodeContext::get_attribute` to get attribute value with a given name.
+
+.. tab-set::
+
+   .. tab-item:: C++
+      :sync: cpp
+ 
+      .. doxygensnippet:: docs/snippets/ov_extensions.cpp
+         :language: cpp
+         :fragment: [frontend_extension_ThresholdedReLU]
+
+   .. tab-item:: Python
+      :sync: python
+ 
+      .. doxygensnippet:: docs/snippets/ov_extensions.py
+         :language: python
+         :fragment: [py_frontend_extension_ThresholdedReLU]
+
+
+To access original framework operation attribute value and connect to inputs, ``node`` object of type ``NodeContext`` is used. It has two main methods:
+
+* ``NodeContext::get_input`` to get input with a given index,
+
+* ``NodeContext::get_attribute`` to get attribute value with a given name.
 
 The conversion function should return a vector of node outputs that are mapped to corresponding outputs of the original framework operation in the same order.
 
+@endsphinxdirective
+
+

docs/MO_DG/prepare_model/Supported_Frameworks_Layers.md

@@ -490,6 +490,7 @@ Some of TensorFlow operations do not match any OpenVINO operations. Yet, they ar
 | Abs |
 | Acos |
 | Acosh |
+| Add |
 | And |
 | ArgMin | 
 | ArgMax | 

docs/MO_DG/prepare_model/convert_model/tf_specific/Convert_EfficientDet_Models.md

@@ -8,48 +8,20 @@ There are several public versions of EfficientDet model implementation available
 convert models from the [repository](https://github.com/google/automl/tree/master/efficientdet)
  (commit 96e1fee) to the OpenVINO format.
 
-### Getting a Frozen TensorFlow Model
+Download and extract the model checkpoint [efficientdet-d4.tar.gz](https://storage.googleapis.com/cloud-tpu-checkpoints/efficientdet/coco2/efficientdet-d4.tar.gz) referenced in the **Pretrained EfficientDet Checkpoints** section of the model repository:
 
-Follow the instructions below to get frozen TensorFlow EfficientDet model. EfficientDet-D4 model is an example:
-
-1. Clone the repository:<br>
-```sh
-git clone https://github.com/google/automl
-cd automl/efficientdet
-```
-2. (Optional) Checkout to the commit that the conversion was tested on:<br>
-```sh
-git checkout 96e1fee
-```
-3. Install required dependencies:<br>
-```sh
-python3 -m pip install --upgrade pip
-python3 -m pip install -r requirements.txt
-python3 -m pip install --upgrade tensorflow-model-optimization
-```
-4. Download and extract the model checkpoint [efficientdet-d4.tar.gz](https://storage.googleapis.com/cloud-tpu-checkpoints/efficientdet/coco2/efficientdet-d4.tar.gz)
-referenced in the **"Pretrained EfficientDet Checkpoints"** section of the model repository:<br>
 ```sh
 wget https://storage.googleapis.com/cloud-tpu-checkpoints/efficientdet/coco2/efficientdet-d4.tar.gz
 tar zxvf efficientdet-d4.tar.gz
 ```
-5. Freeze the model:<br>
-```sh
- mo --runmode=saved_model --model_name=efficientdet-d4  --ckpt_path=efficientdet-d4 --saved_model_dir=savedmodeldir
-```
-As a result, the frozen model file `savedmodeldir/efficientdet-d4_frozen.pb` will be generated.
-
-> **NOTE**: For custom trained models, specify `--hparams` flag to `config.yaml` which was used during training.
-
-> **NOTE**: If you see an error *AttributeError: module 'tensorflow_core.python.keras.api._v2.keras.initializers' has no attribute 'variance_scaling'*, apply the fix from the [patch](https://github.com/google/automl/pull/846).
 
 ### Converting an EfficientDet TensorFlow Model to the IR
 
 To generate the IR of the EfficientDet TensorFlow model, run:<br>
+
 ```sh
 mo \
---input_model savedmodeldir/efficientdet-d4_frozen.pb \
---transformations_config front/tf/automl_efficientdet.json \
+--input_meta_graph efficientdet-d4/model.meta \
 --input_shape [1,$IMAGE_SIZE,$IMAGE_SIZE,3] \
 --reverse_input_channels
 ```
@@ -59,12 +31,6 @@ EfficientDet models were trained with different input image sizes. To determine
 dictionary in the [hparams_config.py](https://github.com/google/automl/blob/96e1fee/efficientdet/hparams_config.py#L304) file.
 The attribute `image_size` specifies the shape to be defined for the model conversion.
 
-The `transformations_config` command line parameter specifies the configuration json file containing hints
-for the Model Optimizer on how to convert the model and trigger transformations implemented in the
-`<PYTHON_SITE_PACKAGES>/openvino/tools/mo/front/tf/AutomlEfficientDet.py`. The json file contains some parameters which must be changed if you
-train the model yourself and modified the `hparams_config` file or the parameters are different from the ones used for EfficientDet-D4.
-The attribute names are self-explanatory or match the name in the `hparams_config` file.
-
 > **NOTE**: The color channel order (RGB or BGR) of an input data should match the channel order of the model training dataset. If they are different, perform the `RGB<->BGR` conversion specifying the command-line parameter: `--reverse_input_channels`. Otherwise, inference results may be incorrect. For more information about the parameter, refer to the **When to Reverse Input Channels** section of the [Converting a Model to Intermediate Representation (IR)](@ref openvino_docs_MO_DG_prepare_model_convert_model_Converting_Model) guide.
 
 OpenVINO toolkit provides samples that can be used to infer EfficientDet model. 
@@ -73,21 +39,21 @@ For more information, refer to the [Open Model Zoo Demos](@ref omz_demos).
 ## <a name="efficientdet-ir-results-interpretation"></a>Interpreting Results of the TensorFlow Model and the IR
 
 The TensorFlow model produces as output a list of 7-element tuples: `[image_id, y_min, x_min, y_max, x_max, confidence, class_id]`, where:
-* `image_id` -- image batch index.
-* `y_min` -- absolute `y` coordinate of the lower left corner of the detected object.
-* `x_min` -- absolute `x` coordinate of the lower left corner of the detected object.
-* `y_max` -- absolute `y` coordinate of the upper right corner of the detected object.
-* `x_max` -- absolute `x` coordinate of the upper right corner of the detected object.
-* `confidence` -- is the confidence of the detected object.
-* `class_id` -- is the id of the detected object class counted from 1.
+* `image_id` - image batch index.
+* `y_min` - absolute `y` coordinate of the lower left corner of the detected object.
+* `x_min` - absolute `x` coordinate of the lower left corner of the detected object.
+* `y_max` - absolute `y` coordinate of the upper right corner of the detected object.
+* `x_max` - absolute `x` coordinate of the upper right corner of the detected object.
+* `confidence` - is the confidence of the detected object.
+* `class_id` - is the id of the detected object class counted from 1.
 
 The output of the IR is a list of 7-element tuples: `[image_id, class_id, confidence, x_min, y_min, x_max, y_max]`, where:
-* `image_id` -- image batch index.
-* `class_id` -- is the id of the detected object class counted from 0.
-* `confidence` -- is the confidence of the detected object.
-* `x_min` -- normalized `x` coordinate of the lower left corner of the detected object.
-* `y_min` -- normalized `y` coordinate of the lower left corner of the detected object.
-* `x_max` -- normalized `x` coordinate of the upper right corner of the detected object.
-* `y_max` -- normalized `y` coordinate of the upper right corner of the detected object.
+* `image_id` - image batch index.
+* `class_id` - is the id of the detected object class counted from 0.
+* `confidence` - is the confidence of the detected object.
+* `x_min` - normalized `x` coordinate of the lower left corner of the detected object.
+* `y_min` - normalized `y` coordinate of the lower left corner of the detected object.
+* `x_max` - normalized `x` coordinate of the upper right corner of the detected object.
+* `y_max` - normalized `y` coordinate of the upper right corner of the detected object.
 
 The first element with `image_id = -1` means end of data.

docs/OV_Runtime_UG/auto_device_selection.md

@@ -66,12 +66,12 @@ Note that if you choose to exclude CPU from the priority list or disable the ini
 This mechanism can be easily observed in the :ref:`Using AUTO with Benchmark app sample <using-auto-with-openvino-samples-and-benchmark-app>` section, showing how the first-inference latency (the time it takes to compile the model and perform the first inference) is reduced when using AUTO. For example:
 
 
-.. code-block: sh
+.. code-block:: sh
 
    benchmark_app -m ../public/alexnet/FP32/alexnet.xml -d GPU -niter 128
 
 
-.. code-block: sh
+.. code-block:: sh
 
    benchmark_app -m ../public/alexnet/FP32/alexnet.xml -d AUTO -niter 128
 
@@ -224,9 +224,14 @@ Performance Hints for AUTO
 
 The ``ov::hint::performance_mode`` property enables you to specify a performance option for AUTO to be more efficient for particular use cases. The default hint for AUTO is ``LATENCY``.
 
+The THROUGHPUT and CUMULATIVE_THROUGHPUT hints below only improve performance in an asynchronous inference pipeline. For information on asynchronous inference, see the `Async API documentation <https://docs.openvino.ai/2022.3/openvino_docs_OV_UG_Infer_request.html#doxid-openvino-docs-o-v-u-g-infer-request>`__ . The following notebooks provide examples of how to set up an asynchronous pipeline:
+
+* :doc:`Image Classification Async Sample <openvino_inference_engine_samples_classification_sample_async_README>`
+* `Notebook - Asynchronous Inference with OpenVINO™ <https://docs.openvino.ai/2022.3/notebooks/115-async-api-with-output.html>`__
+* `Notebook - Automatic Device Selection with OpenVINO <https://docs.openvino.ai/2022.3/notebooks/106-auto-device-with-output.html>`__
 
 LATENCY
-^^^^^^^
+----------
 
 This option prioritizes low latency, providing short response time for each inference job. It performs best for tasks where inference is required for a single input image, e.g. a medical analysis of an ultrasound scan image. It also fits the tasks of real-time or nearly real-time applications, such as an industrial robot's response to actions in its environment or obstacle avoidance for autonomous vehicles.
 
@@ -251,15 +256,43 @@ While ``LATENCY`` and ``THROUGHPUT`` can select one target device with your pref
 
 CUMULATIVE_THROUGHPUT has similar behavior as :doc:`the Multi-Device execution mode (MULTI) <openvino_docs_OV_UG_Running_on_multiple_devices>`. The only difference is that CUMULATIVE_THROUGHPUT uses the devices specified by AUTO, which means that it's not mandatory to add devices manually, while with MULTI, you need to specify the devices before inference.
 
-With the CUMULATIVE_THROUGHPUT option:
+If device priority is specified when using CUMULATIVE_THROUGHPUT, AUTO will run inference requests on devices based on the priority. In the following example, AUTO will always try to use GPU first, and then use CPU if GPU is busy:
 
-* If ``AUTO`` without any device names is specified, and the system has more than two GPU devices, AUTO will remove CPU from the device candidate list to keep GPU running at full capacity.
-* If device priority is specified, AUTO will run inference requests on devices based on the priority. In the following example, AUTO will always try to use GPU first, and then use CPU if GPU is busy:
+.. tab-set::
 
-  .. code-block: sh
+    .. tab-item:: C++
+        :sync: cpp
 
-     ov::CompiledModel compiled_model = core.compile_model(model, "AUTO:GPU,CPU", ov::hint::performance_mode(ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT));
+        .. code-block:: sh
 
+           ov::CompiledModel compiled_model = core.compile_model(model, "AUTO:GPU,CPU", ov::hint::performance_mode(ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT));
+
+    .. tab-item:: Python
+        :sync: py
+
+        .. code-block:: sh
+
+           compiled_model = core.compile_model(model, "AUTO:GPU,CPU", {"PERFORMANCE_HINT" : {"CUMULATIVE_THROUGHPUT"}})
+
+
+If AUTO is used without specifying any device names, and if there are multiple GPUs in the system, CUMULATIVE_THROUGHPUT mode will use all of the GPUs by default. If the system has more than two GPU devices, AUTO will remove CPU from the device candidate list to keep the GPUs running at full capacity. A full list of system devices and their unique identifiers can be queried using ov::Core::get_available_devices (for more information, see :doc:`Query Device Properties <openvino_docs_OV_UG_query_api>`). To explicitly specify which GPUs to use, set their priority when compiling with AUTO:
+
+.. tab-set::
+
+    .. tab-item:: C++
+        :sync: cpp
+
+        .. code-block:: sh
+
+           ov::CompiledModel compiled_model = core.compile_model(model, "AUTO:GPU.1,GPU.0", ov::hint::performance_mode(ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT));
+
+
+    .. tab-item:: Python
+        :sync: py
+
+        .. code-block:: sh
+
+           compiled_model = core.compile_model(model, "AUTO:GPU.1,GPU.0", {"PERFORMANCE_HINT" : {"CUMULATIVE_THROUGHPUT"})
 
 Code Examples
 --------------------
@@ -267,17 +300,21 @@ Code Examples
 To enable performance hints for your application, use the following code:
 
 
-.. tab:: C++
+.. tab-set::
 
-   .. doxygensnippet:: docs/snippets/AUTO3.cpp
-      :language: cpp
-      :fragment: [part3]
+    .. tab-item:: C++
+        :sync: cpp
 
-.. tab:: Python
+        .. doxygensnippet:: docs/snippets/AUTO3.cpp
+            :language: cpp
+            :fragment: [part3]
 
-   .. doxygensnippet:: docs/snippets/ov_auto.py
-      :language: python
-      :fragment: [part3]
+    .. tab-item:: Python
+        :sync: py
+
+        .. doxygensnippet:: docs/snippets/ov_auto.py
+           :language: python
+           :fragment: [part3]
 
 
 Disabling Auto-Batching for THROUGHPUT and CUMULATIVE_THROUGHPUT
@@ -292,17 +329,21 @@ Configuring Model Priority
 The ``ov::hint::model_priority`` property enables you to control the priorities of models in the Auto-Device plugin. A high-priority model will be loaded to a supported high-priority device. A lower-priority model will not be loaded to a device that is occupied by a higher-priority model.
 
 
-.. tab:: C++
+.. tab-set::
 
-   .. doxygensnippet:: docs/snippets/AUTO4.cpp
-      :language: cpp
-      :fragment: [part4]
+    .. tab-item:: C++
+        :sync: cpp
 
-.. tab:: Python
+        .. doxygensnippet:: docs/snippets/AUTO4.cpp
+            :language: cpp
+            :fragment: [part4]
 
-   .. doxygensnippet:: docs/snippets/ov_auto.py
-      :language: python
-      :fragment: [part4]
+    .. tab-item:: Python
+        :sync: py
+
+        .. doxygensnippet:: docs/snippets/ov_auto.py
+           :language: python
+           :fragment: [part4]
 
 
 Checking Target Runtime Devices
@@ -311,35 +352,43 @@ Checking Target Runtime Devices
 To query the runtime target devices on which the inferences are being executed using AUTO, you can use the ``ov::execution_devices`` property. It must be used with ``get_property``, for example:
 
 
-.. tab:: C++
+.. tab-set::
 
-   .. doxygensnippet:: docs/snippets/AUTO7.cpp
-      :language: cpp
-      :fragment: [part7]
+    .. tab-item:: C++
+        :sync: cpp
 
-.. tab:: Python
+        .. doxygensnippet:: docs/snippets/AUTO7.cpp
+            :language: cpp
+            :fragment: [part7]
 
-   .. doxygensnippet:: docs/snippets/ov_auto.py
-      :language: python
-      :fragment: [part7]
+    .. tab-item:: Python
+        :sync: py
+
+        .. doxygensnippet:: docs/snippets/ov_auto.py
+           :language: python
+           :fragment: [part7]
 
 
 Configuring Individual Devices and Creating the Auto-Device plugin on Top
 #########################################################################
 
-Although the methods described above are currently the preferred way to execute inference with AUTO, the following steps can be also used as an alternative. It is currently available as a legacy feature and used if the device candidate list includes Myriad devices, incapable of utilizing the Performance Hints option.
+Although the methods described above are currently the preferred way to execute inference with AUTO, the following steps can be also used as an alternative. It is currently available as a legacy feature and used if AUTO is incapable of utilizing the Performance Hints option.
 
-.. tab:: C++
+.. tab-set::
 
-   .. doxygensnippet:: docs/snippets/AUTO5.cpp
-      :language: cpp
-      :fragment: [part5]
+    .. tab-item:: C++
+        :sync: cpp
 
-.. tab:: Python
+        .. doxygensnippet:: docs/snippets/AUTO5.cpp
+            :language: cpp
+            :fragment: [part5]
 
-   .. doxygensnippet:: docs/snippets/ov_auto.py
-      :language: python
-      :fragment: [part5]
+    .. tab-item:: Python
+        :sync: py
+
+        .. doxygensnippet:: docs/snippets/ov_auto.py
+           :language: python
+           :fragment: [part5]
 
 
 .. _using-auto-with-openvino-samples-and-benchmark-app:
@@ -351,15 +400,15 @@ To see how the Auto-Device plugin is used in practice and test its performance,
 
 For unlimited device choice:
 
-.. code-block:sh
+.. code-block:: sh
 
    benchmark_app –d AUTO –m <model> -i <input> -niter 1000
 
 For limited device choice:
 
-.. code-block:sh
+.. code-block:: sh
 
-   benchmark_app –d AUTO:CPU,GPU,MYRIAD –m <model> -i <input> -niter 1000
+   benchmark_app –d AUTO:CPU,GPU,GNA –m <model> -i <input> -niter 1000
 
 For more information, refer to the :doc:`C++ <openvino_inference_engine_samples_benchmark_app_README>` or :doc:`Python <openvino_inference_engine_tools_benchmark_tool_README>` version instructions.
 

docs/OV_Runtime_UG/automatic_batching.md

@@ -1,155 +1,237 @@
 # Automatic Batching {#openvino_docs_OV_UG_Automatic_Batching}
 
-The Automatic Batching Execution mode (or Auto-batching for short) performs automatic batching on-the-fly to improve device utilization by grouping inference requests together, with no programming effort from the user.
+@sphinxdirective
+
+The Automatic Batching Execution mode (or Auto-batching for short) performs automatic batching on-the-fly to improve device utilization by grouping inference requests together, without programming effort from the user.
 With Automatic Batching, gathering the input and scattering the output from the individual inference requests required for the batch happen transparently, without affecting the application code. 
 
-This article provides a preview of the new Automatic Batching function, including how it works, its configurations, and testing performance.
+Auto Batching can be used :ref:`directly as a virtual device <auto-batching-as-device>` or as an :ref:`option for inference on CPU/GPU/VPU <auto-batching-as-option>` (by means of configuration/hint). These 2 ways are provided for the user to enable the BATCH devices **explicitly** or **implicitly**, with the underlying logic remaining the same. An example of the difference is that the CPU device doesn’t support implicitly to enable BATCH device, commands such as ``./benchmark_app -m <model> -d CPU -hint tput`` will not apply BATCH device **implicitly**, but ``./benchmark_app -m <model> -d "BATCH:CPU(16)`` can **explicitly** load BATCH device.
 
-## Enabling/Disabling Automatic Batching
-
-Auto-batching primarily targets the existing code written for inferencing many requests, each instance with the batch size 1. To obtain corresponding performance improvements, the application **must be running many inference requests simultaneously**. 
+Auto-batching primarily targets the existing code written for inferencing many requests, each instance with the batch size 1. To get corresponding performance improvements, the application **must be running multiple inference requests simultaneously**. 
 Auto-batching can also be used via a particular *virtual* device.       
 
-Batching is a straightforward way of leveraging the compute power of GPU and saving on communication overheads. Automatic Batching is "implicitly" triggered on the GPU when `ov::hint::PerformanceMode::THROUGHPUT` is specified for the `ov::hint::performance_mode` property for the `compile_model` or `set_property` calls.
+This article provides a preview of the Automatic Batching function, including how it works, its configurations, and testing performance.
 
-@sphinxtabset
+How Automatic Batching Works
+############################
 
-@sphinxtab{C++}
+.. tab-set::
+   
+   .. tab-item:: Enabling Automatic Batching
+      :sync: enabling-automatic-batching
+         
+      Batching is a straightforward way of leveraging the compute power of GPU and saving on communication overheads. Automatic Batching is "implicitly" triggered on the GPU when ``ov::hint::PerformanceMode::THROUGHPUT`` is specified for the ``ov::hint::performance_mode`` property for the ``compile_model`` or ``set_property`` calls.
 
-@snippet docs/snippets/ov_auto_batching.cpp compile_model
+      .. tab-set::
+   
+         .. tab-item:: C++
+            :sync: cpp
+               
+            .. doxygensnippet:: docs/snippets/ov_auto_batching.cpp
+               :language: cpp
+               :fragment: [compile_model]
+      
+         .. tab-item:: Python
+            :sync: py
+      
+            .. doxygensnippet:: docs/snippets/ov_auto_batching.py
+               :language: Python
+               :fragment: [compile_model]
+         
+      To enable Auto-batching in the legacy apps not akin to the notion of performance hints, you need to use the **explicit** device notion, such as ``BATCH:GPU``.
 
-@endsphinxtab
+   .. tab-item:: Disabling Automatic Batching
+      :sync: disabling-automatic-batching
 
-@sphinxtab{Python}
+      Auto-Batching can be disabled (for example, for the GPU device) to prevent being triggered by ``ov::hint::PerformanceMode::THROUGHPUT``. To do that, set ``ov::hint::allow_auto_batching`` to **false** in addition to the ``ov::hint::performance_mode``, as shown below:
 
-@snippet docs/snippets/ov_auto_batching.py compile_model
-
-@endsphinxtab
-
-@endsphinxtabset
+      .. tab-set::
+   
+         .. tab-item:: C++
+            :sync: cpp
+               
+            .. doxygensnippet:: docs/snippets/ov_auto_batching.cpp
+               :language: cpp
+               :fragment: [compile_model_no_auto_batching]
+      
+         .. tab-item:: Python
+            :sync: py
+      
+            .. doxygensnippet:: docs/snippets/ov_auto_batching.py
+               :language: Python
+               :fragment: [compile_model_no_auto_batching]
 
 
-To enable Auto-batching in the legacy apps not akin to the notion of performance hints, you need to use the **explicit** device notion, such as `BATCH:GPU`.
+Configuring Automatic Batching
+++++++++++++++++++++++++++++++
 
-### Disabling Automatic Batching
-
-Auto-Batching can be disabled (for example, for the GPU device) to prevent being triggered by `ov::hint::PerformanceMode::THROUGHPUT`. To do that, set `ov::hint::allow_auto_batching` to **false** in addition to the `ov::hint::performance_mode`, as shown below:
-
-@sphinxtabset
-
-@sphinxtab{C++}
-
-@snippet docs/snippets/ov_auto_batching.cpp compile_model_no_auto_batching
-
-@endsphinxtab
-
-@sphinxtab{Python}
-
-@snippet docs/snippets/ov_auto_batching.py compile_model_no_auto_batching
-
-@endsphinxtab
-
-@endsphinxtabset
-
-
-## Configuring Automatic Batching
 Following the OpenVINO naming convention, the *batching* device is assigned the label of *BATCH*. The configuration options are as follows:
 
-| Parameter name     | Parameter description      |             Examples                                                      |
-| :---               | :---                  |:-----------------------------------------------------------------------------|
-| `AUTO_BATCH_DEVICE` | The name of the device to apply Automatic batching,  with the optional batch size value in brackets. | `BATCH:GPU` triggers the automatic batch size selection. `BATCH:GPU(4)` directly specifies the batch size.     |
-| `ov::auto_batch_timeout` | The timeout value, in ms. (1000 by default) |  You can reduce the timeout value to avoid performance penalty when the data arrives too unevenly. For example, set it to "100", or the contrary, i.e., make it large enough to accommodate input preparation (e.g. when it is a serial process).     |
++----------------------------+------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Parameter name             | Parameter description                                                                                | Examples                                                                                                                                                                                                                                         |
++============================+======================================================================================================+==================================================================================================================================================================================================================================================+
+| ``AUTO_BATCH_DEVICE``      | The name of the device to apply Automatic batching,  with the optional batch size value in brackets. | ``BATCH:GPU`` triggers the automatic batch size selection. ``BATCH:GPU(4)`` directly specifies the batch size.                                                                                                                                   |
++----------------------------+------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``ov::auto_batch_timeout`` | The timeout value, in ms. (1000 by default)                                                          | You can reduce the timeout value to avoid performance penalty when the data arrives too unevenly. For example, set it to "100", or the contrary, i.e., make it large enough to accommodate input preparation (e.g. when it is a serial process). |
++----------------------------+------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
-## Automatic Batch Size Selection
+Automatic Batch Size Selection
+++++++++++++++++++++++++++++++
 
-In both the THROUGHPUT hint and the explicit BATCH device cases, the optimal batch size is selected automatically, as the implementation queries the `ov::optimal_batch_size` property from the device and passes the model graph as the parameter. The actual value depends on the model and device specifics, for example, the on-device memory for dGPUs.
-The support for Auto-batching is not limited to GPU. However, if a device does not support `ov::optimal_batch_size` yet, to work with Auto-batching, an explicit batch size must be specified, e.g., `BATCH:<device>(16)`.
+In both the THROUGHPUT hint and the explicit BATCH device cases, the optimal batch size is selected automatically, as the implementation queries the ``ov::optimal_batch_size`` property from the device and passes the model graph as the parameter. The actual value depends on the model and device specifics, for example, the on-device memory for dGPUs.
+The support for Auto-batching is not limited to GPU. However, if a device does not support ``ov::optimal_batch_size`` yet, to work with Auto-batching, an explicit batch size must be specified, e.g., ``BATCH:<device>(16)``.
 
-This "automatic batch size selection" works on the presumption that the application queries `ov::optimal_number_of_infer_requests` to create the requests of the returned number and run them simultaneously:
+This "automatic batch size selection" works on the presumption that the application queries ``ov::optimal_number_of_infer_requests`` to create the requests of the returned number and run them simultaneously:
 
-@sphinxtabset
+.. tab-set::
+   
+   .. tab-item:: C++
+      :sync: cpp
+         
+      .. doxygensnippet:: docs/snippets/ov_auto_batching.cpp
+         :language: cpp
+         :fragment: [query_optimal_num_requests]
 
-@sphinxtab{C++}
+   .. tab-item:: Python
+      :sync: py
 
-@snippet docs/snippets/ov_auto_batching.cpp query_optimal_num_requests
-
-@endsphinxtab
-
-@sphinxtab{Python}
-
-@snippet docs/snippets/ov_auto_batching.py query_optimal_num_requests
-
-@endsphinxtab
-
-@endsphinxtabset
+      .. doxygensnippet:: docs/snippets/ov_auto_batching.py
+         :language: Python
+         :fragment: [query_optimal_num_requests]
 
 
-### Optimizing Performance by Limiting Batch Size
+.. _limiting-batch-size:
 
-If not enough inputs were collected, the `timeout` value makes the transparent execution fall back to the execution of individual requests. This value can be configured via the `AUTO_BATCH_TIMEOUT` property.
+Optimizing Performance by Limiting Batch Size
+---------------------------------------------
+
+If not enough inputs were collected, the ``timeout`` value makes the transparent execution fall back to the execution of individual requests. This value can be configured via the ``AUTO_BATCH_TIMEOUT`` property.
 The timeout, which adds itself to the execution time of the requests, heavily penalizes the performance. To avoid this, when your parallel slack is bounded, provide OpenVINO with an additional hint.
 
-For example, when the application processes only 4 video streams, there is no need to use a batch larger than 4. The most future-proof way to communicate the limitations on the parallelism is to equip the performance hint with the optional `ov::hint::num_requests` configuration key set to 4. This will limit the batch size for the GPU and the number of inference streams for the CPU, hence each device uses `ov::hint::num_requests` while converting the hint to the actual device configuration options:
-
-@sphinxtabset
-
-@sphinxtab{C++}
-
-@snippet docs/snippets/ov_auto_batching.cpp hint_num_requests
-
-@endsphinxtab
-
-@sphinxtab{Python}
-
-@snippet docs/snippets/ov_auto_batching.py hint_num_requests
-
-@endsphinxtab
-
-@endsphinxtabset
+For example, when the application processes only 4 video streams, there is no need to use a batch larger than 4. The most future-proof way to communicate the limitations on the parallelism is to equip the performance hint with the optional ``ov::hint::num_requests`` configuration key set to 4. This will limit the batch size for the GPU and the number of inference streams for the CPU, hence each device uses ``ov::hint::num_requests`` while converting the hint to the actual device configuration options:
 
 
-For the *explicit* usage, you can limit the batch size by using `BATCH:GPU(4)`, where 4 is the number of requests running in parallel.
+.. tab-set::
+   
+   .. tab-item:: C++
+      :sync: cpp
+         
+      .. doxygensnippet:: docs/snippets/ov_auto_batching.cpp
+         :language: cpp
+         :fragment: [hint_num_requests]
 
-## Other Performance Considerations
+   .. tab-item:: Python
+      :sync: py
+
+      .. doxygensnippet:: docs/snippets/ov_auto_batching.py
+         :language: Python
+         :fragment: [hint_num_requests]
+
+
+For the *explicit* usage, you can limit the batch size by using ``BATCH:GPU(4)``, where 4 is the number of requests running in parallel.
+
+
+.. _auto-batching-as-device:
+
+Automatic Batching as an explicit device
+++++++++++++++++++++++++++++++++++++++++
+
+The below examples show how AUTO Batching can be used in the form of device that the user can apply to perform inference directly:
+
+.. code-block:: sh
+
+   ./benchmark_app -m <model> -d "BATCH:GPU"
+   ./benchmark_app -m <model> -d "BATCH:GPU(16)"
+   ./benchmark_app -m <model> -d "BATCH:CPU(16)"
+
+
+* ``BATCH`` -- load BATCH device explicitly, 
+* ``:GPU(16)`` -- BATCH devices configuration, which tell BATCH device to apply GPU device with batch size = 16.
+
+.. _auto-batching-as-option:
+
+Automatic Batching as underlying device configured to other devices
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+In the following example, BATCH device will be configured to another device in case of ``tput/ctput mode``.
+
+.. code-block:: sh
+
+   ./benchmark_app -m <model> -d GPU -hint tput
+   ./benchmark_app -m <model> -d AUTO -hint tput
+   ./benchmark_app -m <model> -d AUTO -hint ctput  
+   ./benchmark_app -m <model> -d AUTO:GPU -hint ctput
+
+.. note::
+   If you run ``./benchmark_app``, do not set ``batch_size`` by ``-b <batch_size>``, otherwise AUTO mode will not be applied.
+
+Other Performance Considerations
+################################
 
 To achieve the best performance with Automatic Batching, the application should:
- - Operate inference requests of the number that represents the multiple of the batch size. In the example above, for batch size 4, the application should operate 4, 8, 12, 16, etc. requests.
- - Use the requests that are grouped by the batch size together. For example, the first 4 requests are inferred, while the second group of the requests is being populated. Essentially, Automatic Batching shifts the asynchronicity from the individual requests to the groups of requests that constitute the batches.
-  - Balance the `timeout` value vs. the batch size. For example, in many cases, having a smaller `timeout` value/batch size may yield better performance than having a larger batch size with a `timeout` value that is not large enough to accommodate the full number of the required requests.
-  - When Automatic Batching is enabled, the `timeout` property of `ov::CompiledModel` can be changed anytime, even after the loading/compilation of the model. For example, setting the value to 0 disables Auto-batching effectively, as the collection of requests would be omitted.
-  - Carefully apply Auto-batching to the pipelines. For example, in the conventional "video-sources -> detection -> classification" flow, it is most beneficial to do Auto-batching over the inputs to the detection stage. The resulting number of detections is usually fluent, which makes Auto-batching less applicable for the classification stage.
 
-The following are limitations of the current implementations:
+- Operate inference requests of the number that represents the multiple of the batch size. In the example from :ref:`Optimizing Performance by Limiting Batch Size section <limiting-batch-size>` -- for batch size 4, the application should operate 4, 8, 12, 16, etc. requests.
+- Use the requests that are grouped by the batch size together. For example, the first 4 requests are inferred, while the second group of the requests is being populated. Essentially, Automatic Batching shifts the asynchronicity from the individual requests to the groups of requests that constitute the batches.
+- Balance the ``timeout`` value vs. the batch size. For example, in many cases, having a smaller ``timeout`` value/batch size may yield better performance than having a larger batch size with a ``timeout`` value that is not large enough to accommodate the full number of the required requests.
+- When Automatic Batching is enabled, the ``timeout`` property of ``ov::CompiledModel`` can be changed anytime, even after the loading/compilation of the model. For example, setting the value to 0 disables Auto-batching effectively, as the collection of requests would be omitted.
+- Carefully apply Auto-batching to the pipelines. For example, in the conventional "video-sources -> detection -> classification" flow, it is most beneficial to do Auto-batching over the inputs to the detection stage. The resulting number of detections is usually fluent, which makes Auto-batching less applicable for the classification stage.
+
+Limitations
++++++++++++
+
+The following are limitations of the current AUTO Batching implementations:
+
+- The dynamic model is not supported by ``BATCH`` device.
+- ``BATCH`` device can only support ``tput/ctput mode``. The ``latency/none mode`` is not supported.
+- Supported are only models with ``batch dimension = 1``.
+- The input/output tensor should come from ``inferRequest``, otherwise the user-created tensor will trigger a memory copying.
+- The ``OPTIMAL_BATCH_SIZE`` should be greater than ``2``. In case it's not, user needs to specify a batch size which depends on model and device (CPU does not support this property).
+- ``BATCH`` device supports GPU by default, while CPU will not trigger ``auto_batch`` in ``tput`` mode.
+- ``AUTO_BATCH`` will bring much more compilation latency.
 - Although it is less critical for the throughput-oriented scenarios, the load time with Auto-batching increases by almost double.
- - Certain networks are not safely reshapable by the "batching" dimension (specified as `N` in the layout terms). Besides, if the batching dimension is not zeroth, Auto-batching will not be triggered "implicitly" by the throughput hint.
- -  The "explicit" notion, for example, `BATCH:GPU`, using the relaxed dimensions tracking, often makes Auto-batching possible. For example, this method unlocks most **detection networks**.
- - When *forcing* Auto-batching via the "explicit" device notion, make sure that you validate the results for correctness.   
- - Performance improvements happen at the cost of the growth of memory footprint. However, Auto-batching queries the available memory (especially for dGPU) and limits the selected batch size accordingly.
+- Certain networks are not safely reshapable by the "batching" dimension (specified as ``N`` in the layout terms). Besides, if the batching dimension is not zeroth, Auto-batching will not be triggered "implicitly" by the throughput hint.
+-  The "explicit" notion, for example, ``BATCH:GPU``, using the relaxed dimensions tracking, often makes Auto-batching possible. For example, this method unlocks most **detection networks**.
+- When *forcing* Auto-batching via the "explicit" device notion, make sure that you validate the results for correctness.   
+- Performance improvements happen at the cost of the growth of memory footprint. However, Auto-batching queries the available memory (especially for dGPU) and limits the selected batch size accordingly.
 
 
-## Testing Performance with Benchmark_app
-The `benchmark_app` sample, that has both [C++](../../samples/cpp/benchmark_app/README.md) and [Python](../../tools/benchmark_tool/README.md) versions, is the best way to evaluate the performance of Automatic Batching:
- -  The most straightforward way is using the performance hints:
-    - benchmark_app **-hint tput** -d GPU -m 'path to your favorite model'
- -  You can also use the "explicit" device notion to override the strict rules of the implicit reshaping by the batch dimension:
-    - benchmark_app **-hint none -d BATCH:GPU** -m 'path to your favorite model'
- -  or override the automatically deduced batch size as well:
-    - $benchmark_app -hint none -d **BATCH:GPU(16)** -m 'path to your favorite model'
-    - This example also applies to CPU or any other device that generally supports batch execution.
-    - Keep in mind that some shell versions (e.g. `bash`) may require adding quotes around complex device names, i.e. `-d "BATCH:GPU(16)"` in this example.
+Testing Performance with Benchmark_app
+######################################
+
+The ``benchmark_app`` sample, that has both :doc:`C++ <openvino_inference_engine_samples_benchmark_app_README>` and :doc:`Python <openvino_inference_engine_tools_benchmark_tool_README>` versions, is the best way to evaluate the performance of Automatic Batching:
+
+- The most straightforward way is using the performance hints:
+  
+  - benchmark_app **-hint tput** -d GPU -m 'path to your favorite model'
+- You can also use the "explicit" device notion to override the strict rules of the implicit reshaping by the batch dimension:
+  
+  - benchmark_app **-hint none -d BATCH:GPU** -m 'path to your favorite model'
+- or override the automatically deduced batch size as well:
+  
+  - $benchmark_app -hint none -d **BATCH:GPU(16)** -m 'path to your favorite model'
+  - This example also applies to CPU or any other device that generally supports batch execution.
+  - Keep in mind that some shell versions (e.g. ``bash``) may require adding quotes around complex device names, i.e. ``-d "BATCH:GPU(16)"`` in this example.
+
 
 Note that Benchmark_app performs a warm-up run of a *single* request. As Auto-Batching requires significantly more requests to execute in batch, this warm-up run hits the default timeout value (1000 ms), as reported in the following example:
 
-  ```
-  [ INFO ] First inference took 1000.18ms 
-  ```
-This value also exposed as the final execution statistics on the `benchmark_app` exit: 
-  ```
-  [ INFO ] Latency: 
-  [ INFO ] 	Max:      1000.18 ms
-  ```
+.. code-block:: sh
+
+   [ INFO ] First inference took 1000.18ms 
+
+This value also exposed as the final execution statistics on the ``benchmark_app`` exit:
+   
+.. code-block:: sh
+
+   [ INFO ] Latency: 
+   [ INFO ]  Max:      1000.18 ms
+
 This is NOT the actual latency of the batched execution, so you are recommended to refer to other metrics in the same log, for example, "Median" or "Average" execution. 
 
-### Additional Resources
+Additional Resources
+####################
 
-* [Supported Devices](supported_plugins/Supported_Devices.md)
+* :doc:`Supported Devices <openvino_docs_OV_UG_supported_plugins_Supported_Devices>`
+
+
+@endsphinxdirective

docs/OV_Runtime_UG/deployment/deployment-manager-tool.md

@@ -14,6 +14,9 @@ To use the Deployment Manager tool, the following requirements need to be met:
    * **For VPU**, see [Configurations for Intel® Vision Accelerator Design with Intel® Movidius™ VPUs](../../install_guides/configurations-for-ivad-vpu.md).
    * **For GNA**, see [Intel® Gaussian & Neural Accelerator (GNA)](../../install_guides/configurations-for-intel-gna.md)
 
+
+
+
 > **IMPORTANT**: The operating system on the target system must be the same as the development system on which you are creating the package. For example, if the target system is Ubuntu 18.04, the deployment package must be created from the OpenVINO™ toolkit installed on Ubuntu 18.04.
 
 > **TIP**: If your application requires additional dependencies, including the Microsoft Visual C++ Redistributable, use the ['--user_data' option](https://docs.openvino.ai/latest/openvino_docs_install_guides_deployment_manager_tool.html#run-standard-cli-mode) to add them to the deployment archive. Install these dependencies on the target host before running inference.

docs/OV_Runtime_UG/ov_dynamic_shapes.md

@@ -38,19 +38,21 @@ The decision about using dynamic shapes should be based on proper benchmarking o
 Unlike statically shaped models, dynamically shaped ones require different inference time, depending on input data shape or input tensor content.
 Furthermore, using the dynamic shapes can bring more overheads in memory and running time of each inference call depending on hardware plugin and model used.
 
-## Handling Dynamic Shapes Natively
+## Handling Dynamic Shapes
 
-This section describes how to handle dynamically shaped models natively with OpenVINO Runtime API version 2022.1 and higher.
-There are three main parts in the flow that differ from static shapes:
- - Configure the model.
- - Prepare data for inference.
- - Read resulting data after inference.
+This section describes how to handle dynamically shaped models with OpenVINO Runtime API version 2022.1 and higher. When using dynamic shapes, there are three main differences in the workflow than with static shapes:
+
+* Configuring the model
+* Preparing and inferencing dynamic data
+* Dynamic shapes in outputs
 
 ### Configuring the Model
 
-To avoid the methods mentioned in the previous section, there is a way to specify one or multiple dimensions to be dynamic, directly in the model inputs.
-This is achieved with the same reshape method that is used for alternating static shape of inputs.
-Dynamic dimensions are specified as `-1` or the `ov::Dimension()` instead of a positive number used for static dimensions:
+Model input dimensions can be specified as dynamic using the model.reshape method. To set a dynamic dimension, use `-1`, `ov::Dimension()` (C++), or `ov.Dimension()` (Python) as the value for that dimension.
+
+> **NOTE**: 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 Optimizer 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](https://docs.openvino.ai/2022.3/omz_models_model_mobilenet_v2.html)). 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.
 
 @sphinxtabset
 
@@ -64,6 +66,8 @@ Dynamic dimensions are specified as `-1` or the `ov::Dimension()` instead of a p
 
 @snippet docs/snippets/ov_dynamic_shapes.py reshape_undefined
 
+With Python, you may also pass all dimensions as a string and use `?` for the dynamic dimensions (e.g. `model.reshape(“1, 3, ?, ?”)`).
+
 @endsphinxtab
 
 @sphinxtab{C}
@@ -74,45 +78,84 @@ Dynamic dimensions are specified as `-1` or the `ov::Dimension()` instead of a p
 
 @endsphinxtabset
 
-To simplify the code, the examples assume that the model has a single input and single output.
-However, there are no limitations on the number of inputs and outputs to apply dynamic shapes.
-
-### Undefined Dimensions "Out Of the Box"
-
-Dynamic dimensions may appear in the input model without calling the `reshape` method.
-Many DL frameworks support undefined dimensions.
-If such a model is converted with Model Optimizer or read directly by the `Core::read_model`, undefined dimensions are preserved.
-Such dimensions are automatically treated as dynamic ones.
-Therefore, there is no need to call the `reshape` method, if undefined dimensions are already configured in the original or the IR model.
-
-If the input model has undefined dimensions that will not change during inference. It is recommended to set them to static values, using the same `reshape` method of the model.
-From the API perspective, any combination of dynamic and static dimensions can be configured.
-
-Model Optimizer provides identical capability to reshape the model during the conversion, including specifying dynamic dimensions.
-Use this capability to save time on calling `reshape` method in the end application.
-To get information about setting input shapes using Model Optimizer, refer to [Setting Input Shapes](../MO_DG/prepare_model/convert_model/Converting_Model.md).
-
-### Dimension Bounds
-
-Apart from a dynamic dimension, the lower and/or upper bounds can also be specified. They define a range of allowed values for the dimension.
-The bounds are coded as arguments for the `ov::Dimension`:
+The examples above assume that the model has a single input layer. To change models with multiple input layers (such as NLP models), iterate over all the input layers, update the shape per layer, and apply the model.reshape method. For example, the following code sets the second dimension as dynamic in every input layer:
 
 @sphinxtabset
 
 @sphinxtab{C++}
 
+@snippet docs/snippets/ov_dynamic_shapes.cpp ov_dynamic_shapes:reshape_multiple_inputs
+
+@endsphinxtab
+
+@sphinxtab{Python}
+
+@snippet docs/snippets/ov_dynamic_shapes.py reshape_multiple_inputs
+
+@endsphinxtab
+
+@endsphinxtabset
+
+For more examples of how to change multiple input layers, see [Changing Input Shapes](ShapeInference.md).
+
+#### Undefined Dimensions "Out Of the Box"
+
+Many DL frameworks support generating models with dynamic (or undefined) dimensions. If such a model is converted with Model Optimizer or read directly by `Core::read_model`, its dynamic dimensions are preserved. These models do not need any additional configuration to use them with dynamic shapes.
+
+To check if a model already has dynamic dimensions, first load it with the `read_model()` method, then check the `partial_shape` property of each layer. If the model has any dynamic dimensions, they will be reported as `?`. For example, the following code will print the name and dimensions of each input layer:
+
+@sphinxtabset
+
+@sphinxtab{C++}
+
+@snippet docs/snippets/ov_dynamic_shapes.cpp ov_dynamic_shapes:check_inputs
+
+@endsphinxtab
+
+@sphinxtab{Python}
+
+@snippet docs/snippets/ov_dynamic_shapes.py check_inputs
+
+@endsphinxtab
+
+@endsphinxtabset
+
+If the input model already has dynamic dimensions, that will not change during inference. If the inputs will not be used dynamically, it is recommended to set them to static values using the `reshape` method to save application memory and potentially improve inference speed. The OpenVINO API supports any combination of static and dynamic dimensions.
+
+Static and dynamic dimensions can also be set when converting the model with Model Optimizer. It has identical capabilities to the ``reshape`` method, so you can save time by converting the model with dynamic shapes beforehand rather than in the application code. To get information about setting input shapes using Model Optimizer, refer to [Setting Input Shapes](../MO_DG/prepare_model/convert_model/Converting_Model.md).
+
+#### Dimension Bounds
+
+The lower and/or upper bounds of a dynamic dimension can also be specified. They define a range of allowed values for the dimension. Dimension bounds can be set by passing the lower and upper bounds into the `reshape` method using the options shown below. 
+
+@sphinxtabset
+
+@sphinxtab{C++}
+
+The dimension bounds can be coded as arguments for `ov::Dimension`, as shown in these examples:
+
 @snippet docs/snippets/ov_dynamic_shapes.cpp ov_dynamic_shapes:reshape_bounds
 
 @endsphinxtab
 
 @sphinxtab{Python}
 
+Each of these options are equivalent:
+
+- Pass the lower and upper bounds directly into the `reshape` method, e.g. `model.reshape([1, 10), (8,512)])`
+- Pass the lower and upper bounds using ov.Dimension, e.g. `model.reshape([ov.Dimension(1, 10), (8, 512)])`
+- Pass the dimension ranges as strings, e.g. `model.reshape(“1..10, 8..512”)`
+
+The examples below show how to set dynamic dimension bounds for a mobilenet-v2 model with a default static shape of `[1,3,224,224]`.
+
 @snippet docs/snippets/ov_dynamic_shapes.py reshape_bounds
 
 @endsphinxtab
 
 @sphinxtab{C}
 
+The dimension bounds can be coded as arguments for [ov_dimension](https://docs.openvino.ai/2022.3/structov_dimension.html#doxid-structov-dimension), as shown in these examples:
+
 @snippet docs/snippets/ov_dynamic_shapes.c ov_dynamic_shapes:reshape_bounds
 
 @endsphinxtab
@@ -131,11 +174,11 @@ Depending on the plugin, specifying the upper bounds can be required. For inform
 
 If the lower and upper bounds for a dimension are known, it is recommended to specify them, even if a plugin can execute a model without the bounds.
 
-### Setting Input Tensors
+### Preparing and Inferencing Dynamic Data
 
-Preparing a model with the `reshape` method is the first step.
-The second step is passing a tensor with an appropriate shape to infer request.
-This is similar to the [regular steps](integrate_with_your_application.md). However, tensors can now be passed with different shapes for the same executable model and even for the same inference request:
+After configuring a model with the `reshape` method, the next steps are to create tensors with the appropriate data shape and pass them to the model as an inference request. This is similar to the regular steps described in [Integrate OpenVINO™ with Your Application](integrate_with_your_application.md). However, tensors can now be passed into the model with different shapes.
+
+The sample below shows how a model can accept different input shapes. In the first case, the model runs inference on a 1x128 input shape and returns a result. In the second case, a 1x200 input shape is used, which the model can still handle because it is dynamically shaped.
 
 @sphinxtabset
 
@@ -159,45 +202,13 @@ This is similar to the [regular steps](integrate_with_your_application.md). Howe
 
 @endsphinxtabset
 
-In the example above, the `set_input_tensor` is used to specify input tensors.
-The real dimension of the tensor is always static, because it is a particular tensor and it does not have any dimension variations in contrast to model inputs.
-
-Similar to static shapes, `get_input_tensor` can be used instead of `set_input_tensor`.
-In contrast to static input shapes, when using `get_input_tensor` for dynamic inputs, the `set_shape` method for the returned tensor should be called to define the shape and allocate memory.
-Without doing so, the tensor returned by `get_input_tensor` is an empty tensor. The shape of the tensor is not initialized and memory is not allocated, because infer request does not have information about the real shape that will be provided.
-Setting shape for an input tensor is required when the corresponding input has at least one dynamic dimension, regardless of the bounds.
-Contrary to previous example, the following one shows the same sequence of two infer requests, using `get_input_tensor` instead of `set_input_tensor`:
-
-@sphinxtabset
-
-@sphinxtab{C++}
-
-@snippet docs/snippets/ov_dynamic_shapes.cpp ov_dynamic_shapes:get_input_tensor
-
-@endsphinxtab
-
-@sphinxtab{Python}
-
-@snippet  docs/snippets/ov_dynamic_shapes.py get_input_tensor
-
-@endsphinxtab
-
-@sphinxtab{C}
-
-@snippet docs/snippets/ov_dynamic_shapes.c ov_dynamic_shapes:get_input_tensor
-
-@endsphinxtab
-
-@endsphinxtabset
+For more information on how to apply input data to a model and run inference, see [OpenVINO™ Inference Request](ov_infer_request.md).
 
 ### Dynamic Shapes in Outputs
 
-Examples above are valid approaches when dynamic dimensions in output may be implied by propagation of dynamic dimension from the inputs.
-For example, batch dimension in an input shape is usually propagated through the whole model and appears in the output shape.
-It also applies to other dimensions, like sequence length for NLP models or spatial dimensions for segmentation models, that are propagated through the entire network.
+When using dynamic dimensions in the input of a model, one or more output dimensions may also be dynamic depending on how the dynamic inputs are propagated through the model. For example, the batch dimension in an input shape is usually propagated through the whole model and appears in the output shape. It also applies to other dimensions, like sequence length for NLP models or spatial dimensions for segmentation models, that are propagated through the entire network.
 
-Whether the output has dynamic dimensions or not can be verified by querying the output partial shape after the model is read or reshaped.
-The same applies to inputs. For example:
+To determine if the output has dynamic dimensions, the `partial_shape` property of the model’s output layers can be queried after the model has been read or reshaped. The same property can be queried for model inputs. For example:
 
 @sphinxtabset
 
@@ -221,9 +232,9 @@ The same applies to inputs. For example:
 
 @endsphinxtabset
 
-When there are dynamic dimensions in corresponding inputs or outputs, the `?` or ranges like `1..10` appear.
+If the output has any dynamic dimensions, they will be reported as `?` or as a range (e.g.`1..10`).
 
-It can also be verified in a more programmatic way:
+Output layers can also be checked for dynamic dimensions using the `partial_shape.is_dynamic()` property. This can be used on an entire output layer, or on an individual dimension, as shown in these examples:
 
 @sphinxtabset
 
@@ -247,8 +258,6 @@ It can also be verified in a more programmatic way:
 
 @endsphinxtabset
 
+If at least one dynamic dimension exists in the output layer of a model, the actual shape of the output tensor will be determined during inference. Before the first inference, the output tensor’s memory is not allocated and has a shape of `[0]`.
 
-If at least one dynamic dimension exists in an output of a model, a shape of the corresponding output tensor will be set as the result of inference call.
-Before the first inference, memory for such a tensor is not allocated and has the `[0]` shape.
-If the `set_output_tensor` method is called with a pre-allocated tensor, the inference will call the `set_shape` internally, and the initial shape is replaced by the calculated shape.
-Therefore, setting a shape for output tensors in this case is useful only when pre-allocating enough memory for output tensor. Normally, the `set_shape` method of a `Tensor` re-allocates memory only if a new shape requires more storage.
+To pre-allocate space in memory for the output tensor, use the `set_output_tensor` method with the expected shape of the output. This will call the `set_shape` method internally, which will cause the initial shape to be replaced by the calculated shape.

docs/OV_Runtime_UG/performance_hints.md

@@ -9,15 +9,14 @@ Previously, a certain level of automatic configuration was the result of the *de
 The hints, in contrast, respect the actual model, so the parameters for optimal throughput are calculated for each model individually (based on its compute versus memory bandwidth requirements and capabilities of the device).
 
 ## Performance Hints: Latency and Throughput
-As discussed in the [Optimization Guide](../optimization_guide/dldt_deployment_optimization_guide.md) there are a few different metrics associated with inference speed.
-Throughput and latency are some of the most widely used metrics that measure the overall performance of an application.
 
-Therefore, in order to ease the configuration of the device, OpenVINO offers two dedicated hints, namely `ov::hint::PerformanceMode::THROUGHPUT` and `ov::hint::PerformanceMode::LATENCY`.
-A special `ov::hint::PerformanceMode::UNDEFINED` hint acts the same as specifying no hint.
+As discussed in the [Optimization Guide](../optimization_guide/dldt_deployment_optimization_guide.md) there are a few different metrics associated with inference speed. Throughput and latency are some of the most widely used metrics that measure the overall performance of an application.
+
+Therefore, in order to ease the configuration of the device, OpenVINO offers two dedicated hints, namely `ov::hint::PerformanceMode::THROUGHPUT` and `ov::hint::PerformanceMode::LATENCY`. A special `ov::hint::PerformanceMode::UNDEFINED` hint acts the same as specifying no hint.
 
 For more information on conducting performance measurements with the `benchmark_app`, refer to the last section in this document.
 
-Keep in mind that a typical model may take significantly more time to load with the `ov::hint::PerformanceMode::THROUGHPUT` and consume much more memory, compared to the `ov::hint::PerformanceMode::LATENCY`.
+Keep in mind that a typical model may take significantly more time to load with the `ov::hint::PerformanceMode::THROUGHPUT` and consume much more memory, compared to the `ov::hint::PerformanceMode::LATENCY`. Also, the `THROUGHPUT` and `LATENCY` hints only improve performance in an asynchronous inference pipeline. For information on asynchronous inference, see the [Prefer Async API](#prefer-async-api) section of this document.
 
 ## Performance Hints: How It Works
 Internally, every device "translates" the value of the hint to the actual performance settings.
@@ -94,14 +93,18 @@ The hints are used on the presumption that the application queries `ov::optimal_
 
 @endsphinxdirective
 
-While an application is free to create more requests if needed (for example to support asynchronous inputs population) **it is very important to at least run the `ov::optimal_number_of_infer_requests` of the inference requests in parallel**. It is recommended for efficiency, or device utilization, reasons. 
+While an application is free to create more requests if needed (for example to support asynchronous inputs population) **it is very important to at least run the** `ov::optimal_number_of_infer_requests` **of the inference requests in parallel**. It is recommended for efficiency, or device utilization, reasons. 
 
 Keep in mind that `ov::hint::PerformanceMode::LATENCY` does not necessarily imply using single inference request. For example, multi-socket CPUs can deliver as many requests at the same minimal latency as the number of NUMA nodes in the system.
 To make your application fully scalable, make sure to query the `ov::optimal_number_of_infer_requests` directly.
 
-## Prefer Async API
-The API of the inference requests offers Sync and Async execution. The `ov::InferRequest::infer()` is inherently synchronous and simple to operate (as it serializes the execution flow in the current application thread). The Async "splits" the `infer()` into `ov::InferRequest::start_async()` and `ov::InferRequest::wait()` (or callbacks). For more information, refer to the [API examples](../OV_Runtime_UG/ov_infer_request.md).
- Although the Synchronous API can be somewhat easier to start with, it is recommended to use the Asynchronous (callbacks-based) API in the production code. It is the most general and scalable way to implement the flow control for any possible number of requests (and thus both latency and throughput scenarios).
+## <a name="prefer-async-api"></a>Prefer Async API  
+
+The API of the inference requests offers Sync and Async execution. The `ov::InferRequest::infer()` is inherently synchronous and simple to operate (as it serializes the execution flow in the current application thread). The Async "splits" the `infer()` into `ov::InferRequest::start_async()` and `ov::InferRequest::wait()` (or callbacks). For more information on synchronous and asynchronous modes, refer to the [OpenVINO Inference Request documentation](../OV_Runtime_UG/ov_infer_request.md).
+
+Although the synchronous API can be easier to start with, it is recommended to use the asynchronous (callbacks-based) API in production code. It is the most general and scalable way to implement the flow control for any possible number of requests. The `THROUGHPUT` and `LATENCY` performance hints automatically configure the Asynchronous pipeline to use the optimal number of processing streams and inference requests. 
+
+> **NOTE**: **Important:** Performance Hints only work when asynchronous execution mode is used. They do not affect the performance of a synchronous pipeline.
  
 ## Combining the Hints and Individual Low-Level Settings
 While sacrificing the portability to some extent, it is possible to combine the hints with individual device-specific settings. 
@@ -127,8 +130,8 @@ For example, use `ov::hint::PerformanceMode::THROUGHPUT` to prepare a general co
 The `benchmark_app`, that exists in both  [C++](../../samples/cpp/benchmark_app/README.md) and [Python](../../tools/benchmark_tool/README.md) versions, is the best way to evaluate the functionality of the performance hints for a particular device:
  - benchmark_app **-hint tput** -d 'device' -m 'path to your model'
  - benchmark_app **-hint latency** -d 'device' -m 'path to your model'
--  Disabling the hints to emulate the pre-hints era (highly recommended before trying the individual low-level settings, such as the number of streams as below, threads, etc):
-- - benchmark_app **-hint none -nstreams 1**  -d 'device' -m 'path to your model'
+- Disabling the hints to emulate the pre-hints era (highly recommended before trying the individual low-level settings, such as the number of streams as below, threads, etc):
+- benchmark_app **-hint none -nstreams 1**  -d 'device' -m 'path to your model'
  
 
 ### Additional Resources

docs/OV_Runtime_UG/supported_plugins/CPU.md

@@ -1,7 +1,6 @@
 # CPU Device {#openvino_docs_OV_UG_supported_plugins_CPU}
 
-The CPU plugin is a part of the Intel® Distribution of OpenVINO™ toolkit. It is developed to achieve high performance inference of neural networks on Intel® x86-64 CPUs.
-For an in-depth description of CPU plugin, see:
+The CPU plugin is a part of the Intel® Distribution of OpenVINO™ toolkit. It is developed to achieve high performance inference of neural networks on Intel® x86-64 CPUs.The newer 11th generation and later Intel® CPUs provide even further performance boost, especially with INT8 models.
 
 - [CPU plugin developers documentation](https://github.com/openvinotoolkit/openvino/wiki/CPUPluginDevelopersDocs).
 

docs/OV_Runtime_UG/supported_plugins/GPU.md

@@ -111,7 +111,7 @@ For more details on how to get a quantized model, refer to the [Model Optimizati
 
 Floating-point precision of a GPU primitive is selected based on operation precision in the OpenVINO IR, except for the [compressed f16 OpenVINO IR form](../../MO_DG/prepare_model/FP16_Compression.md), which is executed in the `f16` precision.
 
-> **NOTE**: Hardware acceleration for `i8`/`u8` precision may be unavailable on some platforms. In such cases, a model is executed in the floating-point precision taken from IR. Hardware support of `u8`/`i8` acceleration can be queried via the `ov::device::capabilities` property.
+> **NOTE**: The newer generation Intel Iris Xe and Xe MAX GPUs provide accelerated performance for i8/u8 models. Hardware acceleration for i8/u8 precision may be unavailable on older generation platforms. In such cases, a model is executed in the floating-point precision taken from IR. Hardware support of u8/i8 acceleration can be queried via the `ov::device::capabilities` property.
 
 [Hello Query Device C++ Sample](../../../samples/cpp/hello_query_device/README.md) can be used to print out the supported data types for all detected devices.
 

docs/OV_Runtime_UG/supported_plugins/MYRIAD.md

@@ -1,6 +1,9 @@
 # MYRIAD Device {#openvino_docs_OV_UG_supported_plugins_MYRIAD}
 
 
+
+
+
 The OpenVINO Runtime MYRIAD plugin has been developed for inference of neural networks on Intel® Neural Compute Stick 2.
 
 ## Configuring the MYRIAD Plugin

docs/OV_Runtime_UG/supported_plugins/Supported_Devices.md

@@ -1,7 +1,8 @@
 Supported Devices {#openvino_docs_OV_UG_supported_plugins_Supported_Devices}
 ==================
 
-The OpenVINO Runtime can infer models in different formats with various input and output formats. This section provides supported and optimal configurations per device. In OpenVINO™ documentation, "device" refers to an Intel® processors used for inference, which can be a supported CPU, GPU, VPU (vision processing unit), or GNA (Gaussian neural accelerator coprocessor), or a combination of those devices.
+The OpenVINO runtime can infer various models of different input and output formats. Here, you can find configurations 
+supported by OpenVINO devices, which are CPU, GPU, or GNA (Gaussian neural accelerator coprocessor). Currently, 11th generation and later processors (currently up to 13th generation) provide a further performance boost, especially with INT8 models.
 
 > **NOTE**: With OpenVINO™ 2020.4 release, Intel® Movidius™ Neural Compute Stick support has been cancelled.
 
@@ -11,13 +12,16 @@ The OpenVINO Runtime provides unique capabilities to infer deep learning models
 |------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
 |[GPU plugin](GPU.md)            |Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics                                                            |
 |[CPU plugin](CPU.md)              |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) |
-|[VPU plugins](VPU.md) (available in the Intel® Distribution of OpenVINO™ toolkit)            |Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X, Intel® Vision Accelerator Design with Intel® Movidius™ VPUs                                                                                           |
+|[VPU plugin](VPU.md) (available in the Intel® Distribution of OpenVINO™ toolkit)             |Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X, Intel® Vision Accelerator Design with Intel® Movidius™ VPUs                                                                                           |
 |[GNA plugin](GNA.md) (available in the Intel® Distribution of OpenVINO™ toolkit)              |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|
 |[Arm® CPU plugin](ARM_CPU.md) (unavailable in the Intel® Distribution of OpenVINO™ toolkit) |Raspberry Pi™ 4 Model B, Apple® Mac mini with M1 chip, NVIDIA® Jetson Nano™, Android™ devices    |
 |[Multi-Device execution](../multi_device.md) |Multi-Device execution enables simultaneous inference of the same model on several devices in parallel    |
 |[Auto-Device plugin](../auto_device_selection.md) |Auto-Device plugin enables selecting Intel® device for inference automatically |
 |[Heterogeneous plugin](../hetero_execution.md) |Heterogeneous execution enables automatic inference splitting between several devices (for example if a device doesn't [support certain operation](#supported-layers)).                                                           |
 
+
+
+
 > **NOTE**: ARM® CPU plugin is a community-level add-on to OpenVINO™. Intel® welcomes community participation in the OpenVINO™ ecosystem, technical questions and code contributions on community forums. However, this component has not undergone full release validation or qualification from Intel®, hence no official support is offered. 
 
 Devices similar to the ones we have used for benchmarking can be accessed using [Intel® DevCloud for the Edge](https://devcloud.intel.com/edge/), a remote development environment with access to Intel® hardware and the latest versions of the Intel® Distribution of the OpenVINO™ Toolkit. [Learn more](https://devcloud.intel.com/edge/get_started/devcloud/) or [Register here](https://inteliot.force.com/DevcloudForEdge/s/).

docs/OV_Runtime_UG/supported_plugins/VPU.md

@@ -11,6 +11,8 @@
     
 @endsphinxdirective
 
+
+
 This chapter provides information on the OpenVINO™ Runtime plugins that enable inference of deep learning models on the supported VPU devices:
 
 * Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X — Supported by the [MYRIAD Plugin](MYRIAD.md)

docs/_static/benchmarks_files/OV-benchmark-data.csv

@@ -1,5 +1,11 @@
-Network model,Release,IE-Type,Platform name,Throughput-INT8,Throughput-FP16,Throughput-FP32,Value,Efficiency,Price,TDP,Sockets,Price/socket,TDP/socket,Latency
+Network model,Release,IE-Type,Platform name,Throughput-INT8,Throughput-FP16,Throughput-FP32,Value,Efficiency,Price,TDP,Sockets,Price/socket,TDP/socket,Latency
 begin_rec,,,,,,,,,,,,,,
+bert-base-cased ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,163.72,,57.83,0.273,1.31,$599 ,125,1,$599 ,125,15.53
+bert-base-cased ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,56.07,,23.3,0.094,0.449,$599 ,125,1,$599 ,125,19.62
+bert-base-cased ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,210.17,,85.83,0.351,1.681,$599 ,125,1,$599 ,125,
+bert-base-cased ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,128.05,,45.94,0.389,1.024,$329 ,125,1,$329 ,125,12.71
+bert-base-cased ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,53.03,,21.9,0.161,0.424,$329 ,125,1,$329 ,125,20.81
+bert-base-cased ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,163.33,,64.74,0.496,1.307,$329 ,125,1,$329 ,125,
 bert-base-cased ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,96.06,,35.627,0.146,0.582,$658 ,165,1,$658 ,165,17.1432
 bert-base-cased ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,53.093,,22.253,0.081,0.322,$658 ,165,1,$658 ,165,22.0002
 bert-base-cased ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,108.306,,44.797,0.165,0.656,$658 ,165,1,$658 ,165,
@@ -19,15 +25,25 @@ bert-base-cased ,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,32.073
 bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,69.053,,40.243,0.116,0.552,$594 ,125,1,$594 ,125,18.309
 bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,23.402,,14.614,0.094,0.33,$249 ,71,1,$249 ,71,44.8984
 bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,266.949,,79.033,0.085,1.271,"$3,144 ",210,2,"$1,572 ",105,12.4065
-bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,2090.76,,326.55,0.292,4.646,"$7,166 ",450,2,"$3,583 ",225,4.61
+bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,2090.76,1372.2,1368.68,0.292,4.646,"$7,166 ",450,2,"$3,583 ",225,4.61
 bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,682.593,,225.713,0.04,1.665,"$16,954 ",410,2,"$8,477 ",205,6.9035
 bert-base-cased ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,256.994,,75.502,0.128,1.028,"$2,004 ",250,2,"$1,002 ",125,13.0382
 bert-base-cased ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,64.632,,18.394,0.138,2.308,$469 ,28,1,$469 ,28,17.638
 bert-base-cased ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,95.656,,44.056,0.204,3.416,$469 ,28,1,$469 ,28,14.1005
 bert-base-cased ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,128.005,,50.592,0.273,4.572,$469 ,28,1,$469 ,28,
 bert-base-cased ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,906.3,348.52,,0.471,6.042,"$1,925 ",150,1,"$1,925 ",150,7.381
+bert-base-cased ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,289.24,152.74,,,,,,1,,50,7.14
+bert-base-cased ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,343.57,180.89,,,,,,1,,75,6.64
+bert-base-cased ,OV-2022.3-8991,accel,Intel® Arc A750,993.22,1486.36,, 4.138 , 4.414 ,$240 ,225,1,$240 ,225,6.46
+bert-base-cased ,OV-2022.3-8991,accel,Intel® Arc A770,1088.69,1622.61,, 3.202 , 4.839 ,$340 ,225,1,$340 ,225,6.29
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,51.72,,17.6,0.086,0.414,$599 ,125,1,$599 ,125,49.13
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,19.05,,6.88,0.032,0.152,$599 ,125,1,$599 ,125,55.82
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,53,,19.95,0.088,0.424,$599 ,125,1,$599 ,125,
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,35.31,,11.04,0.107,0.282,$329 ,125,1,$329 ,125,41.56
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,17.93,,6.46,0.054,0.143,$329 ,125,1,$329 ,125,59.37
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,43.42,,16.19,0.132,0.347,$329 ,125,1,$329 ,125,
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,7.714,,3.093,0.012,0.047,$658 ,165,1,$658 ,165,155.3633
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,5.617,,1.978,0.009,0.034,$658 ,165,1,$658 ,165,181.8303
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,10.602,,3.753,0.016,0.064,$658 ,165,1,$658 ,165,
@@ -47,15 +63,25 @@ bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core,Intel® Co
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,4.801,,2.729,0.008,0.038,$594 ,125,1,$594 ,125,200.0794
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,2.098,,1.32,0.008,0.03,$249 ,71,1,$249 ,71,492.0938
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,21.062,,7.021,0.007,0.1,"$3,144 ",210,2,"$1,572 ",105,101.4694
-bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,651.95,,91.18,0.091,1.449,"$7,166 ",450,2,"$3,583 ",225,12.87
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,651.95,378.57,384.02,0.091,1.449,"$7,166 ",450,2,"$3,583 ",225,12.87
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,46.064,,19.051,0.003,0.112,"$16,954 ",410,2,"$8,477 ",205,49.4869
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,20.014,,6.726,0.01,0.08,"$2,004 ",250,2,"$1,002 ",125,105.9423
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,5.192,,1.626,0.011,0.185,$469 ,28,1,$469 ,28,203.6311
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,10.476,,3.914,0.022,0.374,$469 ,28,1,$469 ,28,95.6598
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,11.75,,4.168,0.025,0.42,$469 ,28,1,$469 ,28,
 bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,74.47,25.77,,0.039,0.496,"$1,925 ",150,1,"$1,925 ",150,19.768
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,74.01,44.31,,,,,,1,,50,17.89
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,92.53,53.04,,,,,,1,,75,15.77
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,accel,Intel® Arc A750,270.49,185.64,,1.127,1.202,$240 ,225,1,$240 ,225,14.36
+bert-large-uncased-whole-word-masking-squad-0001 ,OV-2022.3-8991,accel,Intel® Arc A770,337.47,205.46,,0.993,1.500,$340 ,225,1,$340 ,225,13.97
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+deeplabv3,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,184.93,,63.79,0.309,1.479,$599 ,125,1,$599 ,125,10.31
+deeplabv3,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,69.31,,22.67,0.116,0.554,$599 ,125,1,$599 ,125,15.02
+deeplabv3,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,191.48,,62.99,0.32,1.532,$599 ,125,1,$599 ,125,
+deeplabv3,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,139.02,,48.48,0.423,1.112,$329 ,125,1,$329 ,125,10.48
+deeplabv3,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,65.55,,21.24,0.199,0.524,$329 ,125,1,$329 ,125,16.12
+deeplabv3,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,154.19,,52.87,0.469,1.234,$329 ,125,1,$329 ,125,
 deeplabv3,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,99.078,,36.552,0.151,0.6,$658 ,165,1,$658 ,165,11.269
 deeplabv3,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,57.707,,13.789,0.088,0.35,$658 ,165,1,$658 ,165,16.263
 deeplabv3,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,115.59,,39.82,0.176,0.701,$658 ,165,1,$658 ,165,
@@ -75,15 +101,25 @@ deeplabv3,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,36.559,,18.23
 deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,79.42,,21.03,0.134,0.635,$594 ,125,1,$594 ,125,12.8397
 deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,26.173,,16.906,0.105,0.369,$249 ,71,1,$249 ,71,37.9245
 deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,248.049,,81.667,0.079,1.181,"$3,144 ",210,2,"$1,572 ",105,8.9485
-deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,1139.5,,271.62,0.159,2.532,"$7,166 ",450,2,"$3,583 ",225,2.47
+deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,1139.5,702.28,699.04,0.159,2.532,"$7,166 ",450,2,"$3,583 ",225,2.47
 deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,632.113,,168.65,0.037,1.542,"$16,954 ",410,2,"$8,477 ",205,4.0073
 deeplabv3,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,241.703,,78.963,0.121,0.967,"$2,004 ",250,2,"$1,002 ",125,9.356
 deeplabv3,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,64.13,,18.519,0.137,2.29,$469 ,28,1,$469 ,28,16.6586
 deeplabv3,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,104.926,,24.592,0.224,3.747,$469 ,28,1,$469 ,28,9.1435
 deeplabv3,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,121.441,,30.498,0.259,4.337,$469 ,28,1,$469 ,28,
 deeplabv3,OV-2022.3-8991,accel,Intel® Flex-170 GPU,882.04,98.95,,0.458,5.88,"$1,925 ",150,1,"$1,925 ",150,2.674
+deeplabv3,OV-2022.3-8991,accel,Intel® Arc A40 Pro,246.48,197.01,,,,,,1,,50,4.8
+deeplabv3,OV-2022.3-8991,accel,Intel® Arc A50 Pro,281.31,221.77,,,,,,1,,75,4.74
+deeplabv3,OV-2022.3-8991,accel,Intel® Arc A750,813.12,626.48,,3.388,3.614,$240 ,225,1,$240 ,225,1.9
+deeplabv3,OV-2022.3-8991,accel,Intel® Arc A770,763.91,595.5,,2.247,3.395,$340 ,225,1,$340 ,225,1.83
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+densenet-121,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,777.86,,284.56,1.299,6.223,$599 ,125,1,$599 ,125,3.26
+densenet-121,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,195.3,,66.46,0.326,1.562,$599 ,125,1,$599 ,125,6.8
+densenet-121,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,899.5,,293.29,1.502,7.196,$599 ,125,1,$599 ,125,
+densenet-121,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,612.99,,184.9,1.863,4.904,$329 ,125,1,$329 ,125,3.12
+densenet-121,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,178.37,,62.69,0.542,1.427,$329 ,125,1,$329 ,125,8.37
+densenet-121,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,707.99,,207.12,2.152,5.664,$329 ,125,1,$329 ,125,
 densenet-121,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,457.193,,165.166,0.695,2.771,$658 ,165,1,$658 ,165,3.141
 densenet-121,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,203.417,,68.438,0.309,1.233,$658 ,165,1,$658 ,165,6.6728
 densenet-121,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,575.442,,179.858,0.875,3.488,$658 ,165,1,$658 ,165,
@@ -103,15 +139,25 @@ densenet-121,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,146.463,,6
 densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,360.501,,182.543,0.607,2.884,$594 ,125,1,$594 ,125,3.6046
 densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,114.844,,67.188,0.461,1.618,$249 ,71,1,$249 ,71,9.7609
 densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,1116.372,,295.952,0.355,5.316,"$3,144 ",210,2,"$1,572 ",105,3.9606
-densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,8279.14,,1137.41,1.155,18.398,"$7,166 ",450,2,"$3,583 ",225,2.39
+densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,8279.14,4856.54,4862.51,1.155,18.398,"$7,166 ",450,2,"$3,583 ",225,2.39
 densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,3155.106,,815.725,0.186,7.695,"$16,954 ",410,2,"$8,477 ",205,2.8831
 densenet-121,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,1064.824,,283.423,0.531,4.259,"$2,004 ",250,2,"$1,002 ",125,4.0689
 densenet-121,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,265.167,,74.501,0.565,9.47,$469 ,28,1,$469 ,28,4.7413
 densenet-121,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,391.185,,123.519,0.834,13.971,$469 ,28,1,$469 ,28,6.5259
 densenet-121,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,526.12,,150.35,1.122,18.79,$469 ,28,1,$469 ,28,
 densenet-121,OV-2022.3-8991,accel,Intel® Flex-170 GPU,3440.18,1178.68,,1.787,22.935,"$1,925 ",150,1,"$1,925 ",150,3.302
+densenet-121,OV-2022.3-8991,accel,Intel® Arc A40 Pro,779.8,650.48,,,,,,1,,50,2.97
+densenet-121,OV-2022.3-8991,accel,Intel® Arc A50 Pro,817.69,637.04,,,,,,1,,75,3.06
+densenet-121,OV-2022.3-8991,accel,Intel® Arc A750,2022.98,1666.6,,8.429,8.991,$240 ,225,1,$240 ,225,2.56
+densenet-121,OV-2022.3-8991,accel,Intel® Arc A770,2076.41,1647.41,,6.107,9.228,$340 ,225,1,$340 ,225,2.56
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+efficientdet-d0,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,209.26,,106.11,0.349,1.674,$599 ,125,1,$599 ,125,10.36
+efficientdet-d0,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,82.04,,47.85,0.137,0.656,$599 ,125,1,$599 ,125,22.35
+efficientdet-d0,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,197.85,,108.3,0.33,1.583,$599 ,125,1,$599 ,125,
+efficientdet-d0,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,155.65,,90.91,0.473,1.245,$329 ,125,1,$329 ,125,9.92
+efficientdet-d0,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,77.28,,44.91,0.235,0.618,$329 ,125,1,$329 ,125,22.93
+efficientdet-d0,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,172.54,,95.94,0.524,1.38,$329 ,125,1,$329 ,125,
 efficientdet-d0,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,112.297,,64.06,0.171,0.681,$658 ,165,1,$658 ,165,11.8265
 efficientdet-d0,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,73.766,,38.742,0.112,0.447,$658 ,165,1,$658 ,165,21.403
 efficientdet-d0,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,128.735,,76.62,0.196,0.78,$658 ,165,1,$658 ,165,
@@ -131,15 +177,25 @@ efficientdet-d0,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,50.35,,
 efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,94.981,,36.434,0.16,0.76,$594 ,125,1,$594 ,125,12.658
 efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,35.831,,27.306,0.144,0.505,$249 ,71,1,$249 ,71,30.9469
 efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,239.06,,161.224,0.076,1.138,"$3,144 ",210,2,"$1,572 ",105,13.9735
-efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,875.53,,560.48,0.122,1.946,"$7,166 ",450,2,"$3,583 ",225,5.07
+efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,875.53,495.04,492.93,0.122,1.946,"$7,166 ",450,2,"$3,583 ",225,5.07
 efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,471.02,,300.291,0.028,1.149,"$16,954 ",410,2,"$8,477 ",205,9.3866
 efficientdet-d0,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,231.873,,156.285,0.116,0.927,"$2,004 ",250,2,"$1,002 ",125,14.1605
 efficientdet-d0,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,71.482,,41.123,0.152,2.553,$469 ,28,1,$469 ,28,16.6952
 efficientdet-d0,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,92.52,,50.538,0.197,3.304,$469 ,28,1,$469 ,28,17.295
 efficientdet-d0,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,107.688,,56.901,0.23,3.846,$469 ,28,1,$469 ,28,
 efficientdet-d0,OV-2022.3-8991,accel,Intel® Flex-170 GPU,463.67,295.13,,0.241,3.091,"$1,925 ",150,1,"$1,925 ",150,5.603
+efficientdet-d0,OV-2022.3-8991,accel,Intel® Arc A40 Pro,106.04,142.82,,,,,,1,,50,12.31
+efficientdet-d0,OV-2022.3-8991,accel,Intel® Arc A50 Pro,110.64,142.38,,,,,,1,,75,11.98
+efficientdet-d0,OV-2022.3-8991,accel,Intel® Arc A750,496.2,672.57,,2.068,2.205,$240 ,225,1,$240 ,225,5.17
+efficientdet-d0,OV-2022.3-8991,accel,Intel® Arc A770,497.52,680.16,,1.463,2.211,$340 ,225,1,$340 ,225,5.03
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+faster_rcnn_resnet50_coco,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,5.94,,2.41,0.01,0.048,$599 ,125,1,$599 ,125,270.57
+faster_rcnn_resnet50_coco,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,2.3,,0.71,0.004,0.018,$599 ,125,1,$599 ,125,437.94
+faster_rcnn_resnet50_coco,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,6.45,,2.25,0.011,0.052,$599 ,125,1,$599 ,125,
+faster_rcnn_resnet50_coco,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,4.55,,1.88,0.014,0.036,$329 ,125,1,$329 ,125,310.58
+faster_rcnn_resnet50_coco,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,2.17,,0.67,0.007,0.017,$329 ,125,1,$329 ,125,465.03
+faster_rcnn_resnet50_coco,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,5.3,,2.01,0.016,0.042,$329 ,125,1,$329 ,125,
 faster_rcnn_resnet50_coco,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,12.921,,4.016,0.02,0.078,$658 ,165,1,$658 ,165,89.8929
 faster_rcnn_resnet50_coco,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,6.802,,1.82,0.01,0.041,$658 ,165,1,$658 ,165,149.7396
 faster_rcnn_resnet50_coco,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,15.679,,4.499,0.024,0.095,$658 ,165,1,$658 ,165,
@@ -159,15 +215,25 @@ faster_rcnn_resnet50_coco,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-on
 faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,8.977,,4.542,0.015,0.072,$594 ,125,1,$594 ,125,137.1747
 faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,2.867,,1.464,0.012,0.04,$249 ,71,1,$249 ,71,353.2042
 faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,29.332,,8.19,0.009,0.14,"$3,144 ",210,2,"$1,572 ",105,78.1722
-faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,282.45,,32.43,0.003,0.044,"$7,166 ",450,2,"$3,583 ",225,12.03
+faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,19.71,18.01,18.15,0.003,0.044,"$7,166 ",450,2,"$3,583 ",225,129.2
 faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,85.213,,22.066,0.005,0.208,"$16,954 ",410,2,"$8,477 ",205,30.4317
 faster_rcnn_resnet50_coco,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,27.847,,7.786,0.014,0.111,"$2,004 ",250,2,"$1,002 ",125,78.6604
 faster_rcnn_resnet50_coco,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,7.027,,1.855,0.015,0.251,$469 ,28,1,$469 ,28,151.8783
 faster_rcnn_resnet50_coco,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,13.823,,3.545,0.029,0.494,$469 ,28,1,$469 ,28,70.7933
 faster_rcnn_resnet50_coco,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,16.898,,4.191,0.036,0.604,$469 ,28,1,$469 ,28,
 faster_rcnn_resnet50_coco,OV-2022.3-8991,accel,Intel® Flex-170 GPU,216.3,23.42,,0.112,1.442,"$1,925 ",150,1,"$1,925 ",150,9.137
+faster_rcnn_resnet50_coco,OV-2022.3-8991,accel,Intel® Arc A40 Pro,9.24,7.38,,,,,,1,,50,110.7
+faster_rcnn_resnet50_coco,OV-2022.3-8991,accel,Intel® Arc A50 Pro,10.67,8.36,,,,,,1,,75,96.79
+faster_rcnn_resnet50_coco,OV-2022.3-8991,accel,Intel® Arc A750,37.58,27.13,,0.157,0.167,$240 ,225,1,$240 ,225,29.08
+faster_rcnn_resnet50_coco,OV-2022.3-8991,accel,Intel® Arc A770,38.19,27.28,,0.112,0.170,$340 ,225,1,$340 ,225,28.46
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+Inception-V4,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,219.06,,71.15,0.366,1.752,$599 ,125,1,$599 ,125,10.19
+Inception-V4,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,65.91,,18.1,0.11,0.527,$599 ,125,1,$599 ,125,16.55
+Inception-V4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,279.58,,78.65,0.467,2.237,$599 ,125,1,$599 ,125,
+Inception-V4,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,171.19,,45.8,0.52,1.37,$329 ,125,1,$329 ,125,9.14
+Inception-V4,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,62.45,,17.02,0.19,0.5,$329 ,125,1,$329 ,125,17.48
+Inception-V4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,219.02,,52.56,0.666,1.752,$329 ,125,1,$329 ,125,
 Inception-V4,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,121.813,,39.391,0.185,0.738,$658 ,165,1,$658 ,165,11.0425
 Inception-V4,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,71.229,,17.755,0.108,0.432,$658 ,165,1,$658 ,165,19.7132
 Inception-V4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,175.049,,44.894,0.266,1.061,$658 ,165,1,$658 ,165,
@@ -187,15 +253,25 @@ Inception-V4,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,37.301,,19
 Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,92.646,,44.966,0.156,0.741,$594 ,125,1,$594 ,125,12.3153
 Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,28.537,,15.13,0.115,0.402,$249 ,71,1,$249 ,71,36.8888
 Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,301.215,,77.005,0.096,1.434,"$3,144 ",210,2,"$1,572 ",105,10.5711
-Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,3406.7,,331.56,0.475,7.57,"$7,166 ",450,2,"$3,583 ",225,3.23
+Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,3406.7,1879.09,1867.99,0.475,7.57,"$7,166 ",450,2,"$3,583 ",225,3.23
 Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,937.139,,225.776,0.055,2.286,"$16,954 ",410,2,"$8,477 ",205,5.6984
 Inception-V4,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,287.767,,73.617,0.144,1.151,"$2,004 ",250,2,"$1,002 ",125,11.1114
 Inception-V4,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,71.295,,18.482,0.152,2.546,$469 ,28,1,$469 ,28,15.8294
 Inception-V4,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,158.282,,36.884,0.337,5.653,$469 ,28,1,$469 ,28,10.6245
 Inception-V4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,182.132,,44.198,0.388,6.505,$469 ,28,1,$469 ,28,
 Inception-V4,OV-2022.3-8991,accel,Intel® Flex-170 GPU,2986.91,298.6,,1.552,19.913,"$1,925 ",150,1,"$1,925 ",150,3.968
+Inception-V4,OV-2022.3-8991,accel,Intel® Arc A40 Pro,766.04,436.51,,,,,,1,,50,5.7
+Inception-V4,OV-2022.3-8991,accel,Intel® Arc A50 Pro,877.68,495.62,,,,,,1,,75,5.88
+Inception-V4,OV-2022.3-8991,accel,Intel® Arc A750,3259.61,1855.9,,13.582,14.487,$240 ,225,1,$240 ,225,3.75
+Inception-V4,OV-2022.3-8991,accel,Intel® Arc A770,3417.37,2025.25,,10.051,15.188,$340 ,225,1,$340 ,225,3.56
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+mobilenet-ssd ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,1754.44,,664.82,2.929,14.036,$599 ,125,1,$599 ,125,1.4
+mobilenet-ssd ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,528.03,,168.57,0.882,4.224,$599 ,125,1,$599 ,125,2.35
+mobilenet-ssd ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,1568.83,,665.79,2.619,12.551,$599 ,125,1,$599 ,125,
+mobilenet-ssd ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,1240.01,,437.11,3.769,9.92,$329 ,125,1,$329 ,125,1.47
+mobilenet-ssd ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,493.18,,157.94,1.499,3.945,$329 ,125,1,$329 ,125,2.43
+mobilenet-ssd ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,1063.27,,454.21,3.232,8.506,$329 ,125,1,$329 ,125,
 mobilenet-ssd ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,1054.462,,346.546,1.603,6.391,$658 ,165,1,$658 ,165,1.4898
 mobilenet-ssd ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,493.088,,145.503,0.749,2.988,$658 ,165,1,$658 ,165,2.472
 mobilenet-ssd ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,1056.241,,361.472,1.605,6.401,$658 ,165,1,$658 ,165,
@@ -215,15 +291,25 @@ mobilenet-ssd ,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,315.107,
 mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,774.346,,345.309,1.304,6.195,$594 ,125,1,$594 ,125,1.5452
 mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,233.43,,147.098,0.937,3.288,$249 ,71,1,$249 ,71,4.5879
 mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,2331.207,,691.743,0.741,11.101,"$3,144 ",210,2,"$1,572 ",105,1.4852
-mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,16445.75,,2736.2,2.295,36.546,"$7,166 ",450,2,"$3,583 ",225,0.65
+mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,16445.75,8733.64,8626.42,2.295,36.546,"$7,166 ",450,2,"$3,583 ",225,0.65
 mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,6691.915,,1796.357,0.395,16.322,"$16,954 ",410,2,"$8,477 ",205,1.0518
 mobilenet-ssd ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,2225.935,,667.692,1.111,8.904,"$2,004 ",250,2,"$1,002 ",125,1.5444
 mobilenet-ssd ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,579.307,,166.959,1.235,20.69,$469 ,28,1,$469 ,28,2.0215
 mobilenet-ssd ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,582.636,,243.945,1.242,20.808,$469 ,28,1,$469 ,28,2.548
 mobilenet-ssd ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,744.231,,292.071,1.587,26.58,$469 ,28,1,$469 ,28,
 mobilenet-ssd ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,3548.98,1412.68,,1.844,23.66,"$1,925 ",150,1,"$1,925 ",150,1.344
+mobilenet-ssd ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,2676.23,1939.24,,,,,,1,,50,0.95
+mobilenet-ssd ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,2874.1,1945.48,,,,,,1,,75,0.98
+mobilenet-ssd ,OV-2022.3-8991,accel,Intel® Arc A750,6510.01,5188.87,,27.125,28.933,$240 ,225,1,$240 ,225,0.79
+mobilenet-ssd ,OV-2022.3-8991,accel,Intel® Arc A770,6717.52,5312.93,,19.757,29.856,$340 ,225,1,$340 ,225,0.76
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+mobilenet-v2 ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,4041.77,,2123.33,6.748,32.334,$599 ,125,1,$599 ,125,0.66
+mobilenet-v2 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,978.61,,424.34,1.634,7.829,$599 ,125,1,$599 ,125,1.21
+mobilenet-v2 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,4630.44,,1944.62,7.73,37.044,$599 ,125,1,$599 ,125,
+mobilenet-v2 ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,3306.92,,1403.57,10.051,26.455,$329 ,125,1,$329 ,125,0.65
+mobilenet-v2 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,919.85,,384.42,2.796,7.359,$329 ,125,1,$329 ,125,1.36
+mobilenet-v2 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,3556.06,,1332.32,10.809,28.448,$329 ,125,1,$329 ,125,
 mobilenet-v2 ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,2446.221,,1003.129,3.718,14.826,$658 ,165,1,$658 ,165,0.7182
 mobilenet-v2 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,1265.969,,389.894,1.924,7.673,$658 ,165,1,$658 ,165,1.3894
 mobilenet-v2 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,2680.458,,1013.049,4.074,16.245,$658 ,165,1,$658 ,165,
@@ -243,15 +329,25 @@ mobilenet-v2 ,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,825.071,,
 mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,2067.162,,868.25,3.48,16.537,$594 ,125,1,$594 ,125,0.7363
 mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,594.283,,479.567,2.387,8.37,$249 ,71,1,$249 ,71,1.8531
 mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,5882.455,,1895.498,1.871,28.012,"$3,144 ",210,2,"$1,572 ",105,1.3871
-mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,28383.76,,7254.28,3.961,63.075,"$7,166 ",450,2,"$3,583 ",225,0.55
+mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,28383.76,16212.74,16065.38,3.961,63.075,"$7,166 ",450,2,"$3,583 ",225,0.55
 mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,15616.083,,4308.927,0.921,38.088,"$16,954 ",410,2,"$8,477 ",205,0.8685
 mobilenet-v2 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,5616.283,,1835.686,2.803,22.465,"$2,004 ",250,2,"$1,002 ",125,1.404
 mobilenet-v2 ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,1463.21,,538.597,3.12,52.258,$469 ,28,1,$469 ,28,0.8864
 mobilenet-v2 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,2076.015,,544.641,4.426,74.143,$469 ,28,1,$469 ,28,1.7212
 mobilenet-v2 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,2677.374,,698.942,5.709,95.621,$469 ,28,1,$469 ,28,
 mobilenet-v2 ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,18371.95,4738.33,,9.544,122.48,"$1,925 ",150,1,"$1,925 ",150,1.15
+mobilenet-v2 ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,,,,,,,,1,,50,
+mobilenet-v2 ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,,,,,,,,1,,75,
+mobilenet-v2 ,OV-2022.3-8991,accel,Intel® Arc A750,,,,$0 ,0,$240 ,225,1,$240 ,225,
+mobilenet-v2 ,OV-2022.3-8991,accel,Intel® Arc A770,,,,$0 ,0,$340 ,225,1,$340 ,225,
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+resnet-18 ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,1495.77,,415.82,2.497,11.966,$599 ,125,1,$599 ,125,1.38
+resnet-18 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,497.54,,150.99,0.831,3.98,$599 ,125,1,$599 ,125,2.19
+resnet-18 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,1821.4,,615.14,3.041,14.571,$599 ,125,1,$599 ,125,
+resnet-18 ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,1169.04,,336.09,3.553,9.352,$329 ,125,1,$329 ,125,1.5
+resnet-18 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,467.43,,141.76,1.421,3.739,$329 ,125,1,$329 ,125,2.36
+resnet-18 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,1443.42,,445.25,4.387,11.547,$329 ,125,1,$329 ,125,
 resnet-18 ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,804.771,,212.574,1.223,4.877,$658 ,165,1,$658 ,165,1.3886
 resnet-18 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,491.337,,146.839,0.747,2.978,$658 ,165,1,$658 ,165,2.2655
 resnet-18 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,1180.984,,365.777,1.795,7.157,$658 ,165,1,$658 ,165,
@@ -271,15 +367,25 @@ resnet-18 ,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,265.351,,130
 resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,654.533,,307.741,1.102,5.236,$594 ,125,1,$594 ,125,1.6723
 resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,198.189,,101.399,0.796,2.791,$249 ,71,1,$249 ,71,5.2039
 resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,2017.368,,547.47,0.642,9.607,"$3,144 ",210,2,"$1,572 ",105,1.2913
-resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,27331.02,,2329.12,3.814,60.736,"$7,166 ",450,2,"$3,583 ",225,0.38
+resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,27331.02,16095.24,16009.04,3.814,60.736,"$7,166 ",450,2,"$3,583 ",225,0.38
 resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,6320.391,,1582.817,0.373,15.416,"$16,954 ",410,2,"$8,477 ",205,0.667
 resnet-18 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,1940.935,,522.654,0.969,7.764,"$2,004 ",250,2,"$1,002 ",125,1.3451
 resnet-18 ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,480.992,,126.244,1.026,17.178,$469 ,28,1,$469 ,28,2.242
 resnet-18 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,1061.591,,297.705,2.264,37.914,$469 ,28,1,$469 ,28,1.793
 resnet-18 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,1237.94,,342.513,2.64,44.212,$469 ,28,1,$469 ,28,
 resnet-18 ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,27454.08,2264.67,,14.262,183.027,"$1,925 ",150,1,"$1,925 ",150,0.946
+resnet-18 ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,6911.91,3812.93,,,,,,1,,50,0.69
+resnet-18 ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,8440.86,4691.2,,,,,,1,,75,0.7
+resnet-18 ,OV-2022.3-8991,accel,Intel® Arc A750,31437.04,17244.34,,130.988,139.720,$240 ,225,1,$240 ,225,0.54
+resnet-18 ,OV-2022.3-8991,accel,Intel® Arc A770,35554.47,19135.31,,104.572,158.020,$340 ,225,1,$340 ,225,0.54
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+resnet-50,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,729.93,,240.59,1.219,5.839,$599 ,125,1,$599 ,125,2.91
+resnet-50,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,238.44,,68.18,0.398,1.908,$599 ,125,1,$599 ,125,4.74
+resnet-50,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,895.28,,255.91,1.495,7.162,$599 ,125,1,$599 ,125,
+resnet-50,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,576.86,,153.71,1.753,4.615,$329 ,125,1,$329 ,125,3.04
+resnet-50,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,216.97,,64.36,0.659,1.736,$329 ,125,1,$329 ,125,5.3
+resnet-50,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,717.91,,188.59,2.182,5.743,$329 ,125,1,$329 ,125,
 resnet-50,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,400.118,,133.834,0.608,2.425,$658 ,165,1,$658 ,165,3.0384
 resnet-50,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,229.863,,66.122,0.349,1.393,$658 ,165,1,$658 ,165,5.2538
 resnet-50,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,574.341,,155.749,0.873,3.481,$658 ,165,1,$658 ,165,
@@ -300,14 +406,24 @@ resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,317.744,,149.441,0
 resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,97.606,,52.17,0.392,1.375,$249 ,71,1,$249 ,71,10.851
 resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,980.813,,268.009,0.312,4.671,"$3,144 ",210,2,"$1,572 ",105,2.9838
 resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,2905.803,,748.583,0.405,6.457,"$7,166 ",450,2,"$3,583 ",225,1.475
-resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,11359.88,,1118.97,0.67,27.707,"$16,954 ",410,2,"$8,477 ",205,0.94
+resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,11359.88,5494.15,5497.22,0.67,27.707,"$16,954 ",410,2,"$8,477 ",205,0.94
 resnet-50,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,937.572,,255.866,0.468,3.75,"$2,004 ",250,2,"$1,002 ",125,3.0985
 resnet-50,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,235.061,,63.241,0.501,8.395,$469 ,28,1,$469 ,28,4.7975
-resnet-50,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,235.061,,63.241,0.501,8.395,$469 ,28,1,$469 ,28,4.7975
-resnet-50,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,235.061,,63.241,0.501,8.395,$469 ,28,1,$469 ,28,4.7975
+resnet-50,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,504.247,,125.407,1.075,18.009,$469 ,28,1,$469 ,28,4.7975
+resnet-50,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,595.133,,150.024,1.269,21.255,$469 ,28,1,$469 ,28,4.7975
 resnet-50,OV-2022.3-8991,accel,Intel® Flex-170 GPU,10810.92,1005.16,,5.616,72.073,"$1,925 ",150,1,"$1,925 ",150,1.624
+resnet-50,OV-2022.3-8991,accel,Intel® Arc A40 Pro,2831.48,1628.15,,,,,,1,,50,1.28
+resnet-50,OV-2022.3-8991,accel,Intel® Arc A50 Pro,3233.61,1812.84,,,,,,1,,75,1.3
+resnet-50,OV-2022.3-8991,accel,Intel® Arc A750,11449.86,6590.86,,47.708,50.888,$240 ,225,1,$240 ,225,1.03
+resnet-50,OV-2022.3-8991,accel,Intel® Arc A770,12512.67,6958.31,,36.802,55.612,$340 ,225,1,$340 ,225,0.98
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+ssd-resnet34-1200 ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,11.75,,4.24,0.02,0.094,$599 ,125,1,$599 ,125,162.07
+ssd-resnet34-1200 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,4.5,,1.45,0.008,0.036,$599 ,125,1,$599 ,125,226.99
+ssd-resnet34-1200 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,11.63,,4.24,0.019,0.093,$599 ,125,1,$599 ,125,
+ssd-resnet34-1200 ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,8.21,,2.7,0.025,0.066,$329 ,125,1,$329 ,125,147.53
+ssd-resnet34-1200 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,4.22,,1.36,0.013,0.034,$329 ,125,1,$329 ,125,241.92
+ssd-resnet34-1200 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,8,,2.7,0.024,0.064,$329 ,125,1,$329 ,125,
 ssd-resnet34-1200 ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,6.712,,2.394,0.01,0.041,$658 ,165,1,$658 ,165,175.7493
 ssd-resnet34-1200 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,4.228,,1.262,0.006,0.026,$658 ,165,1,$658 ,165,241.7838
 ssd-resnet34-1200 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,6.666,,2.393,0.01,0.04,$658 ,165,1,$658 ,165,
@@ -327,15 +443,25 @@ ssd-resnet34-1200 ,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,2.04
 ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,4.871,,2.935,0.008,0.039,$594 ,125,1,$594 ,125,239.8346
 ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,1.55,,0.919,0.006,0.022,$249 ,71,1,$249 ,71,665.2714
 ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,15.706,,4.572,0.005,0.075,"$3,144 ",210,2,"$1,572 ",105,132.0319
-ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,152.74,,20.32,0.021,0.339,"$7,166 ",450,2,"$3,583 ",225,14.48
+ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,152.74,144.16,144.02,0.021,0.339,"$7,166 ",450,2,"$3,583 ",225,14.48
 ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,47.365,,14.722,0.003,0.116,"$16,954 ",410,2,"$8,477 ",205,44.387
 ssd-resnet34-1200 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,14.966,,4.35,0.007,0.06,"$2,004 ",250,2,"$1,002 ",125,138.9625
 ssd-resnet34-1200 ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,3.556,,1.015,0.008,0.127,$469 ,28,1,$469 ,28,284.2379
 ssd-resnet34-1200 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,8.239,,2.545,0.018,0.294,$469 ,28,1,$469 ,28,122.4561
 ssd-resnet34-1200 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,3.565,,1.01,0.008,0.127,$469 ,28,1,$469 ,28,
 ssd-resnet34-1200 ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,132.44,18.19,,0.069,0.883,"$1,925 ",150,1,"$1,925 ",150,19.933
+ssd-resnet34-1200 ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,35.75,24.28,,,,,,1,,50,33.83
+ssd-resnet34-1200 ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,44.01,31.32,,,,,,1,,75,29.62
+ssd-resnet34-1200 ,OV-2022.3-8991,accel,Intel® Arc A750,136.84,107.27,,0.570,0.608,$240 ,225,1,$240 ,225,18.81
+ssd-resnet34-1200 ,OV-2022.3-8991,accel,Intel® Arc A770,153.43,116.15,,0.451,0.682,$340 ,225,1,$340 ,225,19.88
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+unet-camvid--0001 ,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,18.79,,6.86,0.031,0.15,$599 ,125,1,$599 ,125,99.01
+unet-camvid--0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,7.59,,2.3,0.013,0.061,$599 ,125,1,$599 ,125,132.32
+unet-camvid--0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,18.14,,7,0.03,0.145,$599 ,125,1,$599 ,125,
+unet-camvid--0001 ,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,12.91,,4.36,0.039,0.103,$329 ,125,1,$329 ,125,95.92
+unet-camvid--0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,7.13,,2.16,0.022,0.057,$329 ,125,1,$329 ,125,140.88
+unet-camvid--0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,16.63,,5.72,0.051,0.133,$329 ,125,1,$329 ,125,
 unet-camvid--0001 ,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,10.652,,3.873,0.016,0.065,$658 ,165,1,$658 ,165,111.0757
 unet-camvid--0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,7.059,,2.154,0.011,0.043,$658 ,165,1,$658 ,165,142.0745
 unet-camvid--0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,14.933,,4.935,0.023,0.091,$658 ,165,1,$658 ,165,
@@ -355,15 +481,25 @@ unet-camvid--0001 ,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,2.90
 unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,7.413,,4.615,0.012,0.059,$594 ,125,1,$594 ,125,157.3622
 unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,2.386,,1.481,0.01,0.034,$249 ,71,1,$249 ,71,422.1157
 unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,29.251,,7.301,0.009,0.139,"$3,144 ",210,2,"$1,572 ",105,69.3596
-unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,381.85,,30.96,0.053,0.849,"$7,166 ",450,2,"$3,583 ",225,7.95
+unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,381.85,151.97,151.98,0.053,0.849,"$7,166 ",450,2,"$3,583 ",225,7.95
 unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,93.081,,21.382,0.005,0.227,"$16,954 ",410,2,"$8,477 ",205,22.9476
 unet-camvid--0001 ,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,27.814,,6.966,0.014,0.111,"$2,004 ",250,2,"$1,002 ",125,72.9773
 unet-camvid--0001 ,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,6.54,,1.677,0.014,0.234,$469 ,28,1,$469 ,28,152.602
 unet-camvid--0001 ,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,15.391,,4.571,0.033,0.55,$469 ,28,1,$469 ,28,61.6002
 unet-camvid--0001 ,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,17.962,,4.848,0.038,0.642,$469 ,28,1,$469 ,28,
 unet-camvid--0001 ,OV-2022.3-8991,accel,Intel® Flex-170 GPU,218.12,35.2,,0.113,1.454,"$1,925 ",150,1,"$1,925 ",150,7.149
+unet-camvid--0001 ,OV-2022.3-8991,accel,Intel® Arc A40 Pro,51.45,33.45,,,,,,1,,50,
+unet-camvid--0001 ,OV-2022.3-8991,accel,Intel® Arc A50 Pro,61.08,40.36,,,,,,1,,75,
+unet-camvid--0001 ,OV-2022.3-8991,accel,Intel® Arc A750,212.93,151.71,,0.887,0.946,$240 ,225,1,$240 ,225,6.27
+unet-camvid--0001 ,OV-2022.3-8991,accel,Intel® Arc A770,246.87,165.05,,0.726,1.097,$340 ,225,1,$340 ,225,5.66
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+yolo_v3_tiny,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,802.63,,252.57,1.34,6.421,$599 ,125,1,$599 ,125,2.69
+yolo_v3_tiny,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,249.5,,86.81,0.417,1.996,$599 ,125,1,$599 ,125,4.79
+yolo_v3_tiny,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,795.31,,247.17,1.328,6.362,$599 ,125,1,$599 ,125,
+yolo_v3_tiny,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,638.25,,206.62,1.94,5.106,$329 ,125,1,$329 ,125,2.59
+yolo_v3_tiny,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,229.22,,81.49,0.697,1.834,$329 ,125,1,$329 ,125,5.22
+yolo_v3_tiny,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,631.71,,205.81,1.92,5.054,$329 ,125,1,$329 ,125,
 yolo_v3_tiny,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,428.506,,162.077,0.651,2.597,$658 ,165,1,$658 ,165,2.4778
 yolo_v3_tiny,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,245.738,,84.457,0.373,1.489,$658 ,165,1,$658 ,165,3.8792
 yolo_v3_tiny,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,598.947,,195.608,0.91,3.63,$658 ,165,1,$658 ,165,
@@ -383,15 +519,25 @@ yolo_v3_tiny,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,147.041,,8
 yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,359.61,,173.635,0.605,2.877,$594 ,125,1,$594 ,125,2.9037
 yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,109.066,,64.87,0.438,1.536,$249 ,71,1,$249 ,71,9.3792
 yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,1058.322,,337.035,0.337,5.04,"$3,144 ",210,2,"$1,572 ",105,2.4971
-yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,7344.88,,1405.51,1.025,16.322,"$7,166 ",450,2,"$3,583 ",225,1.06
+yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,7344.88,5212.9,5236.28,1.025,16.322,"$7,166 ",450,2,"$3,583 ",225,1.06
 yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,2931.242,,901.832,0.173,7.149,"$16,954 ",410,2,"$8,477 ",205,1.215
 yolo_v3_tiny,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,1015.77,,321.263,0.507,4.063,"$2,004 ",250,2,"$1,002 ",125,2.6076
 yolo_v3_tiny,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,258.05,,79.963,0.55,9.216,$469 ,28,1,$469 ,28,4.1833
 yolo_v3_tiny,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,492.645,,157.98,1.05,17.594,$469 ,28,1,$469 ,28,2.5788
 yolo_v3_tiny,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,606.117,,186.339,1.292,21.647,$469 ,28,1,$469 ,28,
 yolo_v3_tiny,OV-2022.3-8991,accel,Intel® Flex-170 GPU,3634.16,1209.67,,1.888,24.228,"$1,925 ",150,1,"$1,925 ",150,1.293
+yolo_v3_tiny,OV-2022.3-8991,accel,Intel® Arc A40 Pro,,,,,,,,1,,50,
+yolo_v3_tiny,OV-2022.3-8991,accel,Intel® Arc A50 Pro,,,,,,,,1,,75,
+yolo_v3_tiny,OV-2022.3-8991,accel,Intel® Arc A750,1557.21,1409.73,,6.488,6.921,$240 ,225,1,$240 ,225,1.89
+yolo_v3_tiny,OV-2022.3-8991,accel,Intel® Arc A770,1659.92,1516.83,,4.882,7.377,$340 ,225,1,$340 ,225,1.83
 end_rec,,,,,,,,,,,,,,
 begin_rec,,,,,,,,,,,,,,
+yolo_v4,OV-2022.3-8991,core,Intel® Core™  i9-13900K CPU-only,37.15,,13.03,0.062,0.297,$599 ,125,1,$599 ,125,55.96
+yolo_v4,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-13900K iGPU-only,12.92,,4.26,0.022,0.103,$599 ,125,1,$599 ,125,78.73
+yolo_v4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-13900K CPU+iGPU,37.16,,13.54,0.062,0.297,$599 ,125,1,$599 ,125,
+yolo_v4,OV-2022.3-8991,core,Intel® Core™  i5-13600K CPU-only,25.5,,8.36,0.078,0.204,$329 ,125,1,$329 ,125,53.79
+yolo_v4,OV-2022.3-8991,core-iGPU,Intel® Core™  i5-13600K iGPU-only,12.15,,4,0.037,0.097,$329 ,125,1,$329 ,125,83.64
+yolo_v4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i5-13600K CPU+iGPU,31.99,,10.82,0.097,0.256,$329 ,125,1,$329 ,125,
 yolo_v4,OV-2022.3-8991,core,Intel® Core™  i9-12900K CPU-only,21.833,,7.096,0.033,0.132,$658 ,165,1,$658 ,165,58.4745
 yolo_v4,OV-2022.3-8991,core-iGPU,Intel® Core™  i9-12900K iGPU-only,11.956,,3.869,0.018,0.072,$658 ,165,1,$658 ,165,85.1633
 yolo_v4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i9-12900K CPU+iGPU,26.693,,8.644,0.041,0.162,$658 ,165,1,$658 ,165,
@@ -411,11 +557,15 @@ yolo_v4,OV-2022.3-8991,core,Intel® Core™  i9-10900TE CPU-only,6.399,,3.765,0.
 yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon® W1290P CPU-only,15.614,,7.925,0.026,0.125,$594 ,125,1,$594 ,125,71.631
 yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon®  E-2124G CPU-only,4.674,,2.804,0.019,0.066,$249 ,71,1,$249 ,71,214.0957
 yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 5218T CPU-only,47.338,,14.464,0.015,0.225,"$3,144 ",210,2,"$1,572 ",105,45.7699
-yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,252.03,,58.12,0.035,0.56,"$7,166 ",450,2,"$3,583 ",225,15.01
+yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon®  Gold 6448Y CPU-only,252.03,228.55,228.67,0.035,0.56,"$7,166 ",450,2,"$3,583 ",225,15.01
 yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon®  Platinum 8270 CPU-only,131.466,,41.001,0.008,0.321,"$16,954 ",410,2,"$8,477 ",205,19.2807
 yolo_v4,OV-2022.3-8991,xeon,Intel®  Xeon®  Silver 4216R CPU-only,45.047,,13.741,0.022,0.18,"$2,004 ",250,2,"$1,002 ",125,48.0344
 yolo_v4,OV-2022.3-8991,core,Intel® Core™  i7-1165G7 CPU-only,11.067,,3.259,0.024,0.395,$469 ,28,1,$469 ,28,92.2912
 yolo_v4,OV-2022.3-8991,core-iGPU,Intel® Core™  i7-1165G7 iGPU-only,25.048,,7.384,0.053,0.895,$469 ,28,1,$469 ,28,39.1492
 yolo_v4,OV-2022.3-8991,core-CPU+iGPU,Intel® Core™  i7-1165G7 CPU+iGPU,29.658,,8.32,0.063,1.059,$469 ,28,1,$469 ,28,
 yolo_v4,OV-2022.3-8991,accel,Intel® Flex-170 GPU,454.49,56.78,,0.236,3.03,"$1,925 ",150,1,"$1,925 ",150,6.969
+yolo_v4,OV-2022.3-8991,accel,Intel® Arc A40 Pro,,,,,,,,1,,50,
+yolo_v4,OV-2022.3-8991,accel,Intel® Arc A50 Pro,,,,,,,,1,,75,
+yolo_v4,OV-2022.3-8991,accel,Intel® Arc A750,288.51,229.91,,1.202,1.282,$240 ,225,1,$240 ,225,
+yolo_v4,OV-2022.3-8991,accel,Intel® Arc A770,393.82,247.1,,1.158,1.750,$340 ,225,1,$340 ,225,
 end_rec,,,,,,,,,,,,,,