[DOCS] Supported Layers update - for 22.1 (#15362)

* LessEqual Not Supported

* porting #13997

* porting #13995

.ci/azure/android_arm64.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 resources:
   repositories:
@@ -13,6 +28,7 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: releases/2022/1
 
 jobs:
 - job: android_arm64

.ci/azure/linux.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 resources:
   repositories:
@@ -13,11 +28,13 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: releases/2022/1
 
   - repository: testdata
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/testdata
+    ref: releases/2022/1
 
 jobs:
 - job: Lin

.ci/azure/linux_arm64.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 resources:
   repositories:
@@ -13,6 +28,7 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: releases/2022/1
 
 jobs:
 - job: linux_arm64
@@ -34,13 +50,13 @@ jobs:
     OPENVINO_REPO_DIR: $(Build.Repository.LocalPath)
     OPENVINO_CONTRIB_REPO_DIR: $(OPENVINO_REPO_DIR)/../openvino_contrib
     OPENCV_REPO_DIR: $(OPENVINO_REPO_DIR)/../opencv
-    BUILD_PYTHON: $(WORK_DIR)/build_python 
+    BUILD_PYTHON: $(WORK_DIR)/build_python
     BUILD_OPENCV: $(WORK_DIR)/build_opencv
     BUILD_OPENVINO: $(WORK_DIR)/build
     BUILD_OPENVINO_PYTHON: $(WORK_DIR)/build_python
     BUILD_OPEN_MODEL_ZOO: $(WORK_DIR)/build_open_model_zoo
     INSTALL_OPENVINO: $(WORK_DIR)/install_openvino
-    INSTALL_PYTHON: $(INSTALL_OPENVINO)/extras/python 
+    INSTALL_PYTHON: $(INSTALL_OPENVINO)/extras/python
     INSTALL_OPENCV: $(INSTALL_OPENVINO)/extras/opencv
     INSTALL_OPEN_MODEL_ZOO: $(INSTALL_OPENVINO)/extras/open_model_zoo
     WORK_DIR: $(Pipeline.Workspace)/_w
@@ -125,20 +141,20 @@ jobs:
       cmakeArgs: >
         -GNinja
         -DVERBOSE_BUILD=ON
-        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake 
-        -DENABLE_OPENCV=OFF 
-        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8 
-        -DPYTHON_LIBRARY=$(INSTALL_PYTHON)/lib/libpython3.8.so 
-        -DENABLE_PYTHON=ON 
-        -DPYTHON_MODULE_EXTENSION=".so" 
-        -DENABLE_TESTS=ON 
-        -DENABLE_FUNCTIONAL_TESTS=ON 
-        -DENABLE_GAPI_TESTS=OFF 
-        -DENABLE_GAPI_PREPROCESSING=OFF 
-        -DENABLE_DATA=OFF 
-        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib 
-        -DTHREADING=SEQ -DENABLE_LTO=ON 
-        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake 
+        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake
+        -DENABLE_OPENCV=OFF
+        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8
+        -DPYTHON_LIBRARY=$(INSTALL_PYTHON)/lib/libpython3.8.so
+        -DENABLE_PYTHON=ON
+        -DPYTHON_MODULE_EXTENSION=".so"
+        -DENABLE_TESTS=ON
+        -DENABLE_FUNCTIONAL_TESTS=ON
+        -DENABLE_GAPI_TESTS=OFF
+        -DENABLE_GAPI_PREPROCESSING=OFF
+        -DENABLE_DATA=OFF
+        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib
+        -DTHREADING=SEQ -DENABLE_LTO=ON
+        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake
         -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
         -DENABLE_SAMPLES=ON
         -DBUILD_java_api=OFF
@@ -173,19 +189,19 @@ jobs:
       cmakeArgs: >
         -GNinja
         -DInferenceEngineDeveloperPackage_DIR=$(BUILD_OPENVINO)
-        -DENABLE_PYTHON=ON 
-        -DPYTHON_EXECUTABLE=$(INSTALL_PYTHON)/bin/python3.8 
-        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8 
+        -DENABLE_PYTHON=ON
+        -DPYTHON_EXECUTABLE=$(INSTALL_PYTHON)/bin/python3.8
+        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8
         -DPYTHON_LIBRARIES=$(INSTALL_PYTHON)/lib
-        -DPYTHON3_NUMPY_INCLUDE_DIRS=/usr/local/lib/python3.8/site-packages/numpy/core/include 
+        -DPYTHON3_NUMPY_INCLUDE_DIRS=/usr/local/lib/python3.8/site-packages/numpy/core/include
         -DPYTHON_MODULE_EXTENSION=".so"
         -DPYBIND11_FINDPYTHON=OFF
         -DPYBIND11_NOPYTHON=OFF
         -DPYTHONLIBS_FOUND=TRUE
         -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
         -DENABLE_DATA=OFF
-        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib 
-        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake 
+        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib
+        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake
         -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
         -DCMAKE_C_COMPILER_LAUNCHER=ccache
         -DCMAKE_INSTALL_PREFIX=$(INSTALL_OPENVINO)
@@ -211,15 +227,15 @@ jobs:
     inputs:
       cmakeArgs: >
         -GNinja
-        -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) 
-        -DENABLE_PYTHON=ON 
+        -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
+        -DENABLE_PYTHON=ON
         -DPYTHON_EXECUTABLE=/usr/local/bin/python3.8
-        -DPYTHON_INCLUDE_DIR=$(INSTALL_PYTHON)/include/python3.8 
+        -DPYTHON_INCLUDE_DIR=$(INSTALL_PYTHON)/include/python3.8
         -DPYTHON_LIBRARY=$(INSTALL_PYTHON)/lib
         -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake
         -DOpenVINO_DIR=$(BUILD_OPENVINO)
         -DInferenceEngine_DIR=$(BUILD_OPENVINO)
-        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake 
+        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake
         -Dngraph_DIR=$(BUILD_OPENVINO)
         -DIE_EXTRA_MODULES=$(OPENVINO_CONTRIB_REPO_DIR)/modules
         -DCMAKE_INSTALL_PREFIX=$(INSTALL_OPEN_MODEL_ZOO)

.ci/azure/linux_conditional_compilation.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 jobs:
 - job: LinCC

.ci/azure/linux_coverity.yml

@@ -4,6 +4,7 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: releases/2022/1
 
 jobs:
 - job: Lin

.ci/azure/linux_ngraph_onnx.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 jobs:
 - job: OpenVINO_ONNX_CI

.ci/azure/linux_onnxruntime.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 jobs:
 - job: onnxruntime

.ci/azure/mac.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 resources:
   repositories:
@@ -13,11 +28,13 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: releases/2022/1
 
   - repository: testdata
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/testdata
+    ref: releases/2022/1
 
 jobs:
 - job: Mac

.ci/azure/windows.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 resources:
   repositories:
@@ -13,11 +28,13 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: releases/2022/1
 
   - repository: testdata
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/testdata
+    ref: releases/2022/1
 
 jobs:
 - job: Win
@@ -30,7 +47,7 @@ jobs:
     maxParallel: 2
 
   # About 150% of total time
-  timeoutInMinutes: 150
+  timeoutInMinutes: 180
 
   pool:
     name: WIN_VMSS_VENV_D8S_WU2

.ci/azure/windows_conditional_compilation.yml

@@ -5,7 +5,22 @@ trigger:
     - releases/*
   paths:
     exclude:
-    - docs/*
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
+
+pr:
+  branches:
+    include:
+    - master
+    - releases/*
+  paths:
+    exclude:
+    - docs/
+    - /**/docs/*
+    - /**/*.md
+    - README.md
 
 jobs:
 - job: WinCC

CODEOWNERS

@@ -47,6 +47,9 @@ Jenkinsfile  @openvinotoolkit/openvino-admins
 /src/inference/include/ie/cldnn/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 /src/inference/include/openvino/runtime/intel_gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 /src/plugins/intel_gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
+/docs/snippets/gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
+/docs/OV_Runtime_UG/supported_plugins/GPU.md  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
+/docs/OV_Runtime_UG/supported_plugins/GPU_RemoteTensor_API.md  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 
 # IE VPU:
 /src/plugins/intel_myriad  @openvinotoolkit/openvino-ie-vpu-maintainers
@@ -63,6 +66,9 @@ Jenkinsfile  @openvinotoolkit/openvino-admins
 /src/plugins/intel_gna/  @openvinotoolkit/openvino-ie-gna-maintainers
 /src/inference/include/ie/gna/  @openvinotoolkit/openvino-ie-gna-maintainers
 
+# IE ARM CPU:
+/docs/OV_Runtime_UG/supported_plugins/ARM_CPU.md  @openvinotoolkit/openvino_contrib-arm_plugin-maintainers
+
 # IE Auto (MULTI) plugin:
 /src/plugins/auto/  @openvinotoolkit/openvino-ie-auto-multi-maintainers
 /src/inference/include/ie/multi-device/  @openvinotoolkit/openvino-ie-auto-multi-maintainers

README.md

@@ -1,5 +1,5 @@
 # OpenVINO™ Toolkit
-[![Stable release](https://img.shields.io/badge/version-2021.4.2-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2021.4.2)
+[![Stable release](https://img.shields.io/badge/version-2022.1-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2022.1)
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
 ![GitHub branch checks state](https://img.shields.io/github/checks-status/openvinotoolkit/openvino/master?label=GitHub%20checks)
 ![Azure DevOps builds (branch)](https://img.shields.io/azure-devops/build/openvinoci/b2bab62f-ab2f-4871-a538-86ea1be7d20f/13?label=Public%20CI)
@@ -42,9 +42,9 @@ Please report questions, issues and suggestions using:
 \* Other names and brands may be claimed as the property of others.
 
 [Open Model Zoo]:https://github.com/openvinotoolkit/open_model_zoo
-[OpenVINO™ Runtime]:https://docs.openvino.ai/latest/openvino_docs_OV_Runtime_User_Guide.html
+[OpenVINO™ Runtime]:https://docs.openvino.ai/latest/openvino_docs_OV_UG_OV_Runtime_User_Guide.html
 [Model Optimizer]:https://docs.openvino.ai/latest/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html
-[Post-Training Optimization Tool]:https://docs.openvino.ai/latest/pot_README.html
+[Post-Training Optimization Tool]:https://docs.openvino.ai/latest/pot_introduction.html
 [Samples]:https://github.com/openvinotoolkit/openvino/tree/master/samples
 [tag on StackOverflow]:https://stackoverflow.com/search?q=%23openvino
 

cmake/developer_package/ncc_naming_style/ncc_naming_style.cmake

@@ -23,7 +23,7 @@ execute_process(
     ERROR_VARIABLE error_var)
 
 if(NOT clang_find_result EQUAL "0")
-    message(WARNING "Please, install libclang-[N]-dev package (required for ncc naming style check)")
+    message(WARNING "Please, install clang-[N] libclang-[N]-dev package (required for ncc naming style check)")
     message(WARNING "find_package(Clang) output: ${output_var}")
     message(WARNING "find_package(Clang) error: ${error_var}")
     set(ENABLE_NCC_STYLE OFF)
@@ -107,8 +107,11 @@ function(ov_ncc_naming_style)
 
     list(APPEND NCC_STYLE_ADDITIONAL_INCLUDE_DIRECTORIES "${NCC_STYLE_SOURCE_DIRECTORY}")
 
+    # without it sources with same name from different directories will map to same .ncc_style target
+    file(RELATIVE_PATH source_dir_rel ${CMAKE_SOURCE_DIR} ${NCC_STYLE_SOURCE_DIRECTORY})
+
     foreach(source IN LISTS sources)
-        set(output_file "${ncc_style_bin_dir}/${source}.ncc_style")
+        set(output_file "${ncc_style_bin_dir}/${source_dir_rel}/${source}.ncc_style")
         set(full_source_path "${NCC_STYLE_SOURCE_DIRECTORY}/${source}")
 
         add_custom_command(

cmake/developer_package/ncc_naming_style/openvino.style

@@ -1,5 +1,5 @@
 # custom OpenVINO values
-CppMethod: '^(operator\W+|[a-z_\d]+|signaling_NaN|quiet_NaN)$'
+CppMethod: '^(operator\W+|[a-z_\d]+|signaling_NaN|quiet_NaN|OPENVINO_OP)$'
 ClassName: '^([A-Z][\w]+|b?float16|numeric_limits|ngraph_error|stopwatch|unsupported_op)$'
 StructName: '^([A-Z][\w]+|element_type_traits|hash|oi_pair)$'
 FunctionName: '^(operator\W+|[a-z_\d]+)|PrintTo$'

docs/CMakeLists.txt

@@ -46,6 +46,7 @@ endif()
 set(LINKCHECKER_PY "" CACHE FILEPATH "Path to linkchecker.py for documentation check dir.")
 set(ENABLE_OPENVINO_NOTEBOOKS OFF CACHE BOOL "Build with openvino notebooks")
 set(OMZ_DOCS_DIR "" CACHE PATH "Path to open_model_zoo documentation dir.")
+set(OTE_DOCS_DIR "" CACHE PATH "Path to training_extensions documentation dir.")
 set(WORKBENCH_DOCS_DIR "" CACHE PATH "Path to workbench documentation dir.")
 set(OVMS_DOCS_DIR "" CACHE PATH "Path to model server documentation dir.")
 set(GRAPH_CSV_DIR "" CACHE PATH "Path to the folder containing csv data for rendering graphs.")
@@ -159,6 +160,15 @@ function(build_docs)
             --output_dir=${DOCS_BUILD_DIR}/workbench)
     endif()
 
+    # ote doc files
+    if(EXISTS "${OTE_DOCS_DIR}")
+        get_filename_component(WORKBENCH_DOCS_DIR "${OTE_DOCS_DIR}" ABSOLUTE)
+
+        list(APPEND commands COMMAND ${PYTHON_EXECUTABLE} ${DOXY_MD_FILTER}
+            --input_dir=${OTE_DOCS_DIR}
+            --output_dir=${DOCS_BUILD_DIR}/ote)
+    endif()
+
     # ovms doc files
     if(EXISTS "${OVMS_DOCS_DIR}")
         get_filename_component(OVMS_DOCS_DIR "${OVMS_DOCS_DIR}" ABSOLUTE)

docs/Doxyfile.config

@@ -264,6 +264,10 @@ TAB_SIZE               = 4
 ALIASES                = "ref_ie{1}=@ref InferenceEngine::\1 \"\1\""
 ALIASES                += sphinxdirective="\n\xmlonly<sphinxdirective>"
 ALIASES                += endsphinxdirective="</sphinxdirective>\endxmlonly"
+ALIASES                += sphinxtabset="\n\xmlonly<sphinxtabset></sphinxtabset>\endxmlonly\n"
+ALIASES                += endsphinxtabset="\n\xmlonly<endsphinxtabset></endsphinxtabset>\endxmlonly\n"
+ALIASES                += sphinxtab{1}="\n\xmlonly<sphinxtab>\1</sphinxtab>\endxmlonly\n"
+ALIASES                += endsphinxtab="\n\xmlonly<endsphinxtab></endsphinxtab>\endxmlonly\n"
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For

docs/Extensibility_UG/GPU_Extensibility.md

@@ -0,0 +1,239 @@
+# How to Implement Custom GPU Operations {#openvino_docs_Extensibility_UG_GPU}
+
+To enable operations not supported by OpenVINO out of the box, you may need an extension for an OpenVINO operation set, and a custom kernel for the device you will target. This page describes custom kernel support for the GPU device.
+
+The GPU codepath abstracts many details about OpenCL. You need to provide the kernel code in OpenCL C and an XML configuration file that connects the kernel and its parameters to the parameters of the operation.
+
+There are two options for using the custom operation configuration file:
+
+* Include a section with your kernels into the automatically-loaded `<lib_path>/cldnn_global_custom_kernels/cldnn_global_custom_kernels.xml` file.
+* Call the `ov::Core::set_property()` method from your application with the `"CONFIG_FILE"` key and the configuration file name as a value before loading the network that uses custom operations to the plugin:
+
+@sphinxtabset
+
+@sphinxtab{C++}
+@snippet docs/snippets/gpu/custom_kernels_api.cpp part0
+@endsphinxtab
+
+@sphinxtab{Python}
+@snippet docs/snippets/gpu/custom_kernels_api.py part0
+@endsphinxtab
+
+@endsphinxtabset
+
+All OpenVINO samples, except the trivial `hello_classification`, and most Open Model Zoo demos
+feature a dedicated command-line option `-c` to load custom kernels. For example, to load custom operations for the classification sample, run the command below:
+```sh
+$ ./classification_sample -m <path_to_model>/bvlc_alexnet_fp16.xml -i ./validation_set/daily/227x227/apron.bmp -d GPU
+ -c <absolute_path_to_config>/custom_layer_example.xml
+```
+
+## Configuration File Format <a name="config-file-format"></a>
+
+The configuration file is expected to follow the `.xml` file structure
+with a node of the `CustomLayer` type for every custom operation you provide.
+
+The definitions described in the sections below use the following notations:
+
+Notation | Description
+---|---
+(0/1) | Can have zero or one instance of this node or attribute
+(1) | Must have only one instance of this node or attribute
+(0+) | Can have any number of instances of this node or attribute
+(1+) | Can have one or more instances of this node or attribute
+
+### CustomLayer Node and Sub-Node Structure
+
+`CustomLayer` node contains the entire configuration for a single custom operation.
+
+| Attribute Name   |\#    |  Description |
+|-----|-----|-----|
+| `name`           | (1)  | The name of the operation type to be used. This name should be identical to the type used in the IR.|
+| `type`           | (1)  | Must be `SimpleGPU`.                                                                                |
+| `version`        | (1)  | Must be `1`.                                                                                        |
+
+**Sub-nodes**: `Kernel` (1), `Buffers` (1), `CompilerOptions` (0+),
+`WorkSizes` (0/1)
+
+### Kernel Node and Sub-Node Structure
+
+`Kernel` node contains all kernel source code configuration.
+
+**Sub-nodes**: `Source` (1+), `Define` (0+)
+
+### Source Node and Sub-Node Structure
+
+`Source` node points to a single OpenCL source file.
+
+| Attribute Name | \#  |Description|
+|-----|-----|-----|
+| `filename`     | (1) | Name of the file containing OpenCL source code. Note that the path is relative to your executable. Multiple source nodes will have their sources concatenated in order. |
+
+**Sub-nodes**: None
+
+### Define Node and Sub-Node Structure
+
+`Define` node configures a single `#&zwj;define` instruction to be added to
+the sources during compilation (JIT).
+
+| Attribute Name | \#    | Description |
+|------|-------|------|
+| `name`         | (1)   | The name of the defined JIT. For static constants, this can include the value as well, which is taken as a string. |
+| `param`        | (0/1) | This parameter value is used as the value of this JIT definition.                                          |
+| `type`         | (0/1) | The parameter type. Accepted values: `int`, `float`, and `int[]`, `float[]` for arrays.                    |
+| `default`      | (0/1) | The default value to be used if the specified parameters are missing from the operation in the IR.          |
+
+**Sub-nodes:** None
+
+The resulting JIT has the following form:
+`#&zwj;define [name] [type] [value/default]`.
+
+### Buffers Node and Sub-Node Structure
+
+`Buffers` node configures all input/output buffers for the OpenCL entry
+function. No buffers node structure exists.
+
+**Sub-nodes:** `Data` (0+), `Tensor` (1+)
+
+### Data Node and Sub-Node Structure
+
+`Data` node configures a single input with static data, for example,
+weights or biases.
+
+| Attribute Name | \#  | Description |
+|----|-----|------|
+| `name`         | (1) | Name of a blob attached to an operation in the IR             |
+| `arg-index`    | (1) | 0-based index in the entry function arguments to be bound to |
+
+**Sub-nodes**: None
+
+### Tensor Node and Sub-Node Structure
+
+`Tensor` node configures a single input or output tensor.
+
+| Attribute Name | \#    | Description  |
+|------|-------|-------|
+| `arg-index`    | (1)   | 0-based index in the entry function arguments to be bound to.                                                                          |
+| `type`         | (1)   | `input` or `output`                                                                                                                    |
+| `port-index`   | (1)   | 0-based index in the operation input/output ports in the IR                                                                            |
+| `format`       | (0/1) | Data layout declaration for the tensor. Accepted values: `BFYX`, `BYXF`, `YXFB`, `FYXB`, and same values in all lowercase. Default value: `BFYX` |
+
+### CompilerOptions Node and Sub-Node Structure
+
+`CompilerOptions` node configures the compilation flags for the OpenCL
+sources.
+
+| Attribute Name | \#  | Description                                        |
+|--------|-----|------|
+| `options`      | (1) | Options string to be passed to the OpenCL compiler |
+
+**Sub-nodes**: None
+
+### WorkSizes Node and Sub-Node Structure
+
+`WorkSizes` node configures the global/local work sizes to be used when
+queuing an OpenCL program for execution.
+
+| Attribute Name      | \#             | Description                                                                 |
+|-----|------|-----|
+| `global`<br>`local` | (0/1)<br>(0/1) | An array of up to three integers or formulas for defining OpenCL work-sizes to be used during execution.<br> The formulas can use the values of the B,F,Y,X dimensions and contain the operators: +,-,/,\*,%. All operators are evaluated in integer arithmetic. <br>Default value: `global=”B*F*Y*X” local=””` |
+| `dim`               | (0/1)          | A tensor to take the work-size from. Accepted values: `input N`, `output`, where `N` is an index of input tensor starting with 0. Default value: `output` |
+
+**Sub-nodes**: None
+
+## Example Configuration File
+
+The following code sample provides an example configuration file in XML
+format. For information on the configuration file structure, see
+[Configuration File Format](#config-file-format).
+```xml
+<CustomLayer name="ReLU" type="SimpleGPU" version="1">
+  <Kernel entry="example_relu_kernel">
+    <Source filename="custom_layer_kernel.cl"/>
+    <Define name="neg_slope" type="float" param="negative_slope" default="0.0"/>
+  </Kernel>
+  <Buffers>
+    <Tensor arg-index="0" type="input" port-index="0" format="BFYX"/>
+    <Tensor arg-index="1" type="output" port-index="0" format="BFYX"/>
+  </Buffers>
+  <CompilerOptions options="-cl-mad-enable"/>
+  <WorkSizes global="X,Y,B*F"/>
+</CustomLayer>
+```
+
+## Built-In Definitions for Custom Layers
+
+The following table includes definitions that are attached before
+user sources.
+
+For an example, see [Example Kernel](#example-kernel).
+
+| Name | Value  |
+|---|---|
+| `NUM_INPUTS` | Number of the input tensors bound to this kernel |
+| `GLOBAL_WORKSIZE`  | An array of global work sizes used to execute this kernel |
+| `GLOBAL_WORKSIZE_SIZE` | The size of the `GLOBAL_WORKSIZE` array |
+| `LOCAL_WORKSIZE`  | An array of local work sizes used to execute this kernel  |
+| `LOCAL_WORKSIZE_SIZE`   | The size of the `LOCAL_WORKSIZE` array |
+| `<TENSOR>_DIMS`| An array of the tensor dimension sizes. Always ordered as `BFYX` |
+| `<TENSOR>_DIMS_SIZE`| The size of the `<TENSOR>_DIMS` array.|
+| `<TENSOR>_TYPE`| The datatype of the tensor: `float`, `half`, or `char`|
+| `<TENSOR>_FORMAT_<TENSOR_FORMAT>` | The format of the tensor, BFYX, BYXF, YXFB , FYXB, or ANY. The format is concatenated to the defined name. You can use the tensor format to define codepaths in your code with `#&zwj;ifdef/#&zwj;endif`. |
+| `<TENSOR>_LOWER_PADDING` | An array of padding elements used for the tensor dimensions before they start. Always ordered as BFYX.|
+| `<TENSOR>_LOWER_PADDING_SIZE` | The size of the `<TENSOR>_LOWER_PADDING` array  |
+| `<TENSOR>_UPPER_PADDING`   | An array of padding elements used for the tensor dimensions after they end. Always ordered as BFYX. |
+| `<TENSOR>_UPPER_PADDING_SIZE`  | The size of the `<TENSOR>_UPPER_PADDING` array |
+| `<TENSOR>_PITCHES` | The offset (in elements) between adjacent elements in each dimension. Always ordered as BFYX.|
+| `<TENSOR>_PITCHES_SIZE`| The size of the `<TENSOR>_PITCHES` array   |
+| `<TENSOR>_OFFSET`| The number of elements from the start of the tensor to the first valid element, bypassing the lower padding.  |
+
+All `<TENSOR>` values are automatically defined for every tensor
+bound to this operation, such as `INPUT0`, `INPUT1`, and `OUTPUT0`, as shown
+in the following example:
+
+```c
+#define INPUT0_DIMS_SIZE 4
+#define INPUT0_DIMS (int []){ 1,96,55,55, }
+```
+
+## Example Kernel<a name="example-kernel"></a>
+
+```c
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+__kernel void example_relu_kernel(
+    const __global INPUT0_TYPE*  input0,
+          __global OUTPUT0_TYPE* output)
+{
+    const uint idx  = get_global_id(0);
+    const uint idy  = get_global_id(1);
+    const uint idbf = get_global_id(2); // batches*features, as OpenCL supports 3D nd-ranges only
+    const uint feature = idbf % OUTPUT0_DIMS[1];
+    const uint batch   = idbf / OUTPUT0_DIMS[1];
+    //notice that pitches are in elements, not in bytes!
+    const uint in_id  = batch*INPUT0_PITCHES[0] + feature*INPUT0_PITCHES[1]   + idy*INPUT0_PITCHES[2]  + idx*INPUT0_PITCHES[3]  + INPUT0_OFFSET;
+    const uint out_id = batch*OUTPUT0_PITCHES[0] + feature*OUTPUT0_PITCHES[1]  + idy*OUTPUT0_PITCHES[2]  + idx*OUTPUT0_PITCHES[3]  + OUTPUT0_OFFSET;
+
+    INPUT0_TYPE value = input0[in_id];
+    // neg_slope (which is non-zero for leaky ReLU) is put automatically as #define, refer to the config xml
+    output[out_id] = value < 0 ? value * neg_slope : value;
+}
+```
+
+
+> **NOTE**: As described in the previous section, all items like
+> `INPUT0_TYPE` are actually defined as OpenCL (pre-)compiler inputs by
+> OpenVINO for efficiency reasons. See [Debugging
+> Tips](#debugging-tips) for information on debugging the results.
+
+## Debugging Tips<a name="debugging-tips"></a>
+
+* **Using `printf` in the OpenCL™ Kernels**.
+To debug the specific values, you can use `printf` in your kernels.
+However, be careful not to output excessively, which
+could generate too much data. The `printf` output is typical, so
+your output can be truncated to fit the buffer. Also, because of
+buffering, you actually get an entire buffer of output when the
+execution ends.<br>
+
+For more information, refer to the [printf
+Function](https://www.khronos.org/registry/OpenCL/sdk/1.2/docs/man/xhtml/printfFunction.html).

docs/Extensibility_UG/Intro.md

@@ -1,4 +1,4 @@
-# OpenVINO Extensibility Mechanism {#openvino_docs_Extensibility_UG_Intro}
+# OpenVINO Extensibility Mechanism {#openvino_docs_Extensibility_UG_Intro}
 
 @sphinxdirective
 
@@ -7,36 +7,68 @@
    :hidden:
 
    openvino_docs_Extensibility_UG_add_openvino_ops
+   openvino_docs_Extensibility_UG_Frontend_Extensions
+   openvino_docs_Extensibility_UG_GPU
+   openvino_docs_Extensibility_UG_VPU_Kernel
+   openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Customize_Model_Optimizer
 
 @endsphinxdirective
 
-The Intel® Distribution of OpenVINO™ toolkit supports neural network models trained with multiple frameworks including
-TensorFlow, Caffe, MXNet, Kaldi, PaddlePaddle, and ONNX. The list of supported operations (layers) is different for
+The Intel® Distribution of OpenVINO™ toolkit supports neural network models trained with various frameworks, including
+TensorFlow, PyTorch, ONNX, PaddlePaddle, MXNet, Caffe, and Kaldi. The list of supported operations is different for
 each of the supported frameworks. To see the operations supported by your framework, refer to
 [Supported Framework Operations](../MO_DG/prepare_model/Supported_Frameworks_Layers.md).
 
-Custom operations, that is those not included in the list, are not recognized by OpenVINO™ out-of-the-box. Therefore, creating Intermediate Representation (IR) for a model using them requires additional steps. This guide illustrates the workflow for running inference on topologies featuring custom operations, allowing you to plug in your own implementation for existing or completely new operations.
+Custom operations, that is those not included in the list, are not recognized by OpenVINO™ out-of-the-box. The need for a custom operation may appear in two main cases:
 
-If your model contains operations not normally supported by OpenVINO™, the OpenVINO™ Extensibility API lets you add support for those custom operations and use one implementation for Model Optimizer and OpenVINO™ Runtime.
+1. A regular framework operation that is new or rarely used, which is why it hasn’t been implemented in OpenVINO yet.
 
-There are two steps to support inference of a model with custom operation(s):
-1. Add support for a [custom operation in the Model Optimizer](../MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md) so
-the Model Optimizer can generate the IR with the operation.
-2. Create a custom operation in it as described in the [Custom Operation](add_openvino_ops.md).
+2. A new user operation that was created for some specific model topology by a model author using framework extension capabilities.
 
-## OpenVINO™ Extensions
+Importing models with such operations requires additional steps. This guide illustrates the workflow for running inference on models featuring custom operations, allowing you to plug in your own implementation for them. OpenVINO™ Extensibility API lets you add support for those custom operations and use one implementation for Model Optimizer and OpenVINO™ Runtime.
 
-An OpenVINO™ provides extensions for:
+Defining a new custom operation basically consist of two parts:
 
- * [Custom OpenVINO™ Operation](add_openvino_ops.md):
-    - Enables the creation of unsupported operations
-    - Enables the use of `ov::Core::read_model` to read models with unsupported operations
-    - Provides a shape inference mechanism for custom operations
-    - Provides an evaluate method which allow to support the operation on CPU or perform constant folding
+1. Definition of operation semantics in OpenVINO, the code that describes how this operation should be inferred consuming input tensor(s) and producing output tensor(s). How to implement execution kernels for [GPU](./GPU_Extensibility.md) and [VPU](./VPU_Extensibility.md) is described in separate guides.
 
-> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/docs/template_extension/new), which demonstrates extension development details. You can review the complete code, which is fully compilable and up-to-date, to see how it works.
+2. Mapping rule that facilitates conversion of framework operation representation to OpenVINO defined operation semantics.
 
-## Load extensions to OpenVINO™ Runtime
+The first part is required for inference, the second part is required for successful import of a model containing such operations from the original framework model format. There are several options to implement each part, the next sections will describe them in detail.
+
+## Definition of Operation Semantics
+
+
+If the custom operation can be mathematically represented as a combination of exiting OpenVINO operations and such decomposition gives desired performance, then low-level operation implementation is not required. When deciding feasibility of such decomposition refer to the latest OpenVINO operation set. You can use any valid combination of exiting operations. How to map a custom operation is described in the next section of this document.
+
+If such decomposition is not possible or appears too bulky with lots of consisting operations that are not performing well, then a new class for the custom operation should be implemented as described in the [Custom Operation Guide](add_openvino_ops.md). 
+
+Prefer implementing a custom operation class if you already have a generic C++ implementation of operation kernel. Otherwise try to decompose the operation first as described above and then after verifying correctness of inference and resulting performance, optionally invest to implementing bare metal C++ implementation.
+
+## Mapping from Framework Operation
+
+Depending on model format used for import, mapping of custom operation is implemented differently, choose one of:
+
+1. If model is represented in ONNX (including models exported from Pytorch in ONNX) or PaddlePaddle formats, then one of the classes from [Frontend Extension API](frontend_extensions.md) should be used. It consists of several classes available in C++ which can be used with Model Optimizer `--extensions` option or when model is imported directly to OpenVINO run-time using read_model method. Python API is also available for run-time model importing.
+
+2. If model is represented in TensorFlow, Caffe, Kaldi or MXNet formats, then [Model Optimizer Extensions](../MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md) should be used. This approach is available for model conversion in Model Optimizer only.
+
+Existing of two approaches simultaneously is explained by two different types of frontends used for model conversion in OpenVINO: new frontends (ONNX, PaddlePaddle) and legacy frontends (TensorFlow, Caffe, Kaldi and MXNet). Model Optimizer can use both front-ends in contrast to the direct import of model with `read_model` method which can use new frontends only. Follow one of the appropriate guides referenced above to implement mappings depending on framework frontend.
+
+If you are implementing extensions for ONNX or PaddlePaddle new frontends and plan to use Model Optimizer `--extension` option for model conversion, then the extensions should be
+
+1. Implemented in C++ only
+
+2. Compiled as a separate shared library (see details how to do that later in this guide).
+
+You cannot write new frontend extensions using Python API if you plan to use them with Model Optimizer.
+
+Remaining part of this guide uses Frontend Extension API applicable for new frontends.
+
+## Registering Extensions
+
+A custom operation class and a new mapping frontend extension class object should be registered to be usable in OpenVINO runtime.
+
+> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/docs/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.
 
 To load the extensions to the `ov::Core` object, use the `ov::Core::add_extension` method, this method allows to load library with extensions or extensions from the code.
 
@@ -44,27 +76,50 @@ To load the extensions to the `ov::Core` object, use the `ov::Core::add_extensio
 
 Extensions can be loaded from code with `ov::Core::add_extension` method:
 
+@sphinxtabset
+
+@sphinxtab{C++}
+
+@snippet docs/snippets/ov_extensions.cpp add_extension
+
+@endsphinxtab
+
+@sphinxtab{Python}
+
+@snippet docs/snippets/ov_extensions.py add_extension
+
+@endsphinxtab
+
+@endsphinxtabset
+
+`Identity` is custom operation class defined in [Custom Operation Guide](add_openvino_ops.md). This is enough to enable reading IR which uses `Identity` extension operation emitted by Model Optimizer. To be able to load original model directly to the runtime, you need to add also a mapping extension:
+
 @sphinxdirective
 
 .. tab:: C++
 
     .. doxygensnippet:: docs/snippets/ov_extensions.cpp
        :language: cpp
-       :fragment: add_extension
+       :fragment: add_frontend_extension
 
 .. tab:: Python
 
     .. doxygensnippet:: docs/snippets/ov_extensions.py
        :language: python
-       :fragment: add_extension
+       :fragment: add_frontend_extension
 
 @endsphinxdirective
+ 
+When Python API is used there is no way to implement a custom OpenVINO operation. Also, even if custom OpenVINO operation is implemented in C++ and loaded to the runtime through a shared library, there is still no way to add a frontend mapping extension that refers to this custom operation. Use C++ shared library approach to implement both operations semantics and framework mapping in this case.
+
+You still can use Python for operation mapping and decomposition in case if operations from the standard OpenVINO operation set is used only.
 
 ### Create library with extensions
 
-You need to create extension library in following cases:
- - Load extensions to Model Optimizer
- - Load extensions to Python application
+You need to create extension library in the following cases:
+ - Convert model with custom operations in Model Optimizer
+ - Load model with custom operations in Python application. It is applicable for both framework model and IR.
+ - Loading models with custom operations in tools that support loading extensions from a library, for example `benchmark_app`.
 
 If you want to create an extension library, for example in order to load these extensions to the Model Optimizer, you need to do next steps:
 Create an entry point for extension library. OpenVINO™ provides an `OPENVINO_CREATE_EXTENSIONS()` macro, which allows to define an entry point to a library with OpenVINO™ Extensions.
@@ -92,24 +147,25 @@ $ cmake --build .
 
 After the build you can use path to your extension library to load your extensions to OpenVINO™ Runtime:
 
-@sphinxdirective
+@sphinxtabset
 
-.. tab:: C++
+@sphinxtab{C++}
 
-    .. doxygensnippet:: docs/snippets/ov_extensions.cpp
-       :language: cpp
-       :fragment: add_extension_lib
+@snippet docs/snippets/ov_extensions.cpp add_extension_lib
 
-.. tab:: Python
+@endsphinxtab
 
-    .. doxygensnippet:: docs/snippets/ov_extensions.py
-       :language: python
-       :fragment: add_extension_lib
+@sphinxtab{Python}
 
-@endsphinxdirective
+@snippet docs/snippets/ov_extensions.py add_extension_lib
+
+@endsphinxtab
+
+@endsphinxtabset
 
 ## See Also
 
 * [OpenVINO Transformations](./ov_transformations.md)
-* [Using Inference Engine Samples](../OV_Runtime_UG/Samples_Overview.md)
+* [Using OpenVINO Runtime Samples](../OV_Runtime_UG/Samples_Overview.md)
 * [Hello Shape Infer SSD sample](../../samples/cpp/hello_reshape_ssd/README.md)
+

docs/Extensibility_UG/VPU_Extensibility.md

@@ -0,0 +1,619 @@
+# 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.
+
+> **NOTES:** 
+> * OpenCL\* custom layer support is available in the preview mode.
+> * This section assumes you are familiar with developing kernels using OpenCL.
+To customize your topology with an OpenCL layer, carry out the tasks described on this page:
+
+1. Write and compile your OpenCL code with the standalone offline OpenCL compiler (`clc`).
+2. Write a configuration file to bind the OpenCL kernel to the topology file (`.xml`) of the model IR.
+3. Pass the configuration file to the OpenVINO™ Runtime with the model IR.
+
+## Compile OpenCL code for VPU (Intel® Neural Compute Stick 2)
+
+> **NOTE**: OpenCL compiler, targeting Intel® Neural Compute Stick 2 for the SHAVE* processor only, is redistributed with OpenVINO.
+OpenCL support is provided by ComputeAorta* and is distributed under a license agreement between Intel® and Codeplay* Software Ltd.
+The OpenCL toolchain for the Intel® Neural Compute Stick 2 supports offline compilation only, so first compile OpenCL C code using the standalone `clc` compiler. You can find the compiler binary at `<INSTALL_DIR>/tools/cl_compiler`.
+
+> **NOTE**: By design, custom OpenCL layers support any OpenCL kernels written assuming OpenCL version 1.2. It also supports half float extension and is optimized for this type, because it is a native type for Intel® Movidius™ VPUs.
+1. Prior to running a compilation, make sure that the following variables are set:
+   * `SHAVE_MA2X8XLIBS_DIR=<INSTALL_DIR>/tools/cl_compiler/lib/`
+   * `SHAVE_LDSCRIPT_DIR=<INSTALL_DIR>/tools/cl_compiler/ldscripts/`
+   * `SHAVE_MYRIAD_LD_DIR=<INSTALL_DIR>/tools/cl_compiler/bin/`
+   * `SHAVE_MOVIASM_DIR=<INSTALL_DIR>/tools/cl_compiler/bin/`
+2. Run the compilation with the command below. You should use `--strip-binary-header` to make an OpenCL runtime-agnostic binary runnable with the OpenVINO™ Runtime.
+   ```bash
+   cd <INSTALL_DIR>/tools/cl_compiler/bin
+   ./clc --strip-binary-header custom_layer.cl -o custom_layer.bin
+   ```
+
+## Write a Configuration File
+
+To tie the topology IR for a layer you customize, prepare a configuration file, so that the OpenVINO™ Runtime can find parameters for your kernel and the execution work grid is described.
+For example, consider the following OpenCL kernel signature:
+```cpp
+__kernel void reorg_nhwc(__global const half *src, __global half *out, int w, int h, int c, int stride);
+```
+A configuration file for this kernel might be the following:
+```xml
+<CustomLayer name="ReorgYolo" type="MVCL" version="1">
+   <Kernel entry="reorg_nhwc">
+       <Source filename="reorg.bin"/>
+   </Kernel>
+   <Parameters>
+       <Tensor arg-name="src"    type="input"  port-index="0"                format="BYXF"/>
+       <Tensor arg-name="out"    type="output" port-index="0"                format="BYXF"/>
+       <Scalar arg-name="w"      type="int"    port-index="0" source="I.X"                />
+       <Scalar arg-name="h"      type="int"    port-index="0" source="I.Y"                />
+       <Scalar arg-name="c"      type="int"    port-index="0" source="I.F"                />
+       <Scalar arg-name="stride" type="int"                   source="stride"             />
+   </Parameters>
+   <WorkSizes dim="input,0" global="(Y+7)/8*8,1,1" local="8,1,1"/>
+</CustomLayer>
+```
+Each custom layer is described with the `CustomLayer` node. It has the following nodes and attributes:
+  - Root node `CustomLayer` contains the following attributes:
+    - `name` – (Required) The name of the OpenVINO™ Runtime layer to bind the kernel with.
+    - `type` and `version` – (Required) Reserved for future use. Set them to `MVCL` and `1` respectively.
+    - `max-shaves` – (Optional) The maximum number of SHAVE cores that should be dedicated for the layer. It is useful for debugging concurrency issues or for resource saving that memory bound kernel does not scale well with the number of cores, so more resources can be left for the rest of a topology.
+  - Sub-node `Kernel` must contain the following attributes:
+    - `entry` – The name of your kernel function as you defined it in a source file. In the example above, it is `reorg_nhwc`.
+    - Node `Source` must contain the following attributes:
+      - `filename` – The path to a compiled binary relative to the XML configuration file.
+  - Sub-node `Parameters` – Describes parameters bindings. For more information, see the description below.
+  - Sub-node `WorkSizes` – Describes local and global work group sizes and the source for dimension deduction as a pair `direction,port`. In the example above, the work group is described relatively to the dimension of the input tensor that comes through port 0 in the IR. `global` and `local` work group configurations support any simple math expressions with +,-,\*,/, and () from `B`(batch), `Y`(height), `X`(width) and `F`(channels).
+  - Sub-node `Where` – Allows to customize bindings with the `key="value"` attribute. For example, to substitute only 3x3 convolutions, write `<Where kernel="3,3"/>` in the binding xml.
+
+  Parameter description supports `Tensor` of one of tensor types such as `input`, `output`, `input_buffer`, `output_buffer` or `data`, `Scalar`, or `Data` nodes and has the following format:
+  - Each `Tensor` node of `input` or `output` type must contain the following attributes:
+    - `arg-name` – The name of a kernel parameter in the kernel signature.
+    - `type` – Node type: `input` or `output` as specified in the IR.
+    - `port-index` – A number of input/output ports as specified in the IR.
+    - `format` – The channel order in the tensor. Optional conversion layers are generated if the custom layer format is not compatible with formats of neighboring layers. `BFXY`, `BYXF`, and `ANY` formats are supported currently.
+  - Each `Tensor` node of `input_buffer` or `output_buffer` type must contain the following attributes:
+    - `arg-name` – The name of a kernel parameter in the kernel signature.
+    - `type` – Node type: `input_buffer` or `output_buffer`. Use the appropriate type to bind multiple kernels that correspond to different stages of the same layer.
+    - `port-index` – The unique identifier to bind by.
+    - `dim` – The dim source with the same `direction,port` format used for `WorkSizes` bindings.
+    - `size` – Amount of bytes needed. Current expression syntax supports only expression over dimensions of over selected input/output tensor or constants and might be expended in the future.
+
+    Here is an example of multi-stage MVN layer binding:
+  ```xml
+  <CustomLayer name="MVN" stage="0" type="MVCL" version="1">
+      <Kernel entry="reduction_mean">
+          <Source filename="mvn.bin"/>
+      </Kernel>
+      <Parameters>
+          <Tensor arg-name="src"                type="input"         port-index="0"               format="BFYX"/>
+          <Tensor arg-name="mean"               type="output_buffer" port-index="0" dim="output,0" size="Y*F*4"/>
+          <Tensor arg-name="variance"           type="output_buffer" port-index="1" dim="output,0" size="Y*F*4"/>
+          <!--other parameters  -->
+      </Parameters>
+      <WorkSizes dim="output,0" global="((Y+7)/8)*8,F,1" local="8,1,1"/>
+  </CustomLayer>
+  <CustomLayer name="MVN" stage="1" type="MVCL" version="1">
+      <Kernel entry="mvn_scale">
+          <Source filename="mvn_scale_changed_orded.bin"/>
+      </Kernel>
+      <Parameters>
+          <Tensor arg-name="src_data"           type="input"        port-index="0"               format="BFYX"/>
+          <Tensor arg-name="dst_data"           type="output"       port-index="0"               format="BFYX"/>
+          <Tensor arg-name="mean_part"          type="input_buffer" port-index="0" dim="output,0" size="Y*F*4"/>
+          <Tensor arg-name="power_mean"         type="input_buffer" port-index="1" dim="output,0" size="Y*F*4"/>
+          <!--other parameters  -->
+      </Parameters>
+      <WorkSizes dim="output,0" global="((Y+7)/8)*8,F,1" local="8,1,1"/>
+  </CustomLayer>
+  ```
+  - Each `Tensor` node that has the type `data` must contain the following attributes:
+   - `source` – A name of the blob as it is in the IR. Typical example is `weights` for convolution.
+   - `format` – Specifies the channel order in the tensor. Optional conversion layers are generated if the custom layer format is not.
+  ```xml
+  <CustomLayer name="BinaryConvolution" type="MVCL" version="1">
+    <Kernel entry="binary_convolution">
+        <Source filename="binary_layers.bin"/>
+    </Kernel>
+    <Parameters>
+        <Tensor arg-name="src_data"      type="input"   port-index="0"                      format="BFYX"/>
+        <Data   arg-name="weights_data"  type="data"                     source="weights"   format="ANY"/>
+        <Tensor arg-name="dst_data"      type="output"  port-index="0"                      format="BFYX"/>
+        <!--other parameters  -->
+    </Parameters>
+    <WorkSizes dim="output,0" global="X,Y,F" local="1,1,1"/>
+  </CustomLayer>
+  ```
+  - Each `Scalar` node must contain the following attributes:
+   - `arg-name` – The name of a kernel parameter in the kernel signature.
+   - `type` – `int` or `float` value. It is used for correct argument extraction from IR parameters.
+   - `source` – Contains the name of the parameter in the IR file or input/output (`I`/`O`, `In`/`On`, where `n` is a port number)
+   followed by dimension `B`(batch), `Y`(height), `X`(width), or `F`(channels).
+
+  - Each `Data` node must contain the following attributes:
+    - `arg-name` – The name of a kernel parameter in the kernel signature.
+    - `type` – Node type. Currently, `local_data` is the only supported value, which defines buffer allocated in fast local on-chip memory. It is limited to 100KB for all `__local` and
+    `__private` arrays defined inside the kernel as well as all `__local` parameters passed to the kernel. Note that a manual-DMA extension requires double buffering.
+    If the custom layer is detected to run out of local memory, the inference fails.
+    - `dim` – The dim source with the same `direction,port` format used for `WorkSizes` bindings.
+    - `size` – Amount of bytes needed. The current expression syntax supports only expression over dimensions of over selected input/output tensor or constants and may be extended in the future.
+  The example binding below illustrates a kernel with two local buffers passed to the kernel.
+  ```xml
+  <CustomLayer name="GRN" type="MVCL" version="1">
+      <Kernel entry="grn_NCHW">
+          <Source filename="grn.bin"/>
+      </Kernel>
+      <Parameters>
+          <Tensor arg-name="src_data" type="input"         port-index="0"                  format="BFYX"/>
+          <Tensor arg-name="dst_data" type="output"        port-index="0"                  format="BFYX"/>
+          <Data   arg-name="src"      type="local_data"                      dim="input,0" size="X*F*2" />
+          <Data   arg-name="dst"      type="local_data"                      dim="input,0" size="X*F*2" />
+          <Scalar arg-name="C"        type="int"           port-index="0"    source="I.F"               />
+          <Scalar arg-name="bias"     type="float"                           source="bias"              />
+      </Parameters>
+      <WorkSizes dim="input,0" global="X,Y,1" local="X,1,1"/>
+  </CustomLayer>
+```
+
+## Pass Configuration File to OpenVINO™ Runtime
+
+> **NOTE**: If both native and custom layer implementations are present, the custom kernel has a priority over the native one.
+Before loading the network that features the custom layers, provide a separate configuration file and load it using the ov::Core::set_property() method with the "CONFIG_KEY" key and the configuration file name as a value before loading the network that uses custom operations to the plugin:
+
+@snippet docs/snippets/vpu/custom_op.cpp part0
+
+## Optimizing Kernels with OpenCL for VPU (Intel® Neural Compute Stick 2)
+
+This section provides optimization guidelines on writing custom layers with OpenCL for VPU devices. Knowledge about general OpenCL
+programming model and OpenCL kernel language is assumed and not a subject of this section. The OpenCL model mapping to VPU is described in the table below.
+
+| OpenCL Model  | VPU Mapping|
+|-----|----|
+| Device code | Executed on SHAVE cores    |
+| Private memory | Mapped to CMX internal memory, limited to 100KB per work group, valid only while the work group is executed |
+| Local memory   | Mapped to CMX internal memory, limited to 100KB per work group, valid only while the work group is executed |
+| Global memory  | Mapped to DDR, used to pass execution preserved parameters for inputs, outputs, and blobs                |
+| Work group     | Executed on a single SHAVE core iterating over multiple work items      |
+
+Note that by the OpenCL specification, the work group execution order is not specified. This means that it is your
+responsibility to ensure that race conditions among work groups are not introduced. Custom layer runtime spits evenly
+work grid among available compute resources and executes them in an arbitrary order. This static scheduling approach works best if the load is evenly spread out across work groups, which is a typical case for Deep Learning kernels. The following guidelines are recommended to use for work group partitioning:
+
+1. Split work evenly across work groups.
+2. Adjust work group granularity to maintain equal workload for all compute codes.
+3. Set the maximum number of cores using the `max-shaves` attribute for the `CustomLayer` node. This keeps more resources for the rest of topology. It is also useful if the kernel scalability reached its limits, which may happen while optimizing memory bound kernels or kernels with poor parallelization.
+4. Try an alternate data layout (`BFXY`/`BYXF`) for the kernel if it improves work group partitioning or data access patterns.
+Consider not just specific layer boost, but full topology performance because data conversion layers would be automatically inserted
+as appropriate.
+
+Offline OpenCL compiler (`clc`) features automatic vectorization over `get_global_id(0)` usage, if uniform access is detected.
+For example, the kernel below could be automatically vectorized:
+```cpp
+__kernel void cvtf32f16(__global float* restrict inImage, __global half*  restrict outImage,
+                        float   scale, float   bais)
+{
+    int idx = get_global_id(0) + get_global_id(1) * get_global_size(0) + get_global_id(2) * get_global_size(0) * get_global_size(1);
+    outImage[idx] = convert_half(inImage[idx]*scale+bais);
+}
+```
+However, this work-group based vectorizer (WGV) conflicts with the default LLVM vectorizer based on superword level parallelism
+(SLP) for the current compiler version. Manual vectorization is recommended to provide the best performance for non-uniform code
+patterns. WGV works if and only if vector types are not used in the code.
+
+Here is a short list of optimization tips:
+
+1. Help auto-vectorizer ensure non-aliasing pointers for kernel parameters by putting `restrict` where possible.
+  - This can give a performance boost, especially for kernels with unrolling, like `ocl_grn` from the example below.
+  - Place `restrict` markers for kernels with manually vectorized codes. In the `ocl_grn` kernel below, the unrolled version without `restrict` is up to 20% slower than the most optimal one, which combines unrolling and `restrict`.
+2. Put `#&zwj;pragma unroll N` to your loop header. The compiler does not trigger unrolling by default, so it is your responsibility to
+annotate the code with pragmas as appropriate. The `ocl_grn` version with `#&zwj;pragma unroll 4` is up to 50% faster, most of which comes from unrolling the first loop, because LLVM, in general, is better in scheduling 3-stage loops (load-compute-store), while the fist loop
+ `variance += (float)(src_data[c*H*W + y*W + x] * src_data[c*H*W + y*W + x]);` is only 2-stage (load-compute). Pay
+attention to unrolling such cases first. Unrolling factor is loop-dependent. Choose the smallest number that
+still improves performance as an optimum between the kernel size and execution speed. For this specific kernel, changing the unroll factor from `4` to `6` results in the same performance, so unrolling factor equal to 4 is an optimum. For Intel® Neural Compute Stick 2, unrolling is conjugated with the automatic software pipelining for load, store, and compute stages:
+```cpp
+__kernel void ocl_grn(__global const half* restrict src_data, __global half* restrict dst_data, int C, float bias)
+{
+    int x = get_global_id(0);
+    int W = get_global_size(0);
+    int y = get_global_id(1);
+    int H = get_global_size(1);
+    float variance = bias + 1e-9f;
+    #pragma unroll 4
+    for (int c = 0; c < C; c++)
+        variance += (float)(src_data[c*H*W + y*W + x] * src_data[c*H*W + y*W + x]);
+    variance = 1.f / native_sqrt(variance);
+    #pragma unroll 4
+    for (int c = 0; c < C; c++)
+        dst_data[c*H*W + y*W + x] = (half)((float)src_data[c*H*W + y*W + x] * variance);
+}
+```
+To check the efficiency of WGV, you can compare performance of the kernel above with the kernel below, which is manually vectorized over width:
+```cpp
+__kernel void ocl_grn_line(__global const half* restrict src_data,  __global half* restrict dst_data, int C, int W, float bias)
+{
+    int y   = get_global_id(1);
+    int H   = get_global_size(1);
+    for (int x = 0; x < W/8; x++)
+    {
+        float8 variance = (float8)(bias+1e-9f);
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+        {
+            __global const half8* restrict src_line = ((__global const half8 * restrict)(src_data + c*H*W + y*W));
+            half8 sh = src_line[x];
+            variance += convert_float8(sh*sh);
+        }
+        variance = 1.f/native_sqrt(variance);
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+        {
+            __global const half8* restrict src_line = ((__global const half8 * restrict)(src_data + c*H*W + y*W));
+            __global       half8* restrict dst_line = ((__global       half8 * restrict)(dst_data + c*H*W + y*W));
+            dst_line[x] = convert_half8(convert_float8(src_line[x])*variance);
+        }
+    }
+    for (int x = W/8*8; x < W; x++)
+    {
+        float variance = bias+1e-9f;
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+            variance += (float)(src_data[c*H*W + y*W + x]*src_data[c*H*W + y*W + x]);
+        variance = 1.f/native_sqrt(variance);
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+            dst_data[c*H*W + y*W + x] = (float)src_data[c*H*W + y*W + x]*variance;
+    }
+}
+```
+Both versions perform the same, but the second one has more complex code.
+
+3. If it is easy to predict the work group size, you can also use the `reqd_work_group_size` kernel attribute to ask the compiler
+to unroll the code up to the local size of the work group. Note that if the kernel is actually executed with the
+different work group configuration, the result is undefined.
+
+4. Prefer to use the `half` compute if it keeps reasonable accuracy. 16-bit float is a native type for Intel® Neural Compute Stick 2, most of the functions `half_*` are mapped to a single hardware instruction.
+Use the standard `native_*` function for the rest of types.
+
+5. Prefer to use the `convert_half` function over `vstore_half` if conversion to 32-bit float is required. `convert_half` is mapped to a single hardware instruction. For the `cvtf32f16` kernel above, the line `outImage[idx] = convert_half(inImage[idx]*scale+bais);` is eight times slower than the code with `vstore_half`.
+
+6. Mind early exits. Early exit can be extremely costly for the current version of the `clc` compiler due to conflicts with the
+auto-vectorizer. The generic advice would be to setup local size by `x` dimension equal to inputs or/and outputs width.
+If it is impossible to define the work grid that exactly matches inputs or/and outputs to eliminate checks, for example,
+`if (get_global_id(0) >= width) return`, use line-wise kernel variant with manual vectorization. 
+The kernel example below demonstrates the impact of early exits on kernel performance.
+   ```cpp
+   // Initial version
+   __kernel void reorg(const __global half* restrict src, __global half* restrict out, int stride)
+   {
+     int w = get_global_id(0);
+     int W = get_global_size(0);
+     int h = get_global_id(1);
+     int H = get_global_size(1);
+     int c = get_global_id(2);
+     int C = get_global_size(2);
+     int C2 = C/(stride*stride);
+     int offset = c / C2;
+     int c2 = c - C2 * offset;
+     int H2 = H*stride;
+     int W2 = W*stride;
+     int h2 = h*stride + offset / stride;
+     int w2 = w*stride + offset - stride * (offset / stride);
+     out[W*H*c + W*h + w] = src[W2*H2*c2 + W2*h2 + w2];
+   }
+   ```
+This `reorg` kernel is auto-vectorizable, but an input for YOLO v2 topology is `NCHW=<1,64,26,26>` and it is not multiple of vector width, which is `8` for `half` data type. As a result, the Inference Engine does not select the auto-vectorized kernel.
+To compare performance of auto-vectorized and scalar version of the kernel, change the input size to`NCHW=<1,64,26,32>`. This enables the auto-vectorized version to be selected by the Inference Engine and can give you about 30% uplift.
+Since the auto-vectorized version is faster, it makes sense to enable it for the YOLO v2 topology input size by setting the local size multiple of vector, for example, 32, and adjust global sizes accordingly. As a result, the execution work grid exceeds actual input dimension, so out-of-bound checks should be inserted. See the updated kernel version below:
+   ```cpp
+   // Version with out-of-bound checks added
+   __kernel void reorg(const __global half* restrict src, __global half* restrict out, int W, int stride)
+   {
+     int w = get_global_id(0);
+     w = min(w, W-1);
+     int h = get_global_id(1);
+     int H = get_global_size(1);
+     int c = get_global_id(2);
+     int C = get_global_size(2);
+     int C2 = C/(stride*stride);
+     int offset = c / C2;
+     int c2 = c - C2 * offset;
+     int H2 = H*stride;
+     int W2 = W*stride;
+     int h2 = h*stride + offset / stride;
+     int w2 = w*stride + offset - stride * (offset / stride);
+     out[W*H*c + W*h + w] = src[W2*H2*c2 + W2*h2 + w2];
+   }
+   ```
+This code performs the same as the initial kernel above (scalar) due to branching overhead. If you replace min/max expression `w = min(w, W-1);` with `if (w >= W) return;`, runtime increases up to 2x against to code without branching (initial version).<br>
+If branching is inevitable for your element-based kernel, it is recommended to change the scheme to line-based. See the kernel variant below:
+```cpp
+// Line-wise version
+__kernel void reorg(const __global half* restrict src, __global half* restrict out, int H, int W, int stride)
+{
+    int h = min((int)get_global_id(0), H-1);
+    int c = get_global_id(1);
+    int C = get_global_size(1);
+    int C2 = C/(stride*stride);
+    int offset = c / C2;
+    int c2 = c - C2 * offset;
+    int H2 = H*stride;
+    int W2 = W*stride;
+    for (int w = 0; w < W; ++w)
+    {
+        int h2 = h*stride + offset / stride;
+        int w2 = w*stride + offset - stride * (offset / stride);
+        out[W*H*c + W*h + w] = src[W2*H2*c2 + W2*h2 + w2];
+    }
+}
+```
+This decreases the execution time up to 40% against the best performing vectorized kernel without early exits (initial version).
+7. Reuse computations among work items by using line-based kernels or sharing values though `__local` memory.
+8. Improve data access locality. Most of custom kernels are memory bound while convolution and fully connected layers are hardware-implemented. The code below demonstrates a further optimized version of the `reorg` kernel unrolled by `stride`:
+   ```cpp
+   // Unrolled line-wise version
+   __kernel void reorg_unrolled_by_stride(const __global half* restrict src, __global half* restrict dst,
+                                          int H, int W, int stride)
+   {
+     int h = min((int)get_global_id(0), H-1);
+     int c2 = get_global_id(1);
+     int C2 = get_global_size(1);
+     int C = C2*stride*stride;
+     int H2 = H*stride;
+     int W2 = W*stride;
+     for (int stride_y = 0; stride_y < stride; stride_y++)
+       for (int stride_x = 0; stride_x < stride; stride_x++)
+         for (int w2 = 0, w = 0; w < W; w2 += stride, w++)
+           dst[W*H*C2*(stride_y*stride+stride_x) + W*H*c2 + W*h + w] = src[W2*H2*c2 + W2*h*stride + W2*stride_y + w2 + stride_x];
+   }
+   ```
+`scr` data in this case loaded only once. As the result, the cycle count drops up to 45% against the line-wise version.
+
+9. Copy data from `__dlobal` to `__local` or `__private` memory if the data is accessed more than once. Access to
+`__dlobal` memory is orders of magnitude slower than access to `__local`/`__private` due to statically scheduled pipeline, which
+stalls completely on memory access without any prefetch. The same recommendation is applicable for scalar load/store
+from/to a `__blobal` pointer since work-group copying could be done in a vector fashion.
+
+10. Use a manual DMA extension. Local (on-chip) memory throughput is up to 24x higher than DDR throughput. Starting from OpenVINO™ 2020.1, VPU OpenCL features manual-DMA kernel extension to copy sub-tensor used by work group into local memory and performing compute without DDR evolved. Here is the simple GRN kernel implementation that runs over DDR. Local size is in the form (width of the input tensor, 1, 1) to define a large enough work group to get code automatically vectorized and unrolled, while global size is (width of the input tensor, height of the input tensor, 1):
+   ```cpp
+   __kernel void grn_NCHW(
+     __global const half* restrict src_data,
+     __global       half* restrict dst_data,
+     int C,
+     float bias)
+   {
+     float variance = bias + 1e-9f;
+     #pragma unroll 4
+     for (int c = 0; c < C; c++)
+     {
+       float val = (float) src_data[c*get_global_size(1)*get_global_size(0) + get_global_id(1)*get_global_size(0) + get_global_id(0)];
+       variance += val*val;
+     }
+     half hvariance = (half)(native_rsqrt((half)(variance/16.f))*0.25f);
+     #pragma unroll 4
+     for (int c = 0; c < C; c++)
+     {
+       dst_data[c*get_global_size(1)*get_global_size(0) + get_global_id(1)*get_global_size(0) + get_global_id(0)]
+       = src_data[c*get_global_size(1)*get_global_size(0) + get_global_id(1)*get_global_size(0) + get_global_id(0)] * hvariance;
+     }
+   }
+   ```
+
+This kernel can be rewritten to introduce special data binding `__dma_preload` and `__dma_postwrite intrinsics`. This means that instead of one kernel, a group of three kernels should be implemented: `kernelName`, `__dma_preload_kernelName`, and `__dma_postwrite_kernelName`.  `__dma_preload_kernelName` for a particular work group `n` is guaranteed to be executed before the `n`-th work group itself, while `__dma_postwrite_kernelName` is guaranteed to be executed after a corresponding work group. You can define one of those functions that are intended to be used to copy data from-to `__global` and `__local` memory. The syntactics requires exact functional signature match. The example below illustrates how to prepare your kernel for manual-DMA.
+
+   ```cpp
+   __kernel void __dma_preload_grn_NCHW(
+     __global const half* restrict src,
+     __global       half* restrict dst,
+     __local        half* restrict local_src,
+     __local        half* restrict local_dst,
+     int C,
+     float bias)
+     {
+     // ToDO: copy required piece of src tensor into local_src
+   }
+   
+   __kernel void __dma_postwrite_grn_NCHW(
+     __global const half* restrict src,
+     __global       half* restrict dst,
+     __local  const half* restrict local_src,
+     __local        half* restrict local_dst,
+     int C,
+     float bias)
+   {
+     // ToDO: copy back computed piece of local_dst into dst
+   }
+   
+   __kernel void grn_NCHW(
+     __global const half* restrict src_data,
+     __global       half* restrict dst_data,
+     __local        half* restrict src,
+     __local        half* restrict dst,
+     int C,
+     float bias)
+   {
+     // same as the example above
+   }
+   ``` 
+The GRN kernel operates on channel-major tensors to compute average over full channel range and then normalizes input elements to produce the output.
+As a part of the manual DMA extension, a group of work group copy functions are introduced in addition to `async_work_group_copy`, which is also mapped to a DMA call.
+
+Here is the list of supported functions:
+```cpp
+// 2D sub-tensor copy
+event_t WorkGroupDmaCreateStrideTransaction(
+                const local T *src,
+                global T *dst,
+                size_t  src_width, // width of the line of source in bytes
+                size_t  dst_width, // width of the line of destination in bytes
+                size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                size_t size, // total number of bytes loaded for all lines from source to destination
+                event_t  event) __OVERLOAD;
+event_t WorkGroupDmaCreateStrideTransaction(
+                const global T *src,
+                local T *dst,
+                size_t  src_width, // width of the line of source in bytes
+                size_t  dst_width, // width of the line of destination in bytes
+                size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                size_t size, // total number of bytes loaded for all lines from source to destination
+                event_t  event) __OVERLOAD;
+// 3D sub-tensor copy
+event_t WorkGroupDmaCreate3DTransaction(
+                 const local T *src,
+                 global T *dst,
+                 size_t  src_width, // width of the line of source in bytes
+                 size_t  dst_width, // width of the line of destination in bytes
+                 size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                 size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                 size_t  num_planes, // number of planes to be copied
+                 size_t  src_plane_stride, // stride between corresponding 2 consecutive planes of source in bytes
+                 size_t  dst_plane_stride, // stride between corresponding 2 consecutive planes of destination in bytes
+                 size_t  size, // size of the loaded plane in bytes, analogues to the size in 2D case
+                 event_t  event) __OVERLOAD;
+event_t WorkGroupDmaCreate3DTransaction(
+                 const global T *src,
+                 local T *dst,
+                 size_t  src_width, // width of the line of source in bytes
+                 size_t  dst_width, // width of the line of destination in bytes
+                 size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                 size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                 size_t  num_planes, // number of planes to be copied
+                 size_t  src_plane_stride, // stride between corresponding 2 consecutive planes of source in bytes
+                 size_t  dst_plane_stride, // stride between corresponding 2 consecutive planes of destination in bytes
+                 size_t  size, // size of the loaded plane in bytes, analogues to the size in 2D case
+                 event_t  event) __OVERLOAD;
+```
+where `T` can be `uchar`, `char`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `half` or `float`.
+
+Modified version of the GRN kernel could be the following:
+```cpp
+__kernel void __dma_preload_grn_NCHW(
+    __global const half* restrict src,
+    __global       half* restrict dst,
+    __local        half* restrict local_src,
+    __local        half* restrict local_dst,
+    int C,
+    float bias)
+{
+    WorkGroupDmaCreate3DTransaction(
+        src + get_group_id(0)*get_local_size(0)
+            + get_group_id(1)*get_local_size(1)*get_global_size(0), // src
+        local_src, // dst
+        get_local_size(0) * sizeof(half), // src width
+        get_local_size(0) * sizeof(half), // dst width
+        get_global_size(0) * sizeof(half), // src stride
+        get_local_size(0) * sizeof(half), // dst stride
+        C, // num planes
+        get_global_size(0) * get_global_size(1) * sizeof(half), // src plane stride
+        get_local_size(0) * get_local_size(1) * sizeof(half), // dst plane stride
+        get_local_size(0) * get_local_size(1) * sizeof(half), // plane size
+        0);
+}
+__kernel void __dma_postwrite_grn_NCHW(
+    __global const half* restrict src,
+    __global       half* restrict dst,
+    __local  const half* restrict local_src,
+    __local        half* restrict local_dst,
+    int C,
+    float bias)
+{
+    WorkGroupDmaCreate3DTransaction(
+        local_dst, // src
+        dst + get_group_id(0)*get_local_size(0)
+            + get_group_id(1)*get_local_size(1)*get_global_size(0), // dst
+        get_local_size(0) * sizeof(half), // src width
+        get_local_size(0) * sizeof(half), // dst width
+        get_local_size(0) * sizeof(half), // src stride
+        get_global_size(0) * sizeof(half), // dst stride
+        C, // num planes
+        get_local_size(0) * get_local_size(1) * sizeof(half), // src plane stride
+        get_global_size(0) * get_global_size(1) * sizeof(half), // dst plane stride
+        get_local_size(0) * get_local_size(1) * sizeof(half), // plane size
+        0);
+}
+__kernel void grn_NCHW(
+    __global const half* restrict src_data,
+    __global       half* restrict dst_data,
+    __local        half* restrict src,
+    __local        half* restrict dst,
+    int C,
+    float bias)
+{
+    float variance = bias + 1e-9f;
+    #pragma unroll 8
+    for (int c = 0; c < C; c++)
+    {
+        float val = (float) src[c*get_local_size(1)*get_local_size(0) + get_local_id(1)*get_local_size(0) + get_local_id(0)];
+        variance += val*val;
+    }
+    half hvariance = (half)(native_rsqrt((half)(variance/16.f))*0.25f);
+    #pragma unroll 8
+    for (int c = 0; c < C; c++)
+    {
+        dst[c*get_local_size(1)*get_local_size(0) + get_local_id(1)*get_local_size(0) + get_local_id(0)]
+        = src[c*get_local_size(1)*get_local_size(0) + get_local_id(1)*get_local_size(0) + get_local_id(0)] * hvariance;
+    }
+}
+```
+
+Note the `get_local_size` and `get_local_id` usage inside the kernel. 21x speedup is expected for a kernel on enet-curbs setup because it was completely limited by memory usage.
+
+An alternative method to using DMA is to use work item copy extension. Those functions are executed inside a kernel and requires work groups equal to single work item.
+
+Here is the list of supported work item functions:
+```cpp
+item_dma_event_t WorkItemDmaCreateTransaction(
+            const global T *src,
+            private T *dst,
+            size_t  size,
+            item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreateTransaction(
+            const private T *src,
+            global T *dst,
+            size_t  size,
+            item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreateStrideTransaction(
+                const global T *src,
+                private T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t size,
+                item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreateStrideTransaction(
+                const private T *src,
+                global T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t size,
+                item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreate3DTransaction(
+                const global T *src,
+                private T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t  num_planes,
+                size_t  src_plane_stride,
+                size_t  dst_plane_stride,
+                size_t  size,
+                item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreate3DTransaction(
+                const private T *src,
+                global T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t  num_planes,
+                size_t  src_plane_stride,
+                size_t  dst_plane_stride,
+                size_t  size,
+                item_dma_event_t  event) __OVERLOAD;
+```
+where `T` can be `uchar`, `char`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `half` or `float`.

docs/Extensibility_UG/add_openvino_ops.md

@@ -1,4 +1,4 @@
-# Custom OpenVINO™ Operations {#openvino_docs_Extensibility_UG_add_openvino_ops}
+# Custom OpenVINO™ Operations {#openvino_docs_Extensibility_UG_add_openvino_ops}
 
 OpenVINO™ Extension API allows you to register custom operations to support models with operations which OpenVINO™ does not support out-of-the-box.
 
@@ -20,14 +20,10 @@ Follow the steps below to add a custom operation:
 
 5. Override the `visit_attributes` method, which enables serialization and deserialization of operation attributes. An `AttributeVisitor` is passed to the method, and the implementation is expected to walk over all the attributes in the op using the type-aware `on_attribute` helper. Helpers are already implemented for standard C++ types like `int64_t`, `float`, `bool`, `vector`, and for existing OpenVINO defined types.
 
-6. Override `evaluate`, which is an optional method that enables fallback of some devices to this implementation and the application of constant folding if there is a custom operation on the constant branch. If your operation contains `evaluate` method you also need to override the `has_evaluate` method, this method allow to get information about availability of `evaluate` method for the operation.
-
-7. Add the `OPENVINO_FRAMEWORK_MAP` macro if you want to map custom operation to framework operation with the same name. It is an optional macro which can be used for one to one mapping. In order to use this macro please include frontend specific headers:
-   @snippet template_extension/new/identity.hpp op:frontend_include
+6. Override `evaluate`, which is an optional method that enables fallback of some devices to this implementation and the application of constant folding if there is a custom operation on the constant branch. If your operation contains `evaluate` method you also need to override the `has_evaluate` method, this method allows to get information about availability of `evaluate` method for the operation.
 
 Based on that, declaration of an operation class can look as follows:
 
-@snippet template_extension/new/identity.hpp op:header
 
 ### Operation Constructors
 
@@ -55,8 +51,9 @@ OpenVINO™ operation contains two constructors:
 
 @snippet template_extension/new/identity.cpp op:visit_attributes
 
-### `evaluate()` and `has_evaluate()`
+### evaluate() and has_evaluate()
 
 `ov::Node::evaluate` method enables you to apply constant folding to an operation.
 
 @snippet template_extension/new/identity.cpp op:evaluate
+

docs/Extensibility_UG/frontend_extensions.md

@@ -0,0 +1,105 @@
+# 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.
+
+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.
+
+> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/docs/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.
+
+## 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.
+
+2. Number of outputs is also the same in both representations.
+
+3. Inputs can be indexed and are mapped in order correspondingly, e.g. input with index 0 in framework representation maps to input with index 0 in OpenVINO representation and so on.
+
+4. The same for outputs.
+
+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.
+
+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
+
+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:
+
+@snippet ov_extensions.cpp 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).
+
+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
+
+`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:
+
+@snippet ov_extensions.cpp frontend_extension_MyRelu
+
+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`.
+
+### Attributes Mapping
+
+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.
+
+Imagine you have CustomOperation class implementation that has two attributes with names `attr1` and `attr2`:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation
+
+And original model in framework representation also has operation with name “CustomOperatoin” with the same `attr1` and `attr2` attributes. Then with the following code:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation_as_is
+
+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:
+
+@snippet ov_extensions.cpp 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:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation_rename_set
+
+So the conclusion is that each attribute of target OpenVINO operation should be initialized either by
+
+1. Setting automatically due to name matching
+
+2. Mapped by attribute name
+
+3. Set to a constant value
+
+This is achieved by specifying maps as arguments for `OpExtension` constructor.
+
+
+## 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.
+
+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 [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))`.
+
+> **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`.
+
+@snippet ov_extensions.cpp frontend_extension_ThresholdedReLU_header
+@snippet ov_extensions.cpp 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.
+

docs/Extensibility_UG/ov_transformations.md

@@ -12,6 +12,7 @@
 
 @endsphinxdirective
 
+OpenVINO Transformation mechanism allows to develop transformation passes to modify `ov::Model`. You can use this mechanism to apply additional optimizations to the original Model or transform unsupported subgraphs and operations to new operations which are supported by the plugin.
 This guide contains all necessary information that you need to start implementing OpenVINO™ transformations.
 
 ## Working with Model

docs/IE_PLUGIN_DG/ExecutableNetwork.md

@@ -37,7 +37,7 @@ The implementation `CompileNetwork` is fully device-specific.
 
 The function accepts a const shared pointer to `ngraph::Function` object and performs the following steps:
 
-1. Applies ngraph passes using `TransformNetwork` function, which defines plugin-specific conversion pipeline. To support low precision inference, the pipeline can include Low Precision Transformations. These transformations are usually hardware specific. You can find how to use and configure Low Precisions Transformations in [Low Precision Transformations](@ref openvino_docs_IE_DG_lpt) guide.
+1. Applies ngraph passes using `TransformNetwork` function, which defines plugin-specific conversion pipeline. To support low precision inference, the pipeline can include Low Precision Transformations. These transformations are usually hardware specific. You can find how to use and configure Low Precisions Transformations in [Low Precision Transformations](@ref openvino_docs_OV_UG_lpt) guide.
 2. Maps the transformed graph to a backend specific graph representation (for example, to MKLDNN graph for Intel CPU).
 3. Allocates and fills memory for graph weights, backend specific memory handles and so on.
 

docs/IE_PLUGIN_DG/Intro.md

@@ -9,11 +9,12 @@
 
    Implement Plugin Functionality <openvino_docs_ie_plugin_dg_plugin>
    Implement Executable Network Functionality <openvino_docs_ie_plugin_dg_executable_network>
-   openvino_docs_ie_plugin_dg_quantized_networks
    Implement Synchronous Inference Request <openvino_docs_ie_plugin_dg_infer_request>
    Implement Asynchronous Inference Request <openvino_docs_ie_plugin_dg_async_infer_request>
    openvino_docs_ie_plugin_dg_plugin_build
    openvino_docs_ie_plugin_dg_plugin_testing
+   openvino_docs_ie_plugin_detailed_guides
+   openvino_docs_ie_plugin_api_references
 
 @endsphinxdirective
 
@@ -55,11 +56,11 @@ Detailed guides
 * [Build](@ref openvino_docs_ie_plugin_dg_plugin_build) a plugin library using CMake\*
 * Plugin and its components [testing](@ref openvino_docs_ie_plugin_dg_plugin_testing)
 * [Quantized networks](@ref openvino_docs_ie_plugin_dg_quantized_networks)
-* [Low precision transformations](@ref openvino_docs_IE_DG_lpt) guide
+* [Low precision transformations](@ref openvino_docs_OV_UG_lpt) guide
 * [Writing OpenVINO™ transformations](@ref openvino_docs_transformations) guide
 
 API References
 -----------------------
 
-* [Inference Engine Plugin API](groupie_dev_api.html)
-* [Inference Engine Transformation API](groupie_transformation_api.html)
+* [Inference Engine Plugin API](@ref ie_dev_api)
+* [Inference Engine Transformation API](@ref ie_transformation_api)

docs/IE_PLUGIN_DG/QuantizedNetworks.md

@@ -9,7 +9,7 @@ For more details about low-precision model representation please refer to this [
 During the model load each plugin can interpret quantization rules expressed in *FakeQuantize* operations:
 - Independently based on the definition of *FakeQuantize* operation.
 - Using a special library of low-precision transformations (LPT) which applies common rules for generic operations,
-such as Convolution, Fully-Connected, Eltwise, etc., and translates "fake-quantized" models into the models with low-precision operations. For more information about low-precision flow please refer to the following [document](@ref openvino_docs_IE_DG_Int8Inference). 
+such as Convolution, Fully-Connected, Eltwise, etc., and translates "fake-quantized" models into models with low-precision operations.
 
 Here we provide only a high-level overview of the interpretation rules of FakeQuantize. 
 At runtime each FakeQuantize can be split into two independent operations: **Quantize** and **Dequantize**. 

docs/IE_PLUGIN_DG/detailed_guides.md

@@ -0,0 +1,18 @@
+# Advanced Topics {#openvino_docs_ie_plugin_detailed_guides}
+
+@sphinxdirective
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   openvino_docs_ie_plugin_dg_quantized_networks
+   openvino_docs_OV_UG_lpt
+
+@endsphinxdirective
+
+The guides below provides extra information about specific features of OpenVINO needed for understanding during OpenVINO plugin development:
+
+* [Quantized networks](@ref openvino_docs_ie_plugin_dg_quantized_networks)
+* [Low precision transformations](@ref openvino_docs_OV_UG_lpt) guide
+* [Writing OpenVINO™ transformations](@ref openvino_docs_transformations) guide

docs/IE_PLUGIN_DG/dev_api_references.md

@@ -0,0 +1,17 @@
+# Plugin API Reference {#openvino_docs_ie_plugin_api_references}
+
+@sphinxdirective
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   ../groupie_dev_api
+   ../groupie_transformation_api
+
+@endsphinxdirective
+
+The guides below provides extra API references needed for OpenVINO plugin development:
+
+* [OpenVINO Plugin API](@ref ie_dev_api)
+* [OpenVINO Transformation API](@ref ie_transformation_api)

docs/IE_PLUGIN_DG/layout.xml

@@ -5,74 +5,74 @@
             <tab type="usergroup" url="index.html" title="Developer Guide for Inference Engine Plugin Library">
                 <tab type="user" url="@ref plugin" visibile="yes" title="Implement Plugin Functionality"/>
                 <tab type="user" url="@ref executable_network" visibile="yes" title="Implement Executable Network Functionality">
-                    <tab type="usergroup" title="Low Precision Transformations" url="@ref openvino_docs_IE_DG_lpt">
-                        <tab type="user" title="Attributes" url="@ref openvino_docs_IE_DG_lpt_attributes">
-                            <tab type="user" title="AvgPoolPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved"/>
-                            <tab type="user" title="IntervalsAlignment" url="@ref openvino_docs_IE_DG_lpt_IntervalsAlignment"/>
-                            <tab type="user" title="PerTensorQuantization" url="@ref openvino_docs_IE_DG_lpt_PerTensorQuantization"/>
-                            <tab type="user" title="PrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_PrecisionPreserved"/>
-                            <tab type="user" title="Precisions" url="@ref openvino_docs_IE_DG_lpt_Precisions"/>
-                            <tab type="user" title="QuantizationAlignment" url="@ref openvino_docs_IE_DG_lpt_QuantizationAlignment"/>
+                    <tab type="usergroup" title="Low Precision Transformations" url="@ref openvino_docs_OV_UG_lpt">
+                        <tab type="user" title="Attributes" url="@ref openvino_docs_OV_UG_lpt_attributes">
+                            <tab type="user" title="AvgPoolPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved"/>
+                            <tab type="user" title="IntervalsAlignment" url="@ref openvino_docs_OV_UG_lpt_IntervalsAlignment"/>
+                            <tab type="user" title="PerTensorQuantization" url="@ref openvino_docs_OV_UG_lpt_PerTensorQuantization"/>
+                            <tab type="user" title="PrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_PrecisionPreserved"/>
+                            <tab type="user" title="Precisions" url="@ref openvino_docs_OV_UG_lpt_Precisions"/>
+                            <tab type="user" title="QuantizationAlignment" url="@ref openvino_docs_OV_UG_lpt_QuantizationAlignment"/>
                         </tab>
-                        <tab type="user" title="Step 1. Prerequisites transformations" url="@ref openvino_docs_IE_DG_lpt_step1_prerequisites">
-                            <tab type="user" title="LinOpSequenceFusion" url="@ref openvino_docs_IE_DG_lpt_LinOpSequenceFusion"/>
-                            <tab type="user" title="PullReshapeThroughDequantization" url="@ref openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization"/>
-                            <tab type="user" title="PullTransposeThroughDequantization" url="@ref openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization"/>
+                        <tab type="user" title="Step 1. Prerequisites transformations" url="@ref openvino_docs_OV_UG_lpt_step1_prerequisites">
+                            <tab type="user" title="LinOpSequenceFusion" url="@ref openvino_docs_OV_UG_lpt_LinOpSequenceFusion"/>
+                            <tab type="user" title="PullReshapeThroughDequantization" url="@ref openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization"/>
+                            <tab type="user" title="PullTransposeThroughDequantization" url="@ref openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization"/>
                         </tab>
-                        <tab type="user" title="Step 2. Markup transformations" url="@ref openvino_docs_IE_DG_lpt_step2_markup">
-                            <tab type="user" title="AlignQuantizationIntervals" url="@ref openvino_docs_IE_DG_lpt_AlignQuantizationIntervals"/>
-                            <tab type="user" title="AlignQuantizationParameters" url="@ref openvino_docs_IE_DG_lpt_AlignQuantizationParameters"/>
-                            <tab type="user" title="CreateAttribute" url="@ref openvino_docs_IE_DG_lpt_CreateAttribute"/>
-                            <tab type="user" title="CreatePrecisionsDependentAttribute" url="@ref openvino_docs_IE_DG_lpt_CreatePrecisionsDependentAttribute"/>
-                            <tab type="user" title="MarkupAvgPoolPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved"/>
-                            <tab type="user" title="MarkupCanBeQuantized" url="@ref openvino_docs_IE_DG_lpt_MarkupCanBeQuantized"/>
-                            <tab type="user" title="MarkupPerTensorQuantization" url="@ref openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization"/>
-                            <tab type="user" title="MarkupPrecisions" url="@ref openvino_docs_IE_DG_lpt_MarkupPrecisions"/>
-                            <tab type="user" title="PropagatePrecisions" url="@ref openvino_docs_IE_DG_lpt_PropagatePrecisions"/>
-                            <tab type="user" title="PropagateThroughPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_PropagateThroughPrecisionPreserved"/>
-                            <tab type="user" title="PropagateToInput" url="@ref openvino_docs_IE_DG_lpt_PropagateToInput"/>
-                            <tab type="user" title="UpdateSharedPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_UpdateSharedPrecisionPreserved"/>
+                        <tab type="user" title="Step 2. Markup transformations" url="@ref openvino_docs_OV_UG_lpt_step2_markup">
+                            <tab type="user" title="AlignQuantizationIntervals" url="@ref openvino_docs_OV_UG_lpt_AlignQuantizationIntervals"/>
+                            <tab type="user" title="AlignQuantizationParameters" url="@ref openvino_docs_OV_UG_lpt_AlignQuantizationParameters"/>
+                            <tab type="user" title="CreateAttribute" url="@ref openvino_docs_OV_UG_lpt_CreateAttribute"/>
+                            <tab type="user" title="CreatePrecisionsDependentAttribute" url="@ref openvino_docs_OV_UG_lpt_CreatePrecisionsDependentAttribute"/>
+                            <tab type="user" title="MarkupAvgPoolPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved"/>
+                            <tab type="user" title="MarkupCanBeQuantized" url="@ref openvino_docs_OV_UG_lpt_MarkupCanBeQuantized"/>
+                            <tab type="user" title="MarkupPerTensorQuantization" url="@ref openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization"/>
+                            <tab type="user" title="MarkupPrecisions" url="@ref openvino_docs_OV_UG_lpt_MarkupPrecisions"/>
+                            <tab type="user" title="PropagatePrecisions" url="@ref openvino_docs_OV_UG_lpt_PropagatePrecisions"/>
+                            <tab type="user" title="PropagateThroughPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_PropagateThroughPrecisionPreserved"/>
+                            <tab type="user" title="PropagateToInput" url="@ref openvino_docs_OV_UG_lpt_PropagateToInput"/>
+                            <tab type="user" title="UpdateSharedPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_UpdateSharedPrecisionPreserved"/>
                         </tab>
-                        <tab type="user" title="Step 3. Main transformations" url="@ref openvino_docs_IE_DG_lpt_step3_main">
-                            <tab type="user" title="AddTransformation" url="@ref openvino_docs_IE_DG_lpt_AddTransformation"/>
-                            <tab type="user" title="AvgPoolTransformation" url="@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation"/>
-                            <tab type="user" title="ClampTransformation" url="@ref openvino_docs_IE_DG_lpt_ClampTransformation"/>
-                            <tab type="user" title="ConcatTransformation" url="@ref openvino_docs_IE_DG_lpt_ConcatTransformation"/>
-                            <tab type="user" title="ConvolutionTransformation" url="@ref openvino_docs_IE_DG_lpt_ConvolutionTransformation"/>
-                            <tab type="user" title="ConvolutionBackpropDataTransformation" url="@ref openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation"/>
-                            <tab type="user" title="DepthToSpaceTransformation" url="@ref openvino_docs_IE_DG_lpt_DepthToSpaceTransformation"/>
-                            <tab type="user" title="FakeQuantizeDecompositionTransformation" url="@ref openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation"/>
-                            <tab type="user" title="FakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FakeQuantizeTransformation"/>
-                            <tab type="user" title="InterpolateTransformation" url="@ref openvino_docs_IE_DG_lpt_InterpolateTransformation"/>
-                            <tab type="user" title="GroupConvolutionTransformation" url="@ref openvino_docs_IE_DG_lpt_GroupConvolutionTransformation"/>
-                            <tab type="user" title="MatMulTransformation" url="@ref openvino_docs_IE_DG_lpt_MatMulTransformation"/>
-                            <tab type="user" title="MaxPoolTransformation" url="@ref openvino_docs_IE_DG_lpt_MaxPoolTransformation"/>
-                            <tab type="user" title="MultiplyTransformation" url="@ref openvino_docs_IE_DG_lpt_MultiplyTransformation"/>
-                            <tab type="user" title="MVNTransformation" url="@ref openvino_docs_IE_DG_lpt_MVNTransformation"/>
-                            <tab type="user" title="NormalizeL2Transformation" url="@ref openvino_docs_IE_DG_lpt_NormalizeL2Transformation"/>
-                            <tab type="user" title="PadTransformation" url="@ref openvino_docs_IE_DG_lpt_PadTransformation"/>
-                            <tab type="user" title="PReluTransformation" url="@ref openvino_docs_IE_DG_lpt_PReluTransformation"/>
-                            <tab type="user" title="ReduceMaxTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceMaxTransformation"/>
-                            <tab type="user" title="ReduceMeanTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceMeanTransformation"/>
-                            <tab type="user" title="ReduceMinTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceMinTransformation"/>
-                            <tab type="user" title="ReduceSumTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceSumTransformation"/>
-                            <tab type="user" title="ReluTransformation" url="@ref openvino_docs_IE_DG_lpt_ReluTransformation"/>
-                            <tab type="user" title="ReshapeTransformation" url="@ref openvino_docs_IE_DG_lpt_ReshapeTransformation"/>
-                            <tab type="user" title="SqueezeTransformation" url="@ref openvino_docs_IE_DG_lpt_SqueezeTransformation"/>
-                            <tab type="user" title="ShuffleChannelsTransformation" url="@ref openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation"/>
-                            <tab type="user" title="SplitTransformation" url="@ref openvino_docs_IE_DG_lpt_SplitTransformation"/>
-                            <tab type="user" title="StridedSliceTransformation" url="@ref openvino_docs_IE_DG_lpt_StridedSliceTransformation"/>
-                            <tab type="user" title="TransposeTransformation" url="@ref openvino_docs_IE_DG_lpt_TransposeTransformation"/>
-                            <tab type="user" title="UnsqueezeTransformation" url="@ref openvino_docs_IE_DG_lpt_UnsqueezeTransformation"/>
-                            <tab type="user" title="VariadicSplitTransformation" url="@ref openvino_docs_IE_DG_lpt_VariadicSplitTransformation"/>
+                        <tab type="user" title="Step 3. Main transformations" url="@ref openvino_docs_OV_UG_lpt_step3_main">
+                            <tab type="user" title="AddTransformation" url="@ref openvino_docs_OV_UG_lpt_AddTransformation"/>
+                            <tab type="user" title="AvgPoolTransformation" url="@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation"/>
+                            <tab type="user" title="ClampTransformation" url="@ref openvino_docs_OV_UG_lpt_ClampTransformation"/>
+                            <tab type="user" title="ConcatTransformation" url="@ref openvino_docs_OV_UG_lpt_ConcatTransformation"/>
+                            <tab type="user" title="ConvolutionTransformation" url="@ref openvino_docs_OV_UG_lpt_ConvolutionTransformation"/>
+                            <tab type="user" title="ConvolutionBackpropDataTransformation" url="@ref openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation"/>
+                            <tab type="user" title="DepthToSpaceTransformation" url="@ref openvino_docs_OV_UG_lpt_DepthToSpaceTransformation"/>
+                            <tab type="user" title="FakeQuantizeDecompositionTransformation" url="@ref openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation"/>
+                            <tab type="user" title="FakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FakeQuantizeTransformation"/>
+                            <tab type="user" title="InterpolateTransformation" url="@ref openvino_docs_OV_UG_lpt_InterpolateTransformation"/>
+                            <tab type="user" title="GroupConvolutionTransformation" url="@ref openvino_docs_OV_UG_lpt_GroupConvolutionTransformation"/>
+                            <tab type="user" title="MatMulTransformation" url="@ref openvino_docs_OV_UG_lpt_MatMulTransformation"/>
+                            <tab type="user" title="MaxPoolTransformation" url="@ref openvino_docs_OV_UG_lpt_MaxPoolTransformation"/>
+                            <tab type="user" title="MultiplyTransformation" url="@ref openvino_docs_OV_UG_lpt_MultiplyTransformation"/>
+                            <tab type="user" title="MVNTransformation" url="@ref openvino_docs_OV_UG_lpt_MVNTransformation"/>
+                            <tab type="user" title="NormalizeL2Transformation" url="@ref openvino_docs_OV_UG_lpt_NormalizeL2Transformation"/>
+                            <tab type="user" title="PadTransformation" url="@ref openvino_docs_OV_UG_lpt_PadTransformation"/>
+                            <tab type="user" title="PReluTransformation" url="@ref openvino_docs_OV_UG_lpt_PReluTransformation"/>
+                            <tab type="user" title="ReduceMaxTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceMaxTransformation"/>
+                            <tab type="user" title="ReduceMeanTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceMeanTransformation"/>
+                            <tab type="user" title="ReduceMinTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceMinTransformation"/>
+                            <tab type="user" title="ReduceSumTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceSumTransformation"/>
+                            <tab type="user" title="ReluTransformation" url="@ref openvino_docs_OV_UG_lpt_ReluTransformation"/>
+                            <tab type="user" title="ReshapeTransformation" url="@ref openvino_docs_OV_UG_lpt_ReshapeTransformation"/>
+                            <tab type="user" title="SqueezeTransformation" url="@ref openvino_docs_OV_UG_lpt_SqueezeTransformation"/>
+                            <tab type="user" title="ShuffleChannelsTransformation" url="@ref openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation"/>
+                            <tab type="user" title="SplitTransformation" url="@ref openvino_docs_OV_UG_lpt_SplitTransformation"/>
+                            <tab type="user" title="StridedSliceTransformation" url="@ref openvino_docs_OV_UG_lpt_StridedSliceTransformation"/>
+                            <tab type="user" title="TransposeTransformation" url="@ref openvino_docs_OV_UG_lpt_TransposeTransformation"/>
+                            <tab type="user" title="UnsqueezeTransformation" url="@ref openvino_docs_OV_UG_lpt_UnsqueezeTransformation"/>
+                            <tab type="user" title="VariadicSplitTransformation" url="@ref openvino_docs_OV_UG_lpt_VariadicSplitTransformation"/>
                         </tab>
-                        <tab type="user" title="Step 4. Cleanup transformations" url="@ref openvino_docs_IE_DG_lpt_step4_cleanup">
-                            <tab type="user" title="FoldConvertTransformation" url="@ref openvino_docs_IE_DG_lpt_FoldConvertTransformation"/>
-                            <tab type="user" title="FoldFakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation"/>
-                            <tab type="user" title="FuseConvertTransformation" url="@ref openvino_docs_IE_DG_lpt_FuseConvertTransformation"/>
-                            <tab type="user" title="FuseMultiplyToFakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation"/>
-                            <tab type="user" title="FuseSubtractToFakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation"/>
-                            <tab type="user" title="MultiplyToGroupConvolutionTransformation" url="@ref openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation"/>
+                        <tab type="user" title="Step 4. Cleanup transformations" url="@ref openvino_docs_OV_UG_lpt_step4_cleanup">
+                            <tab type="user" title="FoldConvertTransformation" url="@ref openvino_docs_OV_UG_lpt_FoldConvertTransformation"/>
+                            <tab type="user" title="FoldFakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation"/>
+                            <tab type="user" title="FuseConvertTransformation" url="@ref openvino_docs_OV_UG_lpt_FuseConvertTransformation"/>
+                            <tab type="user" title="FuseMultiplyToFakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation"/>
+                            <tab type="user" title="FuseSubtractToFakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation"/>
+                            <tab type="user" title="MultiplyToGroupConvolutionTransformation" url="@ref openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation"/>
                         </tab>
                     </tab>
                 </tab>

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/PluginTransformationPipeline.md

@@ -1,17 +0,0 @@
-# Plugin Transformation Pipeline {#openvino_docs_IE_DG_plugin_transformation_pipeline}
-
-@sphinxdirective
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Executable Network
-   :hidden:
-
-   Low Precision Transformations <openvino_docs_IE_DG_lpt>
-
-@endsphinxdirective
-
-Typical plugin transformation pipeline includes steps:
-  1. Common transformations
-  2. [Low precision transformations](@ref openvino_docs_IE_DG_lpt)
-  3. Plugin specific transformations

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/avg_pool_precision_preserved.md

@@ -1,4 +1,4 @@
-# AvgPoolPrecisionPreserved attribute {#openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved}
+# AvgPoolPrecisionPreserved attribute {#openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved}
 
 ngraph::AvgPoolPrecisionPreservedAttribute class represents the `AvgPoolPrecisionPreserved` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/intervals_alignment.md

@@ -1,4 +1,4 @@
-# IntervalsAlignment attribute {#openvino_docs_IE_DG_lpt_IntervalsAlignment}
+# IntervalsAlignment attribute {#openvino_docs_OV_UG_lpt_IntervalsAlignment}
 
 ngraph::IntervalsAlignmentAttribute class represents the `IntervalsAlignment` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/per_tensor_quantization.md

@@ -1,4 +1,4 @@
-# PerTensorQuantization attribute {#openvino_docs_IE_DG_lpt_PerTensorQuantization}
+# PerTensorQuantization attribute {#openvino_docs_OV_UG_lpt_PerTensorQuantization}
 
 ngraph::PerTensorQuantizationAttribute class represents the `PerTensorQuantization` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/precision_preserved.md

@@ -1,4 +1,4 @@
-# PrecisionPreserved attribute {#openvino_docs_IE_DG_lpt_PrecisionPreserved}
+# PrecisionPreserved attribute {#openvino_docs_OV_UG_lpt_PrecisionPreserved}
 
 ngraph::PrecisionPreservedAttribute class represents the `PrecisionPreserved` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/precisions.md

@@ -1,4 +1,4 @@
-# Precisions attribute {#openvino_docs_IE_DG_lpt_Precisions}
+# Precisions attribute {#openvino_docs_OV_UG_lpt_Precisions}
 
 ngraph::PrecisionsAttribute class represents the `Precisions` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/quantization_alignment.md

@@ -1,4 +1,4 @@
-# QuantizationAlignment attribute {#openvino_docs_IE_DG_lpt_QuantizationAlignment}
+# QuantizationAlignment attribute {#openvino_docs_OV_UG_lpt_QuantizationAlignment}
 
 ngraph::QuantizationAlignmentAttribute class represents the `QuantizationAlignment` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/lpt.md

@@ -1,4 +1,4 @@
-# OpenVINO™ Low Precision Transformations {#openvino_docs_IE_DG_lpt}
+# OpenVINO™ Low Precision Transformations {#openvino_docs_OV_UG_lpt}
 
 @sphinxdirective
 
@@ -7,13 +7,13 @@
    :caption: Low Precision Transformations
    :hidden:
 
-   Low Precision Transformations <openvino_docs_IE_DG_lpt>
+   Low Precision Transformations <openvino_docs_OV_UG_lpt>
 
-   Attributes <openvino_docs_IE_DG_lpt_attributes>
-   Step 1. Prerequisites transformations <openvino_docs_IE_DG_lpt_step1_prerequisites>
-   Step 2. Markup transformations <openvino_docs_IE_DG_lpt_step2_markup>
-   Step 3. Main transformations <openvino_docs_IE_DG_lpt_step3_main>
-   Step 4. Cleanup transformations <openvino_docs_IE_DG_lpt_step4_cleanup>
+   Attributes <openvino_docs_OV_UG_lpt_attributes>
+   Step 1. Prerequisites transformations <openvino_docs_OV_UG_lpt_step1_prerequisites>
+   Step 2. Markup transformations <openvino_docs_OV_UG_lpt_step2_markup>
+   Step 3. Main transformations <openvino_docs_OV_UG_lpt_step3_main>
+   Step 4. Cleanup transformations <openvino_docs_OV_UG_lpt_step4_cleanup>
 
 @endsphinxdirective
 
@@ -72,11 +72,7 @@ For example, if you would like to infer a model with `Convolution` operation in
 > There are several supported quantization approaches on activations and on weights. All supported approaches are described in [Quantization approaches](#quantization-approaches) section below. In demonstrated model [FakeQuantize operation quantization](#fakequantize-operation) approach is used.
 
 ### Low precision tools
-There are two tools to quantize a model:
-1. [Post-Training Optimization Toolkit](@ref pot_docs_LowPrecisionOptimizationGuide) (POT)
-2. [Neural Network Compression Framework](https://github.com/openvinotoolkit/nncf) (NNCF)
-
-Additionally, low precision transformations can handle ONNX quantized models.
+For more details on how to get a quantized model, refer to [Model Optimization](@ref openvino_docs_model_optimization_guide) document.
 
 ## Quantization approaches
 LPT transformations support two quantization approaches:
@@ -115,63 +111,63 @@ Inside each step LPT transformations handle input model operation by operation,
 As result, usually all operations are inferred by plugin in low precision. If plugin doesn't support an operation inference in low precision, then corresponding LPT transformation can be disabled, and input tensor precisions for the operation will not be changed. In this case the operation is inferred in the original precision. 
 
 Low precision transformations pipeline includes four steps:
-* [Step #1: Prerequisites](@ref openvino_docs_IE_DG_lpt_step1_prerequisites)
-* [Step #2: Markup transformations](@ref openvino_docs_IE_DG_lpt_step2_markup)
-* [Step #3: Main transformations](@ref openvino_docs_IE_DG_lpt_step3_main)
-* [Step #4: Cleanup transformations](@ref openvino_docs_IE_DG_lpt_step4_cleanup)
+* [Step #1: Prerequisites](@ref openvino_docs_OV_UG_lpt_step1_prerequisites)
+* [Step #2: Markup transformations](@ref openvino_docs_OV_UG_lpt_step2_markup)
+* [Step #3: Main transformations](@ref openvino_docs_OV_UG_lpt_step3_main)
+* [Step #4: Cleanup transformations](@ref openvino_docs_OV_UG_lpt_step4_cleanup)
 
 ### Step 1. Prerequisites
 This step fuses and propagates some operations in the model to prepare for the next step. It is required for OpenVINO plugins. Transformations:
-* [PullReshapeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization)
-* [PullTransposeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization)
-* [LinOpSequenceFusion](@ref openvino_docs_IE_DG_lpt_LinOpSequenceFusion)
+* [PullReshapeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization)
+* [PullTransposeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization)
+* [LinOpSequenceFusion](@ref openvino_docs_OV_UG_lpt_LinOpSequenceFusion)
 
-The model on this step is changed. There are more details in developer guide [Prerequisites transformations](@ref openvino_docs_IE_DG_lpt_step1_prerequisites).
+The model on this step is changed. There are more details in developer guide [Prerequisites transformations](@ref openvino_docs_OV_UG_lpt_step1_prerequisites).
 
 ### Step 2. Markup
 This step creates runtime attributes for operations. These attributes will be used in next step. Transformations:
-* [MarkupCanBeQuantized](@ref openvino_docs_IE_DG_lpt_MarkupCanBeQuantized)
-* [MarkupPrecisions](@ref openvino_docs_IE_DG_lpt_MarkupPrecisions)
-* [MarkupPerTensorQuantization](@ref openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization)
-* [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved)
-* [PropagatePrecisions](@ref openvino_docs_IE_DG_lpt_PropagatePrecisions)
-* [AlignQuantizationIntervals](@ref openvino_docs_IE_DG_lpt_AlignQuantizationIntervals)
-* [AlignQuantizationParameters](@ref openvino_docs_IE_DG_lpt_AlignQuantizationParameters)
+* [MarkupCanBeQuantized](@ref openvino_docs_OV_UG_lpt_MarkupCanBeQuantized)
+* [MarkupPrecisions](@ref openvino_docs_OV_UG_lpt_MarkupPrecisions)
+* [MarkupPerTensorQuantization](@ref openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization)
+* [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved)
+* [PropagatePrecisions](@ref openvino_docs_OV_UG_lpt_PropagatePrecisions)
+* [AlignQuantizationIntervals](@ref openvino_docs_OV_UG_lpt_AlignQuantizationIntervals)
+* [AlignQuantizationParameters](@ref openvino_docs_OV_UG_lpt_AlignQuantizationParameters)
 
-The model on this step is changed: only new attributes are added to some operations. There are more details in developer guide [Markup transformations](@ref openvino_docs_IE_DG_lpt_step2_markup).
+The model on this step is changed: only new attributes are added to some operations. There are more details in developer guide [Markup transformations](@ref openvino_docs_OV_UG_lpt_step2_markup).
 
 ### Step 3. Main transformations, FakeQuantize decomposition and dequantization operations handling
-This step has the most transformations. These transformations can be separated in two groups: decomposition transformation and dequantization operations handling. There are more details in developer guide [Main transformations](@ref openvino_docs_IE_DG_lpt_step3_main). Transformations:
-* [AddTransformation](@ref openvino_docs_IE_DG_lpt_AddTransformation)
-* [AvgPoolTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ClampTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ConcatTransformation](@ref openvino_docs_IE_DG_lpt_ConcatTransformation)
-* [ConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionTransformation)
-* [ConvolutionBackpropDataTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation)
-* [DepthToSpaceTransformation](@ref openvino_docs_IE_DG_lpt_DepthToSpaceTransformation)
-* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation)
-* [FakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeTransformation)
-* [InterpolateTransformation](@ref openvino_docs_IE_DG_lpt_InterpolateTransformation)
-* [GroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_GroupConvolutionTransformation)
-* [MatMulTransformation](@ref openvino_docs_IE_DG_lpt_MatMulTransformation)
-* [MaxPoolTransformation](@ref openvino_docs_IE_DG_lpt_MaxPoolTransformation)
-* [MultiplyTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyTransformation)
-* [MVNTransformation](@ref openvino_docs_IE_DG_lpt_MVNTransformation)
-* [NormalizeL2Transformation](@ref openvino_docs_IE_DG_lpt_NormalizeL2Transformation)
-* [PReluTransformation](@ref openvino_docs_IE_DG_lpt_PReluTransformation)
-* [ReduceMaxTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMaxTransformation)
-* [ReduceMeanTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMeanTransformation)
-* [ReduceMinTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMinTransformation)
-* [ReduceSumTransformation](@ref openvino_docs_IE_DG_lpt_ReduceSumTransformation)
-* [ReluTransformation](@ref openvino_docs_IE_DG_lpt_ReluTransformation)
-* [ReshapeTransformation](@ref openvino_docs_IE_DG_lpt_ReshapeTransformation)
-* [SqueezeTransformation](@ref openvino_docs_IE_DG_lpt_SqueezeTransformation)
-* [ShuffleChannelsTransformation](@ref openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation)
-* [SplitTransformation](@ref openvino_docs_IE_DG_lpt_SplitTransformation)
-* [StridedSliceTransformation](@ref openvino_docs_IE_DG_lpt_StridedSliceTransformation)
-* [TransposeTransformation](@ref openvino_docs_IE_DG_lpt_TransposeTransformation)
-* [UnsqueezeTransformation](@ref openvino_docs_IE_DG_lpt_UnsqueezeTransformation)
-* [VariadicSplitTransformation](@ref openvino_docs_IE_DG_lpt_VariadicSplitTransformation)
+This step has the most transformations. These transformations can be separated in two groups: decomposition transformation and dequantization operations handling. There are more details in developer guide [Main transformations](@ref openvino_docs_OV_UG_lpt_step3_main). Transformations:
+* [AddTransformation](@ref openvino_docs_OV_UG_lpt_AddTransformation)
+* [AvgPoolTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ClampTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ConcatTransformation](@ref openvino_docs_OV_UG_lpt_ConcatTransformation)
+* [ConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionTransformation)
+* [ConvolutionBackpropDataTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation)
+* [DepthToSpaceTransformation](@ref openvino_docs_OV_UG_lpt_DepthToSpaceTransformation)
+* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation)
+* [FakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeTransformation)
+* [InterpolateTransformation](@ref openvino_docs_OV_UG_lpt_InterpolateTransformation)
+* [GroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_GroupConvolutionTransformation)
+* [MatMulTransformation](@ref openvino_docs_OV_UG_lpt_MatMulTransformation)
+* [MaxPoolTransformation](@ref openvino_docs_OV_UG_lpt_MaxPoolTransformation)
+* [MultiplyTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyTransformation)
+* [MVNTransformation](@ref openvino_docs_OV_UG_lpt_MVNTransformation)
+* [NormalizeL2Transformation](@ref openvino_docs_OV_UG_lpt_NormalizeL2Transformation)
+* [PReluTransformation](@ref openvino_docs_OV_UG_lpt_PReluTransformation)
+* [ReduceMaxTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMaxTransformation)
+* [ReduceMeanTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMeanTransformation)
+* [ReduceMinTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMinTransformation)
+* [ReduceSumTransformation](@ref openvino_docs_OV_UG_lpt_ReduceSumTransformation)
+* [ReluTransformation](@ref openvino_docs_OV_UG_lpt_ReluTransformation)
+* [ReshapeTransformation](@ref openvino_docs_OV_UG_lpt_ReshapeTransformation)
+* [SqueezeTransformation](@ref openvino_docs_OV_UG_lpt_SqueezeTransformation)
+* [ShuffleChannelsTransformation](@ref openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation)
+* [SplitTransformation](@ref openvino_docs_OV_UG_lpt_SplitTransformation)
+* [StridedSliceTransformation](@ref openvino_docs_OV_UG_lpt_StridedSliceTransformation)
+* [TransposeTransformation](@ref openvino_docs_OV_UG_lpt_TransposeTransformation)
+* [UnsqueezeTransformation](@ref openvino_docs_OV_UG_lpt_UnsqueezeTransformation)
+* [VariadicSplitTransformation](@ref openvino_docs_OV_UG_lpt_VariadicSplitTransformation)
 
 #### Decomposition transformations
 Decomposition transformations decompose the `FakeQuantize` operation to: quantize (`FakeQuantize` with low precision output) and dequantization operations (opposite to quantize, with low precision input and the original precision output). For dequantization operations LPT uses three operations: `Convert`, `Subtract` and `Multiply`. Element-wise operations `Subtract` and `Multiply` have constants on the second branches. If dequantization operations are not handled at the end of LPT pipeline, then they will be fused back to the `FakeQuantize`.
@@ -197,14 +193,14 @@ Original `Convolution` operation in FP32 with dequantization operations before:
 
 ### Step 4: Cleanup of the result model
 LPT cleanup transformations is final stage in LPT pipeline. In this step LPT transformations clean up the result model to avoid not handled dequantization operations: fuse dequantization operations if possible (fuse at least `Convert` operations if not) to other model operations to cleanup result model. Transformations:
-* [FoldConvertTransformation](@ref openvino_docs_IE_DG_lpt_FoldConvertTransformation)
-* [FoldFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation)
-* [FuseConvertTransformation](@ref openvino_docs_IE_DG_lpt_FuseConvertTransformation)
-* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation)
-* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation)
-* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation)
+* [FoldConvertTransformation](@ref openvino_docs_OV_UG_lpt_FoldConvertTransformation)
+* [FoldFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation)
+* [FuseConvertTransformation](@ref openvino_docs_OV_UG_lpt_FuseConvertTransformation)
+* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation)
+* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation)
+* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation)
 
-There are more details in developer guide [Cleanup transformations](@ref openvino_docs_IE_DG_lpt_step4_cleanup).
+There are more details in developer guide [Cleanup transformations](@ref openvino_docs_OV_UG_lpt_step4_cleanup).
 
 `FakeQuantize` operation with not handled dequantization operations:  
 ![TODO: FakeQuantize operation with dequantization operations before LPT](quantization/img/fq.transformed.png)
@@ -236,11 +232,11 @@ This step is optional. It modifies the nGraph function to a device-specific oper
 
 Let's explore quantized [TensorFlow* implementation of ResNet-50](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/resnet-50-tf) model. Use [Model Downloader](@ref omz_tools_downloader) tool to download the `fp16` model from [OpenVINO™ Toolkit - Open Model Zoo repository](https://github.com/openvinotoolkit/open_model_zoo):
 ```sh
-./downloader.py --name resnet-50-tf --precisions FP16-INT8
+omz_downloader --name resnet-50-tf --precisions FP16-INT8
 ```
 After that you should quantize model by the [Model Quantizer](@ref omz_tools_downloader) tool.
 ```sh
-./quantizer.py --model_dir public/resnet-50-tf --dataset_dir <DATASET_DIR> --precisions=FP16-INT8
+omz_quantizer --model_dir public/resnet-50-tf --dataset_dir <DATASET_DIR> --precisions=FP16-INT8
 ```
 
 ### Inference
@@ -259,7 +255,7 @@ Result model depends on different factors:
 
 
 Information about layer precision is stored in the performance counters that are
-available from the Inference Engine API. For example, the part of performance counters table for quantized [TensorFlow* implementation of ResNet-50](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/resnet-50-tf) model inference on CPU Plugin looks as follows:
+available from the OpenVINO Runtime API. For example, the part of performance counters table for quantized [TensorFlow* implementation of ResNet-50](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/resnet-50-tf) model inference on CPU Plugin looks as follows:
 
 
 | layerName                                                 | execStatus | layerType    | execType             | realTime (ms) | cpuTime (ms) |

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/lpt_attributes.md

@@ -1,4 +1,4 @@
-# Attributes {#openvino_docs_IE_DG_lpt_attributes}
+# Attributes {#openvino_docs_OV_UG_lpt_attributes}
 
 @sphinxdirective
 
@@ -7,12 +7,12 @@
    :caption: Attributes
    :hidden:
 
-   AvgPoolPrecisionPreserved <openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved>
-   IntervalsAlignment <openvino_docs_IE_DG_lpt_IntervalsAlignment>
-   PerTensorQuantization <openvino_docs_IE_DG_lpt_PerTensorQuantization>
-   PrecisionPreserved <openvino_docs_IE_DG_lpt_PrecisionPreserved>
-   Precisions <openvino_docs_IE_DG_lpt_Precisions>
-   QuantizationAlignment <openvino_docs_IE_DG_lpt_QuantizationAlignment>
+   AvgPoolPrecisionPreserved <openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved>
+   IntervalsAlignment <openvino_docs_OV_UG_lpt_IntervalsAlignment>
+   PerTensorQuantization <openvino_docs_OV_UG_lpt_PerTensorQuantization>
+   PrecisionPreserved <openvino_docs_OV_UG_lpt_PrecisionPreserved>
+   Precisions <openvino_docs_OV_UG_lpt_Precisions>
+   QuantizationAlignment <openvino_docs_OV_UG_lpt_QuantizationAlignment>
 
 @endsphinxdirective
 
@@ -20,12 +20,12 @@
 
 | Name                                                                                | Target                 | Required | Mutable |
 |-------------------------------------------------------------------------------------|------------------------|----------|---------|
-| [AvgPoolPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved) | Precision              | No       | Yes     |
-| [IntervalsAlignment](@ref openvino_docs_IE_DG_lpt_IntervalsAlignment)               | Quantization interval  | Yes      | Yes     |
-| [PerTensorQuantization](@ref openvino_docs_IE_DG_lpt_PerTensorQuantization)         | Precision              | Yes      | No      |
-| [PrecisionPreserved](@ref openvino_docs_IE_DG_lpt_PrecisionPreserved)               | Precision              | Yes      | Yes     |
-| [Precisions](@ref openvino_docs_IE_DG_lpt_Precisions)                               | Precision              | Yes      | Yes     |
-| [QuantizationAlignment](@ref openvino_docs_IE_DG_lpt_QuantizationAlignment)         | Quantization alignment | Yes      | Yes     |
+| [AvgPoolPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved) | Precision              | No       | Yes     |
+| [IntervalsAlignment](@ref openvino_docs_OV_UG_lpt_IntervalsAlignment)               | Quantization interval  | Yes      | Yes     |
+| [PerTensorQuantization](@ref openvino_docs_OV_UG_lpt_PerTensorQuantization)         | Precision              | Yes      | No      |
+| [PrecisionPreserved](@ref openvino_docs_OV_UG_lpt_PrecisionPreserved)               | Precision              | Yes      | Yes     |
+| [Precisions](@ref openvino_docs_OV_UG_lpt_Precisions)                               | Precision              | Yes      | Yes     |
+| [QuantizationAlignment](@ref openvino_docs_OV_UG_lpt_QuantizationAlignment)         | Quantization alignment | Yes      | Yes     |
 
 > `Target` attribute group defines attribute usage during model transformation for the best performance:
 >  - `Precision` - the attribute defines the most optimal output port precision.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step1_prerequisites.md

@@ -1,6 +1,6 @@
-# Step 1. Prerequisites Transformations {#openvino_docs_IE_DG_lpt_step1_prerequisites}
+# Step 1. Prerequisites Transformations {#openvino_docs_OV_UG_lpt_step1_prerequisites}
 
 Prerequisites transformations are optional. The transformations prepare a model before running other low precision transformations. The transformations do not operate with dequantization operations or update precisions. Prerequisites transformations include:
-* [PullReshapeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization)
-* [PullTransposeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization)
-* [LinOpSequenceFusion](@ref openvino_docs_IE_DG_lpt_LinOpSequenceFusion)
+* [PullReshapeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization)
+* [PullTransposeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization)
+* [LinOpSequenceFusion](@ref openvino_docs_OV_UG_lpt_LinOpSequenceFusion)

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step2_markup.md

@@ -1,14 +1,14 @@
-# Step 2. Markup Transformations {#openvino_docs_IE_DG_lpt_step2_markup}
+# Step 2. Markup Transformations {#openvino_docs_OV_UG_lpt_step2_markup}
 
 This step defines the optimal `FakeQuantize` decomposition precisions for the best inference performance via operations markup with runtime attribute instances. Attributes are created for input and output ports and operations. Transformations do not change the operation output port precisions. A model markup low precision logic is decomposed and implemented into the following common markup transformations. The order of transformations is important:
 
-1. [MarkupCanBeQuantized](@ref openvino_docs_IE_DG_lpt_MarkupCanBeQuantized)
-2. [MarkupPrecisions](@ref openvino_docs_IE_DG_lpt_MarkupPrecisions)
-3. [MarkupPerTensorQuantization](@ref openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization)
-4. [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved)
-5. [PropagatePrecisions](@ref openvino_docs_IE_DG_lpt_PropagatePrecisions)
-6. [AlignQuantizationIntervals](@ref openvino_docs_IE_DG_lpt_AlignQuantizationIntervals)
-7. [AlignQuantizationParameters](@ref openvino_docs_IE_DG_lpt_AlignQuantizationParameters)
+1. [MarkupCanBeQuantized](@ref openvino_docs_OV_UG_lpt_MarkupCanBeQuantized)
+2. [MarkupPrecisions](@ref openvino_docs_OV_UG_lpt_MarkupPrecisions)
+3. [MarkupPerTensorQuantization](@ref openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization)
+4. [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved)
+5. [PropagatePrecisions](@ref openvino_docs_OV_UG_lpt_PropagatePrecisions)
+6. [AlignQuantizationIntervals](@ref openvino_docs_OV_UG_lpt_AlignQuantizationIntervals)
+7. [AlignQuantizationParameters](@ref openvino_docs_OV_UG_lpt_AlignQuantizationParameters)
 
 The table of transformations and used attributes:
 
@@ -25,11 +25,11 @@ The table of transformations and used attributes:
 > **Note:** the same type of attribute instances can be created in different transformations. This approach is the result of the transformation single-responsibility principle. For example, `Precision` attribute instances are created in `MarkupCanBeQuantized` and `MarkupPrecisions` transformations, but the reasons for their creation are different
 
 Common markup transformations can be decomposed into simpler utility markup transformations. The order of Markup utility transformations is not important:
-* [CreateAttribute](@ref openvino_docs_IE_DG_lpt_CreateAttribute)
-* [CreatePrecisionsDependentAttribute](@ref openvino_docs_IE_DG_lpt_CreatePrecisionsDependentAttribute)
-* [PropagateThroughPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_PropagateThroughPrecisionPreserved)
-* [PropagateToInput](@ref openvino_docs_IE_DG_lpt_PropagateToInput)
-* [UpdateSharedPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_UpdateSharedPrecisionPreserved)
+* [CreateAttribute](@ref openvino_docs_OV_UG_lpt_CreateAttribute)
+* [CreatePrecisionsDependentAttribute](@ref openvino_docs_OV_UG_lpt_CreatePrecisionsDependentAttribute)
+* [PropagateThroughPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_PropagateThroughPrecisionPreserved)
+* [PropagateToInput](@ref openvino_docs_OV_UG_lpt_PropagateToInput)
+* [UpdateSharedPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_UpdateSharedPrecisionPreserved)
 
 Let's explore all transformations and their relations in detail, using one and the same model:
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step3_main.md

@@ -1,36 +1,36 @@
-# Step 3. Main Transformations {#openvino_docs_IE_DG_lpt_step3_main}
+# Step 3. Main Transformations {#openvino_docs_OV_UG_lpt_step3_main}
 
 Main transformations are the majority of low precision transformations. Transformations operate with dequantization operations. Main transformations include:
-* [AddTransformation](@ref openvino_docs_IE_DG_lpt_AddTransformation)
-* [AvgPoolTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ClampTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ConcatTransformation](@ref openvino_docs_IE_DG_lpt_ConcatTransformation)
-* [ConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionTransformation)
-* [ConvolutionBackpropDataTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation)
-* [DepthToSpaceTransformation](@ref openvino_docs_IE_DG_lpt_DepthToSpaceTransformation)
-* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation)
-* [FakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeTransformation)
-* [InterpolateTransformation](@ref openvino_docs_IE_DG_lpt_InterpolateTransformation)
-* [GroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_GroupConvolutionTransformation)
-* [MatMulTransformation](@ref openvino_docs_IE_DG_lpt_MatMulTransformation)
-* [MaxPoolTransformation](@ref openvino_docs_IE_DG_lpt_MaxPoolTransformation)
-* [MultiplyTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyTransformation)
-* [MVNTransformation](@ref openvino_docs_IE_DG_lpt_MVNTransformation)
-* [NormalizeL2Transformation](@ref openvino_docs_IE_DG_lpt_NormalizeL2Transformation)
-* [PReluTransformation](@ref openvino_docs_IE_DG_lpt_PReluTransformation)
-* [ReduceMaxTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMaxTransformation)
-* [ReduceMeanTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMeanTransformation)
-* [ReduceMinTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMinTransformation)
-* [ReduceSumTransformation](@ref openvino_docs_IE_DG_lpt_ReduceSumTransformation)
-* [ReluTransformation](@ref openvino_docs_IE_DG_lpt_ReluTransformation)
-* [ReshapeTransformation](@ref openvino_docs_IE_DG_lpt_ReshapeTransformation)
-* [SqueezeTransformation](@ref openvino_docs_IE_DG_lpt_SqueezeTransformation)
-* [ShuffleChannelsTransformation](@ref openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation)
-* [SplitTransformation](@ref openvino_docs_IE_DG_lpt_SplitTransformation)
-* [StridedSliceTransformation](@ref openvino_docs_IE_DG_lpt_StridedSliceTransformation)
-* [TransposeTransformation](@ref openvino_docs_IE_DG_lpt_TransposeTransformation)
-* [UnsqueezeTransformation](@ref openvino_docs_IE_DG_lpt_UnsqueezeTransformation)
-* [VariadicSplitTransformation](@ref openvino_docs_IE_DG_lpt_VariadicSplitTransformation)
+* [AddTransformation](@ref openvino_docs_OV_UG_lpt_AddTransformation)
+* [AvgPoolTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ClampTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ConcatTransformation](@ref openvino_docs_OV_UG_lpt_ConcatTransformation)
+* [ConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionTransformation)
+* [ConvolutionBackpropDataTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation)
+* [DepthToSpaceTransformation](@ref openvino_docs_OV_UG_lpt_DepthToSpaceTransformation)
+* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation)
+* [FakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeTransformation)
+* [InterpolateTransformation](@ref openvino_docs_OV_UG_lpt_InterpolateTransformation)
+* [GroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_GroupConvolutionTransformation)
+* [MatMulTransformation](@ref openvino_docs_OV_UG_lpt_MatMulTransformation)
+* [MaxPoolTransformation](@ref openvino_docs_OV_UG_lpt_MaxPoolTransformation)
+* [MultiplyTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyTransformation)
+* [MVNTransformation](@ref openvino_docs_OV_UG_lpt_MVNTransformation)
+* [NormalizeL2Transformation](@ref openvino_docs_OV_UG_lpt_NormalizeL2Transformation)
+* [PReluTransformation](@ref openvino_docs_OV_UG_lpt_PReluTransformation)
+* [ReduceMaxTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMaxTransformation)
+* [ReduceMeanTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMeanTransformation)
+* [ReduceMinTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMinTransformation)
+* [ReduceSumTransformation](@ref openvino_docs_OV_UG_lpt_ReduceSumTransformation)
+* [ReluTransformation](@ref openvino_docs_OV_UG_lpt_ReluTransformation)
+* [ReshapeTransformation](@ref openvino_docs_OV_UG_lpt_ReshapeTransformation)
+* [SqueezeTransformation](@ref openvino_docs_OV_UG_lpt_SqueezeTransformation)
+* [ShuffleChannelsTransformation](@ref openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation)
+* [SplitTransformation](@ref openvino_docs_OV_UG_lpt_SplitTransformation)
+* [StridedSliceTransformation](@ref openvino_docs_OV_UG_lpt_StridedSliceTransformation)
+* [TransposeTransformation](@ref openvino_docs_OV_UG_lpt_TransposeTransformation)
+* [UnsqueezeTransformation](@ref openvino_docs_OV_UG_lpt_UnsqueezeTransformation)
+* [VariadicSplitTransformation](@ref openvino_docs_OV_UG_lpt_VariadicSplitTransformation)
 
 Let's explore some main transformations on the example model. Original model:
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step4_cleanup.md

@@ -1,8 +1,8 @@
-# Step 4. Cleanup Transformations {#openvino_docs_IE_DG_lpt_step4_cleanup}
+# Step 4. Cleanup Transformations {#openvino_docs_OV_UG_lpt_step4_cleanup}
 
-* [FoldConvertTransformation](@ref openvino_docs_IE_DG_lpt_FoldConvertTransformation)
-* [FoldFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation)
-* [FuseConvertTransformation](@ref openvino_docs_IE_DG_lpt_FuseConvertTransformation)
-* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation)
-* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation)
-* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation)
+* [FoldConvertTransformation](@ref openvino_docs_OV_UG_lpt_FoldConvertTransformation)
+* [FoldFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation)
+* [FuseConvertTransformation](@ref openvino_docs_OV_UG_lpt_FuseConvertTransformation)
+* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation)
+* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation)
+* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation)

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/convert_subtract_constant.md

@@ -1,3 +1,3 @@
-# ConvertSubtractConstant transformation {#openvino_docs_IE_DG_lpt_ConvertSubtractConstant}
+# ConvertSubtractConstant transformation {#openvino_docs_OV_UG_lpt_ConvertSubtractConstant}
 
 ngraph::pass::low_precision::ConvertSubtractConstant class represents the `ConvertSubtractConstant` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/lin_op_sequence_fusion.md

@@ -1,4 +1,4 @@
-# LinOpSequenceFusion transformation {#openvino_docs_IE_DG_lpt_LinOpSequenceFusion}
+# LinOpSequenceFusion transformation {#openvino_docs_OV_UG_lpt_LinOpSequenceFusion}
 
 ngraph::pass::LinOpSequenceFusion class represents the `LinOpSequenceFusion` transformation.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/pull_reshape_through_dequantization.md

@@ -1,3 +1,3 @@
-# PullReshapeThroughDequantization transformation {#openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization}
+# PullReshapeThroughDequantization transformation {#openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization}
 
 ngraph::pass::low_precision::PullReshapeThroughDequantization class represents the `PullReshapeThroughDequantization` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/pull_transpose_through_dequantization.md

@@ -1,3 +1,3 @@
-# PullTransposeThroughDequantization transformation {#openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization}
+# PullTransposeThroughDequantization transformation {#openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization}
 
 ngraph::pass::low_precision::PullTransposeThroughDequantization class represents the `PullTransposeThroughDequantization` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/align_quantization_intervals.md

@@ -1,3 +1,3 @@
-# AlignQuantizationIntervals transformation {#openvino_docs_IE_DG_lpt_AlignQuantizationIntervals}
+# AlignQuantizationIntervals transformation {#openvino_docs_OV_UG_lpt_AlignQuantizationIntervals}
 
 ngraph::pass::low_precision::AlignQuantizationIntervals class represents the `AlignQuantizationIntervals` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/align_quantization_parameters.md

@@ -1,3 +1,3 @@
-# AlignQuantizationParameters transformation {#openvino_docs_IE_DG_lpt_AlignQuantizationParameters}
+# AlignQuantizationParameters transformation {#openvino_docs_OV_UG_lpt_AlignQuantizationParameters}
 
 ngraph::pass::low_precision::AlignQuantizationParameters class represents the `AlignQuantizationParameters` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/create_attribute.md

@@ -1,3 +1,3 @@
-# CreateAttribute transformation {#openvino_docs_IE_DG_lpt_CreateAttribute}
+# CreateAttribute transformation {#openvino_docs_OV_UG_lpt_CreateAttribute}
 
 ngraph::pass::low_precision::CreateAttribute class represents the `CreateAttribute` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/create_precisions_dependent_attribute.md

@@ -1,3 +1,3 @@
-# CreatePrecisionsDependentAttribute transformation {#openvino_docs_IE_DG_lpt_CreatePrecisionsDependentAttribute}
+# CreatePrecisionsDependentAttribute transformation {#openvino_docs_OV_UG_lpt_CreatePrecisionsDependentAttribute}
 
 ngraph::pass::low_precision::CreatePrecisionsDependentAttribute class represents the `CreatePrecisionsDependentAttribute` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_avg_pool_precision_preserved.md

@@ -1,3 +1,3 @@
-# MarkupAvgPoolPrecisionPreserved transformation {#openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved}
+# MarkupAvgPoolPrecisionPreserved transformation {#openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved}
 
 ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved class represents the `MarkupAvgPoolPrecisionPreserved` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_can_be_quantized.md

@@ -1,3 +1,3 @@
-# MarkupCanBeQuantized transformation {#openvino_docs_IE_DG_lpt_MarkupCanBeQuantized}
+# MarkupCanBeQuantized transformation {#openvino_docs_OV_UG_lpt_MarkupCanBeQuantized}
 
 ngraph::pass::low_precision::MarkupCanBeQuantized class represents the `MarkupCanBeQuantized` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_per_tensor_quantization.md

@@ -1,3 +1,3 @@
-# MarkupPerTensorQuantization transformation {#openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization}
+# MarkupPerTensorQuantization transformation {#openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization}
 
 ngraph::pass::low_precision::MarkupPerTensorQuantization class represents the `MarkupPerTensorQuantization` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_precisions.md

@@ -1,3 +1,3 @@
-# MarkupPrecisions transformation {#openvino_docs_IE_DG_lpt_MarkupPrecisions}
+# MarkupPrecisions transformation {#openvino_docs_OV_UG_lpt_MarkupPrecisions}
 
 ngraph::pass::low_precision::MarkupPrecisions class represents the `MarkupPrecisions` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_precisions.md

@@ -1,3 +1,3 @@
-# PropagatePrecisions transformation {#openvino_docs_IE_DG_lpt_PropagatePrecisions}
+# PropagatePrecisions transformation {#openvino_docs_OV_UG_lpt_PropagatePrecisions}
 
 ngraph::pass::low_precision::PropagatePrecisions class represents the `PropagatePrecisions` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_shared_value.md

@@ -1,3 +1,3 @@
-# PropagateSharedValue transformation {#openvino_docs_IE_DG_lpt_PropagateSharedValue}
+# PropagateSharedValue transformation {#openvino_docs_OV_UG_lpt_PropagateSharedValue}
 
 ngraph::pass::low_precision::PropagateSharedValue class represents the `PropagateSharedValue` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_through_precision_preserved.md

@@ -1,3 +1,3 @@
-# PropagateThroughPrecisionPreserved transformation {#openvino_docs_IE_DG_lpt_PropagateThroughPrecisionPreserved}
+# PropagateThroughPrecisionPreserved transformation {#openvino_docs_OV_UG_lpt_PropagateThroughPrecisionPreserved}
 
 ngraph::pass::low_precision::PropagateThroughPrecisionPreserved class represents the `PropagateThroughPrecisionPreserved` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_to_input.md

@@ -1,3 +1,3 @@
-# PropagateToInput transformation {#openvino_docs_IE_DG_lpt_PropagateToInput}
+# PropagateToInput transformation {#openvino_docs_OV_UG_lpt_PropagateToInput}
 
 ngraph::pass::low_precision::PropagateToInput class represents the `PropagateToInput` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/update_shared_precision_preserved.md

@@ -1,3 +1,3 @@
-# UpdateSharedPrecisionPreserved transformation {#openvino_docs_IE_DG_lpt_UpdateSharedPrecisionPreserved}
+# UpdateSharedPrecisionPreserved transformation {#openvino_docs_OV_UG_lpt_UpdateSharedPrecisionPreserved}
 
 ngraph::pass::low_precision::UpdateSharedPrecisionPreserved class represents the `UpdateSharedPrecisionPreserved` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/activation/clamp.md

@@ -1,3 +1,3 @@
-# ClampTransformation transformation {#openvino_docs_IE_DG_lpt_ClampTransformation}
+# ClampTransformation transformation {#openvino_docs_OV_UG_lpt_ClampTransformation}
 
 ngraph::pass::low_precision::ClampTransformation class represents the `Clamp` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/activation/prelu.md

@@ -1,3 +1,3 @@
-# PReluTransformation transformation {#openvino_docs_IE_DG_lpt_PReluTransformation}
+# PReluTransformation transformation {#openvino_docs_OV_UG_lpt_PReluTransformation}
 
 ngraph::pass::low_precision::PReluTransformation class represents the `PRelu` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/activation/relu.md

@@ -1,3 +1,3 @@
-# ReluTransformation transformation {#openvino_docs_IE_DG_lpt_ReluTransformation}
+# ReluTransformation transformation {#openvino_docs_OV_UG_lpt_ReluTransformation}
 
 ngraph::pass::low_precision::ReluTransformation class represents the `Relu` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/arithmetic/add.md

@@ -1,4 +1,4 @@
-# AddTransformation transformation {#openvino_docs_IE_DG_lpt_AddTransformation}
+# AddTransformation transformation {#openvino_docs_OV_UG_lpt_AddTransformation}
 
 ngraph::pass::low_precision::AddTransformation class represents the `Add` operation transformation.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/arithmetic/multiply.md

@@ -1,3 +1,3 @@
-# MultiplyTransformation transformation {#openvino_docs_IE_DG_lpt_MultiplyTransformation}
+# MultiplyTransformation transformation {#openvino_docs_OV_UG_lpt_MultiplyTransformation}
 
 ngraph::pass::low_precision::MultiplyTransformation class represents the `Multiply` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/arithmetic/subtract.md

@@ -1,3 +1,3 @@
-# SubtractTransformation transformation {#openvino_docs_IE_DG_lpt_SubtractTransformation}
+# SubtractTransformation transformation {#openvino_docs_OV_UG_lpt_SubtractTransformation}
 
 ngraph::pass::low_precision::SubtractTransformation class represents the `Subtract` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/convolution/convolution.md

@@ -1,4 +1,4 @@
-# ConvolutionTransformation transformation {#openvino_docs_IE_DG_lpt_ConvolutionTransformation}
+# ConvolutionTransformation transformation {#openvino_docs_OV_UG_lpt_ConvolutionTransformation}
 
 ngraph::pass::low_precision::ConvolutionTransformation class represents the `Convolution` operation transformation.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/convolution/convolution_backprop_data.md

@@ -1,3 +1,3 @@
-# ConvolutionBackpropDataTransformation transformation {#openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation}
+# ConvolutionBackpropDataTransformation transformation {#openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation}
 
 ngraph::pass::low_precision::ConvolutionBackpropDataTransformation class represents the `ConvolutionBackpropData` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/convolution/group_convolution.md

@@ -1,3 +1,3 @@
-# GroupConvolutionTransformation transformation {#openvino_docs_IE_DG_lpt_GroupConvolutionTransformation}
+# GroupConvolutionTransformation transformation {#openvino_docs_OV_UG_lpt_GroupConvolutionTransformation}
 
 ngraph::pass::low_precision::GroupConvolutionTransformation class represents the `GroupConvolution` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/image/interpolate.md

@@ -1,3 +1,3 @@
-# InterpolateTransformation transformation {#openvino_docs_IE_DG_lpt_InterpolateTransformation}
+# InterpolateTransformation transformation {#openvino_docs_OV_UG_lpt_InterpolateTransformation}
 
 ngraph::pass::low_precision::InterpolateTransformation class represents the `Interpolate` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/matrix/mat_mul.md

@@ -1,3 +1,3 @@
-# MatMulTransformation transformation {#openvino_docs_IE_DG_lpt_MatMulTransformation}
+# MatMulTransformation transformation {#openvino_docs_OV_UG_lpt_MatMulTransformation}
 
 ngraph::pass::low_precision::MatMulTransformation class represents the `MatMul` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/concat.md

@@ -1,3 +1,3 @@
-# ConcatTransformation transformation {#openvino_docs_IE_DG_lpt_ConcatTransformation}
+# ConcatTransformation transformation {#openvino_docs_OV_UG_lpt_ConcatTransformation}
 
 ngraph::pass::low_precision::ConcatTransformation class represents the `Concat` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/depth_to_space.md

@@ -1,3 +1,3 @@
-# DepthToSpaceTransformation transformation {#openvino_docs_IE_DG_lpt_DepthToSpaceTransformation}
+# DepthToSpaceTransformation transformation {#openvino_docs_OV_UG_lpt_DepthToSpaceTransformation}
 
 ngraph::pass::low_precision::DepthToSpaceTransformation class represents the `DepthToSpace` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/pad.md

@@ -1,3 +1,3 @@
-# PadTransformation transformation {#openvino_docs_IE_DG_lpt_PadTransformation}
+# PadTransformation transformation {#openvino_docs_OV_UG_lpt_PadTransformation}
 
 ngraph::pass::low_precision::PadTransformation class represents the `Pad` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/shuffle_channels.md

@@ -1,3 +1,3 @@
-# ShuffleChannelsTransformation transformation {#openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation}
+# ShuffleChannelsTransformation transformation {#openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation}
 
 ngraph::pass::low_precision::ShuffleChannelsTransformation class represents the `ShuffleChannels` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/split.md

@@ -1,3 +1,3 @@
-# SplitTransformation transformation {#openvino_docs_IE_DG_lpt_SplitTransformation}
+# SplitTransformation transformation {#openvino_docs_OV_UG_lpt_SplitTransformation}
 
 ngraph::pass::low_precision::SplitTransformation class represents the `Split` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/strided_slice.md

@@ -1,3 +1,3 @@
-# StridedSliceTransformation transformation {#openvino_docs_IE_DG_lpt_StridedSliceTransformation}
+# StridedSliceTransformation transformation {#openvino_docs_OV_UG_lpt_StridedSliceTransformation}
 
 ngraph::pass::low_precision::StridedSliceTransformation class represents the `StridedSlice` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/transpose.md

@@ -1,3 +1,3 @@
-# TransposeTransformation transformation {#openvino_docs_IE_DG_lpt_TransposeTransformation}
+# TransposeTransformation transformation {#openvino_docs_OV_UG_lpt_TransposeTransformation}
 
 ngraph::pass::low_precision::TransposeTransformation class represents the `Transpose` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/movement/variadic_split.md

@@ -1,3 +1,3 @@
-# VariadicSplitTransformation transformation {#openvino_docs_IE_DG_lpt_VariadicSplitTransformation}
+# VariadicSplitTransformation transformation {#openvino_docs_OV_UG_lpt_VariadicSplitTransformation}
 
 ngraph::pass::low_precision::VariadicSplitTransformation class represents the `VariadicSplit` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/normalization/mvn.md

@@ -1,3 +1,3 @@
-# MVNTransformation transformation {#openvino_docs_IE_DG_lpt_MVNTransformation}
+# MVNTransformation transformation {#openvino_docs_OV_UG_lpt_MVNTransformation}
 
 ngraph::pass::low_precision::MVNTransformation class represents the `MVN` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/normalization/normalize_l2.md

@@ -1,3 +1,3 @@
-# NormalizeL2Transformation transformation {#openvino_docs_IE_DG_lpt_NormalizeL2Transformation}
+# NormalizeL2Transformation transformation {#openvino_docs_OV_UG_lpt_NormalizeL2Transformation}
 
 ngraph::pass::low_precision::NormalizeL2Transformation class represents the `NormalizeL2` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/pooling/avg_pool.md

@@ -1,3 +1,3 @@
-# AvgPoolTransformation transformation {#openvino_docs_IE_DG_lpt_AvgPoolTransformation}
+# AvgPoolTransformation transformation {#openvino_docs_OV_UG_lpt_AvgPoolTransformation}
 
 ngraph::pass::low_precision::AvgPoolTransformation class represents the `AvgPool` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/pooling/max_pool.md

@@ -1,3 +1,3 @@
-# MaxPoolTransformation transformation {#openvino_docs_IE_DG_lpt_MaxPoolTransformation}
+# MaxPoolTransformation transformation {#openvino_docs_OV_UG_lpt_MaxPoolTransformation}
 
 ngraph::pass::low_precision::MaxPoolTransformation class represents the `MaxPool` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/quantization/fake_quantize.md

@@ -1,3 +1,3 @@
-# FakeQuantizeTransformation transformation {#openvino_docs_IE_DG_lpt_FakeQuantizeTransformation}
+# FakeQuantizeTransformation transformation {#openvino_docs_OV_UG_lpt_FakeQuantizeTransformation}
 
 ngraph::pass::low_precision::FakeQuantizeTransformation class represents the `FakeQuantize` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/quantization/fold_fake_quantize.md

@@ -1,3 +1,3 @@
-# FoldFakeQuantizeTransformation transformation {#openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation}
+# FoldFakeQuantizeTransformation transformation {#openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation}
 
 ngraph::pass::low_precision::FoldFakeQuantizeTransformation class represents the `FoldFakeQuantize` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/reduction/reduce_max.md

@@ -1,3 +1,3 @@
-# ReduceMaxTransformation transformation {#openvino_docs_IE_DG_lpt_ReduceMaxTransformation}
+# ReduceMaxTransformation transformation {#openvino_docs_OV_UG_lpt_ReduceMaxTransformation}
 
 ngraph::pass::low_precision::ReduceMaxTransformation class represents the `ReduceMax` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/reduction/reduce_mean.md

@@ -1,3 +1,3 @@
-# ReduceMeanTransformation transformation {#openvino_docs_IE_DG_lpt_ReduceMeanTransformation}
+# ReduceMeanTransformation transformation {#openvino_docs_OV_UG_lpt_ReduceMeanTransformation}
 
 ngraph::pass::low_precision::ReduceMeanTransformation class represents the `ReduceMean` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/reduction/reduce_min.md

@@ -1,3 +1,3 @@
-# ReduceMinTransformation transformation {#openvino_docs_IE_DG_lpt_ReduceMinTransformation}
+# ReduceMinTransformation transformation {#openvino_docs_OV_UG_lpt_ReduceMinTransformation}
 
 ngraph::pass::low_precision::ReduceMinTransformation class represents the `ReduceMin` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/reduction/reduce_sum.md

@@ -1,3 +1,3 @@
-# ReduceSumTransformation transformation {#openvino_docs_IE_DG_lpt_ReduceSumTransformation}
+# ReduceSumTransformation transformation {#openvino_docs_OV_UG_lpt_ReduceSumTransformation}
 
 ngraph::pass::low_precision::ReduceSumTransformation class represents the `ReduceSum` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/shape/reshape.md

@@ -1,3 +1,3 @@
-# ReshapeTransformation transformation {#openvino_docs_IE_DG_lpt_ReshapeTransformation}
+# ReshapeTransformation transformation {#openvino_docs_OV_UG_lpt_ReshapeTransformation}
 
 ngraph::pass::low_precision::ReshapeTransformation class represents the `Reshape` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/shape/squeeze.md

@@ -1,3 +1,3 @@
-# SqueezeTransformation transformation {#openvino_docs_IE_DG_lpt_SqueezeTransformation}
+# SqueezeTransformation transformation {#openvino_docs_OV_UG_lpt_SqueezeTransformation}
 
 ngraph::pass::low_precision::SqueezeTransformation class represents the `Squeeze` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/shape/unsqueeze.md

@@ -1,3 +1,3 @@
-# UnsqueezeTransformation transformation {#openvino_docs_IE_DG_lpt_UnsqueezeTransformation}
+# UnsqueezeTransformation transformation {#openvino_docs_OV_UG_lpt_UnsqueezeTransformation}
 
 ngraph::pass::low_precision::UnsqueezeTransformation class represents the `Unsqueeze` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step4_cleanup/fake_quantize_decomposition.md

@@ -1,3 +1,3 @@
-# FakeQuantizeDecompositionTransformation transformation {#openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation}
+# FakeQuantizeDecompositionTransformation transformation {#openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation}
 
 ngraph::pass::low_precision::FakeQuantizeDecompositionTransformation class represents the `FakeQuantizeDecompositionTransformation` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step4_cleanup/fold_convert.md

@@ -1,3 +1,3 @@
-# FoldConvertTransformation transformation {#openvino_docs_IE_DG_lpt_FoldConvertTransformation}
+# FoldConvertTransformation transformation {#openvino_docs_OV_UG_lpt_FoldConvertTransformation}
 
 ngraph::pass::low_precision::FoldConvertTransformation class represents the `FoldConvertTransformation` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step4_cleanup/fuse_convert.md

@@ -1,3 +1,3 @@
-# FuseConvertTransformation transformation {#openvino_docs_IE_DG_lpt_FuseConvertTransformation}
+# FuseConvertTransformation transformation {#openvino_docs_OV_UG_lpt_FuseConvertTransformation}
 
 ngraph::pass::low_precision::FuseConvertTransformation class represents the `FuseConvertTransformation` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step4_cleanup/fuse_multiply_to_fake_quantize.md

@@ -1,3 +1,3 @@
-# FuseMultiplyToFakeQuantizeTransformation transformation {#openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation}
+# FuseMultiplyToFakeQuantizeTransformation transformation {#openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation}
 
 ngraph::pass::low_precision::FuseMultiplyToFakeQuantizeTransformation class represents the `FuseMultiplyToFakeQuantizeTransformation` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step4_cleanup/fuse_subtract_to_fake_quantize.md

@@ -1,3 +1,3 @@
-# FuseSubtractToFakeQuantizeTransformation transformation {#openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation}
+# FuseSubtractToFakeQuantizeTransformation transformation {#openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation}
 
 ngraph::pass::low_precision::FuseSubtractToFakeQuantizeTransformation class represents the `FuseSubtractToFakeQuantizeTransformation` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step4_cleanup/multiply_to_group_convolution.md

@@ -1,3 +1,3 @@
-# MultiplyToGroupConvolutionTransformation transformation {#openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation}
+# MultiplyToGroupConvolutionTransformation transformation {#openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation}
 
 ngraph::pass::low_precision::MultiplyToGroupConvolutionTransformation class represents the `MultiplyToGroupConvolutionTransformation` transformation.

docs/MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md

@@ -1,4 +1,4 @@
-# Model Optimizer Developer Guide {#openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide}
+# Convert model with Model Optimizer {#openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide}
 
 @sphinxdirective
 
@@ -7,678 +7,128 @@
 .. toctree::
    :maxdepth: 1
    :hidden:
-   
-   openvino_docs_MO_DG_IR_and_opsets
+
    openvino_docs_MO_DG_prepare_model_convert_model_Converting_Model
+   openvino_docs_MO_DG_prepare_model_convert_model_Cutting_Model
    openvino_docs_MO_DG_Additional_Optimization_Use_Cases
-   openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Customize_Model_Optimizer
+   openvino_docs_MO_DG_FP16_Compression
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_TensorFlow
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_ONNX
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_PyTorch
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Paddle
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_MxNet
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Caffe
+   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Kaldi
+   openvino_docs_MO_DG_prepare_model_convert_model_tutorials
    openvino_docs_MO_DG_prepare_model_Model_Optimizer_FAQ
-   openvino_docs_MO_DG_Known_Issues_Limitations
-   openvino_docs_MO_DG_Default_Model_Optimizer_Optimizations
 
 @endsphinxdirective
 
-## Introduction 
+## Introduction
 
-Model Optimizer is a cross-platform command-line tool that facilitates the transition between the training and deployment environment, performs static model analysis, and adjusts deep learning models for optimal execution on end-point target devices.
+Model Optimizer is a cross-platform command-line tool that facilitates the transition between training and deployment environments, performs static model analysis, and adjusts deep learning models for optimal execution on end-point target devices.
 
-Model Optimizer process assumes you have a network model trained using supported deep learning frameworks: Caffe*, TensorFlow*, Kaldi*, MXNet* or converted to the ONNX* format. Model Optimizer produces an Intermediate Representation (IR) of the network, which can be inferred with the [OpenVINO™ Runtime](../OV_Runtime_UG/openvino_intro.md).
+Using Model Optimizer tool assumes you already have a deep learning model trained using one of the supported frameworks: TensorFlow, PyTorch, PaddlePaddle, MXNet, Caffe, Kaldi, or represented in ONNX* format. Model Optimizer produces an Intermediate Representation (IR) of the model, which can be inferred with [OpenVINO™ Runtime](../OV_Runtime_UG/openvino_intro.md).
 
-> **NOTE**: Model Optimizer does not infer models. Model Optimizer is an offline tool that runs before the inference takes place.
+> **NOTE**: Model Optimizer does not infer models. Model Optimizer is an offline tool that converts a model into IR and optimizes before the inference takes place.
 
-The scheme below illustrates the typical workflow for deploying a trained deep learning model: 
+The scheme below illustrates the typical workflow for deploying a trained deep learning model:
 
 ![](img/BASIC_FLOW_MO_simplified.svg)
 
-The IR is a pair of files describing the model: 
+The IR is a pair of files describing the model:
 
 *  <code>.xml</code> - Describes the network topology
 
 *  <code>.bin</code> - Contains the weights and biases binary data.
 
+> **NOTE**: The generated IR can be additionally optimized for inference by [Post-training optimization](../../tools/pot/docs/Introduction.md)
+> that applies post-training quantization methods.
+
 > **TIP**: You also can work with the Model Optimizer inside the OpenVINO™ [Deep Learning Workbench](https://docs.openvino.ai/latest/workbench_docs_Workbench_DG_Introduction.html) (DL Workbench).
 > [DL Workbench](https://docs.openvino.ai/latest/workbench_docs_Workbench_DG_Introduction.html) is a web-based graphical environment that enables you to optimize, fine-tune, analyze, visualize, and compare performance of deep learning models.
 
-## Install Model Optimizer Pre-Requisites
-
-Before running the Model Optimizer, you must install the Model Optimizer pre-requisites for the framework that was used to train the model.
-
-@sphinxdirective
-.. tab:: Using configuration scripts
-
-   .. tab:: Linux
-
-      .. tab:: All frameworks
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               ./install_prerequisites.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               ./install_prerequisites.shs
-
-      .. tab:: Caffe
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisitess
-               install_prerequisites_caffe.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_caffe.shs
-
-      .. tab:: Tensorflow 1.x
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_tf.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_tf.sh
-
-      .. tab:: Tensorflow 2.x
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_tf2.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_tf2.sh
-
-      .. tab:: MXNet
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_mxnet.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_mxnet.sh
-
-      .. tab:: ONNX
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_onnx.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_onnx.sh
-
-      .. tab:: Kaldi
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_kaldi.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_kaldi.sh
-
-   .. tab:: Windows
-
-      .. tab:: All frameworks
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites.bat
-
-      .. tab:: Caffe
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites_caffe.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites_caffe.bat
-
-      .. tab:: Tensorflow 1.x
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites_tf.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites_tf.bat
-
-      .. tab:: Tensorflow 2.x
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites_tf2.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites_tf2.bat
-
-      .. tab:: MXNet
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites_mxnet.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites_mxnet.bat
-
-      .. tab:: ONNX
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites_onnx.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites_onnx.bat
-
-      .. tab:: Kaldi
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites\
-               install_prerequisites_kaldi.bat
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>\deployment_tools\model_optimizer\install_prerequisites
-               virtualenv --system-site-packages -p python .\env
-               env\Scripts\activate.bat
-               install_prerequisites_kaldi.bat
-
-   .. tab:: macOS
-
-      .. tab:: All frameworks
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               ./install_prerequisites.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               ./install_prerequisites.shs
-
-      .. tab:: Caffe
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisitess
-               install_prerequisites_caffe.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_caffe.shs
-
-      .. tab:: Tensorflow 1.x
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_tf.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_tf.sh
-
-      .. tab:: Tensorflow 2.x
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_tf2.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_tf2.sh
-
-      .. tab:: MXNet
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_mxnet.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_mxnet.sh
-
-      .. tab:: ONNX
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_onnx.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_onnx.sh
-
-      .. tab:: Kaldi
-      
-         .. tab:: Install globally
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               install_prerequisites_kaldi.sh
-         
-         .. tab:: Install to virtualenv
-
-            .. code-block:: sh
-               
-               cd <INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites
-               virtualenv --system-site-packages -p python3 ./venv
-               source ./venv/bin/activate  # sh, bash, ksh, or zsh
-               install_prerequisites_kaldi.sh
-
-.. tab:: Using manual configuration process
-
-   .. tab:: Linux
-
-      .. tab:: All frameworks
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements.txt
-
-      .. tab:: Caffe
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_caffe.txt
-
-      .. tab:: Tensorflow 1.x
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_tf.txt
-
-      .. tab:: Tensorflow 2.x
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_tf2.txt
-
-      .. tab:: MXNet
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_mxnet.txt
-
-      .. tab:: ONNX
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_onnx.txt
-
-      .. tab:: Kaldi
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_kaldi.txt
-
-   .. tab:: Windows
-
-      .. tab:: All frameworks
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements.txt
-
-      .. tab:: Caffe
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements_caffe.txt
-
-      .. tab:: Tensorflow 1.x
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements_tf.txt
-
-      .. tab:: Tensorflow 2.x
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements_tf2.txt
-
-      .. tab:: MXNet
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements_mxnet.txt
-
-      .. tab:: ONNX
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements_onnx.txt
-
-      .. tab:: Kaldi
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>\deployment_tools\model_optimizer
-            virtualenv --system-site-packages -p python .\env
-            env\Scripts\activate.bat
-            pip install -r requirements_kaldi.txt
-
-   .. tab:: macOS
-
-      .. tab:: All frameworks
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements.txt
-
-      .. tab:: Caffe
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_caffe.txt
-
-      .. tab:: Tensorflow 1.x
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_tf.txt
-
-      .. tab:: Tensorflow 2.x
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_tf2.txt
-
-      .. tab:: MXNet
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_mxnet.txt
-
-      .. tab:: ONNX
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_onnx.txt
-
-      .. tab:: Kaldi
-      
-         .. code-block:: sh
-               
-            cd <INSTALL_DIR>/deployment_tools/model_optimizer/
-            virtualenv --system-site-packages -p python3 ./venv
-            source ./venv/bin/activate
-            pip3 install -r requirements_kaldi.txt
-
-@endsphinxdirective
-
 ## Run Model Optimizer
 
-To convert the model to the Intermediate Representation (IR), run Model Optimizer:
+To convert the model to IR, run Model Optimizer:
 
 ```sh
-mo --input_model INPUT_MODEL --output_dir <OUTPUT_MODEL_DIR>
+mo --input_model INPUT_MODEL
 ```
 
-You need to have write permissions for an output directory.
+If out-of-the-box conversion (only the `--input_model` parameter is specified) is not succeed,
+try to use parameters for overriding input shapes and cutting the model, mentioned below.
 
-> **NOTE**: Some models require using additional arguments to specify conversion parameters, such as `--input_shape`, `--scale`, `--scale_values`, `--mean_values`, `--mean_file`. To learn about when you need to use these parameters, refer to [Converting a Model to Intermediate Representation (IR)](prepare_model/convert_model/Converting_Model.md).
+To override original input shapes for model conversion, Model Optimizer provides two parameters: `--input` and `--input_shape`.
+For more information about these parameters, refer to [Setting Input Shapes](prepare_model/convert_model/Converting_Model.md).
 
-To adjust the conversion process, you may use general parameters defined in the [Converting a Model to Intermediate Representation (IR)](prepare_model/convert_model/Converting_Model.md) and 
-framework-specific parameters for:
-* [Caffe](prepare_model/convert_model/Convert_Model_From_Caffe.md)
-* [TensorFlow](prepare_model/convert_model/Convert_Model_From_TensorFlow.md)
-* [MXNet](prepare_model/convert_model/Convert_Model_From_MxNet.md)
-* [ONNX](prepare_model/convert_model/Convert_Model_From_ONNX.md)
-* [Kaldi](prepare_model/convert_model/Convert_Model_From_Kaldi.md)
+To cut off unwanted parts of a model, such as unsupported operations and training sub-graphs,
+the `--input` and `--output` parameters can be used, defining new inputs and outputs of the converted model.
+For a more detailed description, refer to [Cutting Off Parts of a Model](prepare_model/convert_model/Cutting_Model.md).
 
-## Videos
+Also, you can insert additional input pre-processing sub-graphs into the converted model using
+the `--mean_values`, `scales_values`, `--layout`, and other parameters described
+in [Embedding Preprocessing Computation](prepare_model/Additional_Optimizations.md).
 
-@sphinxdirective
+Model Optimizer's compression parameter `--data_type` allows to generate IR of the `FP16` data type. For more details,
+please refer to [Compression of a Model to FP16](prepare_model/FP16_Compression.md).
 
-.. list-table::
+To get the full list of conversion parameters available in Model Optimizer, run the following command:
 
-   * - .. raw:: html
+```sh
+mo --help
+```
 
-           <iframe allowfullscreen mozallowfullscreen msallowfullscreen oallowfullscreen webkitallowfullscreen width="220"
-           src="https://www.youtube.com/embed/Kl1ptVb7aI8">
-           </iframe>
-    
-     - .. raw:: html
+## Examples of CLI Commands
 
-           <iframe allowfullscreen mozallowfullscreen msallowfullscreen oallowfullscreen webkitallowfullscreen width="220"
-           src="https://www.youtube.com/embed/BBt1rseDcy0">
-           </iframe>
+Below is a list of separate examples for different frameworks and Model Optimizer parameters.
 
-     - .. raw:: html
+1. Launch Model Optimizer for a TensorFlow MobileNet model in the binary protobuf format.
+```sh
+mo --input_model MobileNet.pb
+```
+Launch Model Optimizer for a TensorFlow BERT model in the SavedModel format, with three inputs. Explicitly specify input shapes
+where the batch size and the sequence length equal 2 and 30 respectively.
+```sh
+mo --saved_model_dir BERT --input mask,word_ids,type_ids --input_shape [2,30],[2,30],[2,30]
+```
+For more information on TensorFlow model conversion,
+refer to [Converting a TensorFlow Model](prepare_model/convert_model/Convert_Model_From_TensorFlow.md).
 
-           <iframe allowfullscreen mozallowfullscreen msallowfullscreen oallowfullscreen webkitallowfullscreen width="220"
-           src="https://www.youtube.com/embed/RF8ypHyiKrY">
-           </iframe>
+2. Launch Model Optimizer for an ONNX OCR model and explicitly specify new output.
+```sh
+mo --input_model ocr.onnx --output probabilities
+```
+For more information on ONNX model conversion,
+please refer to [Converting an ONNX Model](prepare_model/convert_model/Convert_Model_From_ONNX.md).
+Note that PyTorch models must be exported to the ONNX format before its conversion into IR.
+More details can be found in [Converting a PyTorch Model](prepare_model/convert_model/Convert_Model_From_PyTorch.md).
 
-   * - **Model Optimizer Concept.**
-     - **Model Optimizer Basic Operation.**
-     - **Choosing the Right Precision.**
+3. Launch Model Optimizer for a PaddlePaddle UNet model and apply mean-scale normalization to the input.
+```sh
+mo --input_model unet.pdmodel --mean_values [123,117,104] --scale 255
+```
+For more information on PaddlePaddle model conversion, please refer to
+[Converting a PaddlePaddle Model](prepare_model/convert_model/Convert_Model_From_Paddle.md).
 
-   * - Duration: 3:56
-     - Duration: 2:57
-     - Duration: 4:18
+4. Launch Model Optimizer for an MXNet SSD Inception V3 model and specify first-channel layout for the input.
+```sh
+mo --input_model ssd_inception_v3-0000.params --layout NCHW
+```
+For more information on MXNet models conversion, please refer to [Converting an MXNet Model](prepare_model/convert_model/Convert_Model_From_MxNet.md).
 
-@endsphinxdirective
+5. Launch Model Optimizer for a Caffe AlexNet model with input channels in the RGB format, which needs to be reversed.
+```sh
+mo --input_model alexnet.caffemodel --reverse_input_channels
+```
+For more information on Caffe model conversion, please refer to [Converting a Caffe Model](prepare_model/convert_model/Convert_Model_From_Caffe.md).
+
+6. Launch Model Optimizer for a Kaldi LibriSpeech nnet2 model.
+```sh
+mo --input_model librispeech_nnet2.mdl --input_shape [1,140]
+```
+For more information on Kaldi model conversion,
+refer to [Converting a Kaldi Model](prepare_model/convert_model/Convert_Model_From_Kaldi.md).
+
+To get conversion recipes for specific TensorFlow, ONNX, PyTorch, MXNet, and Kaldi models,
+refer to [Model Conversion Tutorials](prepare_model/convert_model/Convert_Model_Tutorials.md).

docs/MO_DG/Known_Issues_Limitations.md

@@ -1,9 +0,0 @@
-# Known Issues and Limitations in the Model Optimizer {#openvino_docs_MO_DG_Known_Issues_Limitations}
-
-## Model Optimizer for TensorFlow* should be run on Intel® hardware that supports the AVX instruction set
-
-TensorFlow* provides only prebuilt binaries with AVX instructions enabled. When you're configuring the Model Optimizer by running the `install_prerequisites` or `install_prerequisites_tf` scripts, they download only those ones, which are not supported on hardware such as Intel® Pentium® processor N4200/5, N3350/5, N3450/5 (formerly known as Apollo Lake).
-
-To run the Model Optimizer on this hardware, you should compile TensorFlow binaries from source as described at the [TensorFlow website](https://www.tensorflow.org/install/source). 
-
-Another option is to run the Model Optimizer to generate an IR on hardware that supports AVX to and then perform inference on hardware without AVX.