Re-structure Model Optimizer User Guide and Clean-up (#10801)

* Modified the workflow diagram

* Moved supported topology lists to separate topics

* Additional changes

* Removed Supported Topologies list and Deprecated pages

* Created the Model Conversion Tutorials section for instructions for specific models

* Topic names alignment, removed Default_Model_Optimizer_Optimizations.md

* Additional structural changes

* Fixed links

* heading fixes

docs/MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md

@@ -7,18 +7,23 @@
 .. 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_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_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_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.
 
@@ -26,11 +31,11 @@ Model Optimizer process assumes you have a network model trained using supported
 
 > **NOTE**: Model Optimizer does not infer models. Model Optimizer is an offline tool that runs 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
 
@@ -49,14 +54,14 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
    .. 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
@@ -67,14 +72,14 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
                ./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
@@ -85,90 +90,90 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
                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
@@ -177,126 +182,126 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
    .. 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
@@ -305,14 +310,14 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
    .. 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
@@ -323,14 +328,14 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
                ./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
@@ -341,90 +346,90 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
                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
@@ -435,63 +440,63 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
    .. 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
@@ -500,63 +505,63 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
    .. 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
@@ -565,63 +570,63 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
    .. 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
@@ -634,21 +639,28 @@ Before running the Model Optimizer, you must install the Model Optimizer pre-req
 To convert the model to the Intermediate Representation (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.
+> **NOTE**: Some models require using additional arguments, such as `--input`, `--input_shape`, and `--output`. To learn about when you need to use these parameters, refer to [General Conversion Parameters](prepare_model/convert_model/Converting_Model.md).
 
-> **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 adjust the conversion process, you may use [general parameters](prepare_model/convert_model/Converting_Model.md) and framework-specific parameters for:
-
-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)
+* [PyTorch](prepare_model/convert_model/Convert_Model_From_PyTorch.md)
+* [PaddlePaddle](prepare_model/convert_model/Convert_Model_From_Paddle.md)
+* [MXNet](prepare_model/convert_model/Convert_Model_From_MxNet.md)
+* [Caffe](prepare_model/convert_model/Convert_Model_From_Caffe.md)
 * [Kaldi](prepare_model/convert_model/Convert_Model_From_Kaldi.md)
 
+## Examples of CLI Commands
+
+Launch the Model Optimizer for the Caffe bvlc_alexnet model:
+
+```sh
+mo --input_model bvlc_alexnet.caffemodel
+```
+
 ## Videos
 
 @sphinxdirective
@@ -660,7 +672,7 @@ framework-specific parameters for:
            <iframe allowfullscreen mozallowfullscreen msallowfullscreen oallowfullscreen webkitallowfullscreen width="220"
            src="https://www.youtube.com/embed/Kl1ptVb7aI8">
            </iframe>
-    
+
      - .. raw:: html
 
            <iframe allowfullscreen mozallowfullscreen msallowfullscreen oallowfullscreen webkitallowfullscreen width="220"

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.

docs/MO_DG/prepare_model/Additional_Optimizations.md

@@ -1,4 +1,4 @@
-# Optimize Preprocessing Computation{#openvino_docs_MO_DG_Additional_Optimization_Use_Cases}
+# Optimize Preprocessing Computation {#openvino_docs_MO_DG_Additional_Optimization_Use_Cases}
 
 Model Optimizer performs preprocessing to a model. It is possible to optimize this step and improve first inference time, to do that, follow the tips bellow:
 
@@ -13,3 +13,23 @@ Model Optimizer performs preprocessing to a model. It is possible to optimize th
 
 -	**Resulting IR precision**<br>
 The resulting IR precision, for instance, `FP16` or `FP32`, directly affects performance. As CPU now supports `FP16` (while internally upscaling to `FP32` anyway) and because this is the best precision for a GPU target, you may want to always convert models to `FP16`. Notice that this is the only precision that Intel&reg; Movidius&trade; Myriad&trade; 2 and Intel&reg; Myriad&trade; X VPUs support.
+
+## When to Specify Mean and Scale Values
+Usually neural network models are trained with the normalized input data. This means that the input data values are converted to be in a specific range, for example, `[0, 1]` or `[-1, 1]`. Sometimes the mean values (mean images) are subtracted from the input data values as part of the pre-processing. There are two cases how the input data pre-processing is implemented.
+ * The input pre-processing operations are a part of a topology. In this case, the application that uses the framework to infer the topology does not pre-process the input.
+ * The input pre-processing operations are not a part of a topology and the pre-processing is performed within the application which feeds the model with an input data.
+
+In the first case, the Model Optimizer generates the IR with required pre-processing operations and OpenVINO Samples may be used to infer the model.
+
+In the second case, information about mean/scale values should be provided to the Model Optimizer to embed it to the generated IR. Model Optimizer provides a number of command line parameters to specify them: `--mean`, `--scale`, `--scale_values`, `--mean_values`.
+
+> **NOTE:** If both mean and scale values are specified, the mean is subtracted first and then scale is applied regardless of the order of options in command line. Input values are *divided* by the scale value(s). If also `--reverse_input_channels` option is used, the reverse_input_channels will be applied first, then mean and after that scale.
+
+There is no a universal recipe for determining the mean/scale values for a particular model. The steps below could help to determine them:
+* Read the model documentation. Usually the documentation describes mean/scale value if the pre-processing is required.
+* Open the example script/application executing the model and track how the input data is read and passed to the framework.
+* Open the model in a visualization tool and check for layers performing subtraction or multiplication (like `Sub`, `Mul`, `ScaleShift`, `Eltwise` etc) of the input data. If such layers exist, pre-processing is probably part of the model.
+
+## When to Reverse Input Channels <a name="when_to_reverse_input_channels"></a>
+Input data for your application can be of RGB or BRG color input order. For example, OpenVINO Samples load input images in the BGR channels order. However, the model may be trained on images loaded with the opposite order (for example, most TensorFlow\* models are trained with images in RGB order). In this case, inference results using the OpenVINO samples may be incorrect. The solution is to provide `--reverse_input_channels` command line parameter. Taking this parameter, the Model Optimizer performs first convolution or other channel dependent operation weights modification so these operations output will be like the image is passed with RGB channels order.
+

docs/MO_DG/prepare_model/Default_Model_Optimizer_Optimizations.md

@@ -1,11 +0,0 @@
-# Default Model Optimizer Optimizations {#openvino_docs_MO_DG_Default_Model_Optimizer_Optimizations}
-
-Model Optimizer not only converts a model to IR format, but also performs a number of optimizations. For example, certain primitives like linear operations (BatchNorm and ScaleShift), are automatically fused into convolutions. Generally, these layers should not be manifested in the resulting IR:
-
-![](../img/optimizations/resnet_269.png)
-
-The picture above shows Caffe\* Resnet269\* topology. The left model is the original model, and the one on the right (after conversion) is the resulting model that the Model Optimizer produces, with BatchNorm and ScaleShift layers  fused into the convolution weights rather than constituting separate layers.
-
-If you still see these operations, inspect the Model Optimizer output carefully while searching for warnings, such as on the tool being unable to fuse. For example, non-linear operations (like activations) in between convolutions and linear operations might prevent the fusing. If performance is of concern, try to change (and potentially re-train) the topology. Refer to the [Model Optimizer Guide](Model_Optimization_Techniques.md) for more optimizations.
-
-Notice that the activation (`_relu`) is not touched by the Model Optimizer, and while it can be merged into convolution as well, this is rather a device-specific optimization, covered by OpenVINO Runtime during the model loading time. You are encouraged to inspect performance counters from plugins that should indicate that these particular layers are not executed (“Optimized out”). For more information, refer to <a href="#performance-counters">Internal Inference Performance Counters</a>.

docs/MO_DG/prepare_model/Model_Optimizer_FAQ.md

@@ -6,7 +6,7 @@ If your question is not covered by the topics below, use the [OpenVINO™ Su
 
 Internally, the Model Optimizer uses a protobuf library to parse and load Caffe\* models. This library requires a file grammar and a generated parser. For a Caffe fallback, the Model Optimizer uses a Caffe-generated parser for a Caffe-specific `.proto` file (which is usually located in the `src/caffe/proto` directory). So, if you have Caffe installed on your machine with Python* interface available, make sure that this is exactly the version of Caffe that was used to create the model.
 
-If you just want to experiment with the Model Optimizer and test a Python extension for working with your custom 
+If you just want to experiment with the Model Optimizer and test a Python extension for working with your custom
 layers without building Caffe, add the layer description to the `caffe.proto` file and generate a parser for it.
 
 For example, to add the description of the `CustomReshape` layer, which is an artificial layer not present in any `caffe.proto` files:
@@ -25,17 +25,17 @@ For example, to add the description of the `CustomReshape` layer, which is an ar
       optional BlobShape shape = 1; // we just use the same parameter type as some other Caffe layers
     }
 ```
-    
+
 2.  Generate a new parser:
 ```shell
 cd <SITE_PACKAGES_WITH_INSTALLED_OPENVINO>/openvino/tools/mo/front/caffe/proto
 python3 generate_caffe_pb2.py --input_proto <PATH_TO_CUSTOM_CAFFE>/src/caffe/proto/caffe.proto
 ```
 where `PATH_TO_CUSTOM_CAFFE` is the path to the root directory of custom Caffe\*.
-    
+
 3.  Now, the Model Optimizer is able to load the model into memory and start working with your extensions if there are any.
 
-However, because your model has custom layers, you must register your custom layers as custom. To learn more about it, refer to the section [Custom Layers in Model Optimizer](customize_model_optimizer/Customize_Model_Optimizer.md). 
+However, because your model has custom layers, you must register your custom layers as custom. To learn more about it, refer to the section [Custom Layers in Model Optimizer](customize_model_optimizer/Customize_Model_Optimizer.md).
 
 #### 2. How do I create a bare caffemodel, if I have only prototxt? <a name="question-2"></a>
 
@@ -48,8 +48,8 @@ net.save('<PATH_TO_PROTOTXT>/my_net.caffemodel')
 ```
 #### 3. What does the message "[ ERROR ]: Unable to create ports for node with id" mean? <a name="question-3"></a>
 
-Most likely, the Model Optimizer does not know how to infer output shapes of some layers in the given topology. 
+Most likely, the Model Optimizer does not know how to infer output shapes of some layers in the given topology.
-To lessen the scope, compile the list of layers that are custom for the Model Optimizer: present in the topology, 
+To lessen the scope, compile the list of layers that are custom for the Model Optimizer: present in the topology,
 absent in [list of supported layers](Supported_Frameworks_Layers.md) for the target framework. Then refer to available options in the corresponding section in [Custom Layers in Model Optimizer](customize_model_optimizer/Customize_Model_Optimizer.md).
 
 #### 4. What does the message "Input image of shape is larger than mean image from file" mean? <a name="question-4"></a>
@@ -100,7 +100,7 @@ message NetParameter {
 ```
 So, the input layer of the provided model must be specified in one of the following styles:
 
-*   
+*
 ```sh
 input: "data"
 input_shape
@@ -111,8 +111,8 @@ input_shape
     dim: 227
 }
 ```
-    
+
-*   
+*
 ```sh
 input: "data"
 input_shape
@@ -129,7 +129,7 @@ input_shape
      dim: 3
 }
 ```
-*   
+*
 ```sh
 layer
 {
@@ -146,7 +146,7 @@ layer
     input_param {shape: {dim: 1 dim: 3}}
 }
 ```
-*   
+*
 ```sh
 input: "data"
 input_dim: 1
@@ -252,7 +252,7 @@ Looks like you have provided only one shape for the placeholder, however there a
 
 #### 33. What does the message "The amount of input nodes for port is not equal to 1" mean? <a name="question-33"></a>
 
-This error occurs when the `SubgraphMatch.single_input_node` function is used for an input port that supplies more than one node in a sub-graph. The `single_input_node` function can be used only for ports that has a single consumer inside the matching sub-graph. When multiple nodes are connected to the port, use the `input_nodes` function or `node_by_pattern` function instead of `single_input_node`. Please, refer to [Sub-Graph Replacement in the Model Optimizer](customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md) for more details.
+This error occurs when the `SubgraphMatch.single_input_node` function is used for an input port that supplies more than one node in a sub-graph. The `single_input_node` function can be used only for ports that has a single consumer inside the matching sub-graph. When multiple nodes are connected to the port, use the `input_nodes` function or `node_by_pattern` function instead of `single_input_node`. Please, refer to **Graph Transformation Extensions** section in the [Model Optimizer Extensibility](customize_model_optimizer/Customize_Model_Optimizer.md) documentation for more details.
 
 #### 34. What does the message "Output node for port has already been specified" mean? <a name="question-34"></a>
 
@@ -350,7 +350,7 @@ You cannot specify the batch and the input shape at the same time. You should sp
 
 The specified input shape cannot be parsed. Please, define it in one of the following ways:
 
-*   
+*
 ```shell
  mo --input_model <INPUT_MODEL>.caffemodel --input_shape (1,3,227,227)
 ```
@@ -447,7 +447,7 @@ This message may appear when the `--data_type=FP16` command line option is used.
 
 #### 78. What does the message "The amount of nodes matched pattern ... is not equal to 1" mean? <a name="question-78"></a>
 
-This error occurs when the `SubgraphMatch.node_by_pattern` function is used with a pattern that does not uniquely identify a single node in a sub-graph. Try to extend the pattern string to make unambiguous match to a single sub-graph node. For more details, refer to [Sub-graph Replacement in the Model Optimizer](customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md).
+This error occurs when the `SubgraphMatch.node_by_pattern` function is used with a pattern that does not uniquely identify a single node in a sub-graph. Try to extend the pattern string to make unambiguous match to a single sub-graph node. For more details, refer to **Graph Transformation Extensions** section in the [Model Optimizer Extensibility](customize_model_optimizer/Customize_Model_Optimizer.md) documentation.
 
 #### 79. What does the message "The topology contains no "input" layers" mean? <a name="question-79"></a>
 
@@ -459,18 +459,18 @@ You are using an unsupported Python\* version. Use only versions 3.4 - 3.6 for t
 
 #### 81. What does the message "Arguments --nd_prefix_name, --pretrained_model_name and --input_symbol should be provided. Please provide all or do not use any." mean? <a name="question-81"></a>
 
-This error occurs if you do not provide `--nd_prefix_name`, `--pretrained_model_name` and `--input_symbol` parameters. 
+This error occurs if you do not provide `--nd_prefix_name`, `--pretrained_model_name` and `--input_symbol` parameters.
-Model Optimizer requires both `.params` and `.nd` model files to merge into the result file (`.params`). Topology 
+Model Optimizer requires both `.params` and `.nd` model files to merge into the result file (`.params`). Topology
 description (`.json` file) should be prepared (merged) in advance and provided with `--input_symbol` parameter.
 
-If you add to your model additional layers and weights that are in `.nd` files, the Model Optimizer can build a model 
+If you add to your model additional layers and weights that are in `.nd` files, the Model Optimizer can build a model
 from one `.params` file and two additional `.nd` files (`*_args.nd`, `*_auxs.nd`).
 To do that, provide both CLI options or do not pass them if you want to convert an MXNet model without additional weights.
 For more information, refer to [Converting a MXNet* Model](convert_model/Convert_Model_From_MxNet.md).
 
 #### 82. What does the message "You should specify input for mean/scale values" mean? <a name="question-82"></a>
 
-In case when the model has multiple inputs and you want to provide mean/scale values, you need to pass those values for each input. More specifically, a number of passed values should be the same as the number of inputs of the model. 
+In case when the model has multiple inputs and you want to provide mean/scale values, you need to pass those values for each input. More specifically, a number of passed values should be the same as the number of inputs of the model.
 For more information, refer to [Converting a Model to Intermediate Representation](convert_model/Converting_Model.md).
 
 #### 83. What does the message "Input with name ... not found!" mean? <a name="question-83"></a>
@@ -490,7 +490,7 @@ For more information, refer to [Converting a MXNet* Model](convert_model/Convert
 
 #### 86. What does the message "Operation ... not supported. Please register it as custom op" mean? <a name="question-86"></a>
 
-Model Optimizer tried to load the model that contains some unsupported operations. 
+Model Optimizer tried to load the model that contains some unsupported operations.
 If you want to convert model that contains unsupported operations you need to prepare extension for all such operations.
 For more information, refer to [OpenVINO™ Extensibility Mechanism](../../Extensibility_UG/Intro.md).
 
@@ -499,7 +499,7 @@ For more information, refer to [OpenVINO™ Extensibility Mechanism](../../Exten
 This error appears if the class of implementation of op for Python Caffe layer could not be used by Model Optimizer. Python layers should be handled differently compared to ordinary Caffe layers.
 
 In particular, you need to call the function `register_caffe_python_extractor` and pass `name` as the second argument of the function.
-The name should be the compilation of the layer name and the module name separated by a dot. 
+The name should be the compilation of the layer name and the module name separated by a dot.
 
 For example, your topology contains this layer with type `Python`:
 
@@ -520,7 +520,7 @@ What you do first is implementing an extension for this layer in the Model Optim
 ```
 class ProposalPythonExampleOp(Op):
        op = 'Proposal'
-   
+
        def __init__(self, graph: nx.MultiDiGraph, attrs: dict):
            ...
 ```
@@ -536,25 +536,25 @@ Op.excluded_classes.append(ProposalPythonExampleOp)
 
 Note that the first call <code>register_caffe_python_extractor(ProposalPythonExampleOp, 'rpn.proposal_layer.ProposalLayer')</code> registers extension of the layer in the Model Optimizer that will be found by the specific name (mandatory to join module name and layer name): <code>rpn.proposal_layer.ProposalLayer</code>.
 
-The second call prevents Model Optimizer from using this extension as if it is an extension for 
+The second call prevents Model Optimizer from using this extension as if it is an extension for
 a layer with type `Proposal`. Otherwise, this layer can be chosen as an implementation of extension that can lead to potential issues.
 For more information, refer to the [OpenVINO™ Extensibility Mechanism](../../Extensibility_UG/Intro.md).
 
 #### 88. What does the message "Model Optimizer is unable to calculate output shape of Memory node .." mean? <a name="question-88"></a>
 
-Model Optimizer supports only `Memory` layers, in which `input_memory` goes before `ScaleShift` or `FullyConnected` layer.  
+Model Optimizer supports only `Memory` layers, in which `input_memory` goes before `ScaleShift` or `FullyConnected` layer.
 This error message means that in your model the layer after input memory is not of type `ScaleShift` or `FullyConnected`.
 This is a known limitation.
 
 #### 89. What do the messages "File ...  does not appear to be a Kaldi file (magic number does not match)", "Kaldi model should start with <Nnet> tag" mean? <a name="question-89"></a>
 
-These error messages mean that the Model Optimizer does not support your Kaldi\* model, because check sum of the model is not 
+These error messages mean that the Model Optimizer does not support your Kaldi\* model, because check sum of the model is not
 16896 (the model should start with this number) or model file does not contain tag `<Net>` as a starting one.
 Double check that you provide a path to a true Kaldi model and try again.
 
 #### 90. What do the messages "Expect counts file to be one-line file." or "Expect counts file to contain list of integers" mean? <a name="question-90"></a>
 
-These messages mean that you passed the file counts containing not one line. The count file should start with 
+These messages mean that you passed the file counts containing not one line. The count file should start with
 `[` and end with  `]`,  and integer values should be separated by space between those signs.
 
 #### 91. What does the message "Model Optimizer is not able to read Kaldi model .." mean? <a name="question-91"></a>
@@ -570,8 +570,8 @@ file is not available or does not exist. Also refer to FAQ [#90](#question-90).
 #### 93. What does the message "For legacy MXNet models Model Optimizer does not support conversion of old MXNet models (trained with 1.0.0 version of MXNet and lower) with custom layers." mean? <a name="question-93"></a>
 
 This message means that if you have model with custom layers and its json file has been generated with MXNet version
-lower than 1.0.0, Model Optimizer does not support such topologies. If you want to convert it you have to rebuild 
+lower than 1.0.0, Model Optimizer does not support such topologies. If you want to convert it you have to rebuild
-MXNet with unsupported layers or generate new json with MXNet version 1.0.0 and higher. Also you need to implement 
+MXNet with unsupported layers or generate new json with MXNet version 1.0.0 and higher. Also you need to implement
 OpenVINO extension for used custom layers.
 For more information, refer to the [OpenVINO™ Extensibility Mechanism](../../Extensibility_UG/Intro.md).
 
@@ -581,11 +581,11 @@ Model Optimizer supports only straightforward models without cycles.
 
 There are multiple ways to avoid cycles:
 
-For Tensorflow: 
+For Tensorflow:
 * [Convert models, created with TensorFlow Object Detection API](convert_model/tf_specific/Convert_Object_Detection_API_Models.md)
 
-For all frameworks: 
+For all frameworks:
-1. [Replace cycle containing Sub-graph in Model Optimizer](customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md)
+1. [Replace cycle containing Sub-graph in Model Optimizer](customize_model_optimizer/Customize_Model_Optimizer.md)
 2. [OpenVINO™ Extensibility Mechanism](../../Extensibility_UG/Intro.md)
 
 or
@@ -596,7 +596,7 @@ or
 This message means that model is not supported. It may be caused by using shapes larger than 4-D.
 There are two ways to avoid such message:
 
-1. [Cut model part containing such layers in Model Optimizer](convert_model/Cutting_Model.md) 
+1. [Cut model part containing such layers in Model Optimizer](convert_model/Cutting_Model.md)
 2. Edit network in original framework to exclude such layers.
 
 #### 99. What does the message "Expected token `</ParallelComponent>`, has `...`" mean?  <a name="question-99"></a>
@@ -611,7 +611,7 @@ But there are exceptions. For example, output value of layer Interp is calculate
 
 #### 101. What does the message "Mean/scale values should ..." mean? <a name="question-101"></a>
 
-It means that your mean/scale values have wrong format. Specify mean/scale values using the form `layer_name(val1,val2,val3)`. 
+It means that your mean/scale values have wrong format. Specify mean/scale values using the form `layer_name(val1,val2,val3)`.
 You need to specify values for each input of the model. For more information, refer to [Converting a Model to Intermediate Representation](convert_model/Converting_Model.md).
 
 #### 102. What does the message "Operation _contrib_box_nms is not supported ..." mean? <a name="question-102"></a>
@@ -632,10 +632,10 @@ Note that you might have conflicts between previously installed PyPI dependencie
 
 #### 105. What does the message "The IR preparation was executed by the legacy MO path. ..." mean? <a name="question-105"></a>
 
-For the models in ONNX* format, there are two available paths of IR conversion. 
+For the models in ONNX* format, there are two available paths of IR conversion.
-The old one is handled by the old Python* implementation, while the new one uses new C++ frontends. 
+The old one is handled by the old Python* implementation, while the new one uses new C++ frontends.
-Starting from the 2022.1 version, the default IR conversion path for ONNX models is processed using the new ONNX frontend. 
+Starting from the 2022.1 version, the default IR conversion path for ONNX models is processed using the new ONNX frontend.
-Certain features, such as `--extensions` and `--transformations_config`, are not yet fully supported on the new frontends. 
+Certain features, such as `--extensions` and `--transformations_config`, are not yet fully supported on the new frontends.
-For `--extensions`, the new frontends support only paths to shared libraries (.dll and .so). For `--transformations_config`, they support JSON configurations with defined library fields. 
+For `--extensions`, the new frontends support only paths to shared libraries (.dll and .so). For `--transformations_config`, they support JSON configurations with defined library fields.
-Inputs freezing (enabled by `--freeze_placeholder_with_value` or `--input` arguments) is not supported on the new frontends. 
+Inputs freezing (enabled by `--freeze_placeholder_with_value` or `--input` arguments) is not supported on the new frontends.
 The IR conversion falls back to the old path if a user does not select any expected path of conversion explicitly (by `--use_new_frontend` or `--use_legacy_frontend` MO arguments) and unsupported pre-defined scenario is detected on the new frontend path.

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_Caffe.md

@@ -1,11 +1,5 @@
 # Converting a Caffe* Model {#openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Caffe}
 
-@sphinxdirective
-
-.. _convert model caffe:
-
-@endsphinxdirective
-
 A summary of the steps for optimizing and deploying a model that was trained with Caffe\*:
 
 1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for Caffe\*.
@@ -13,33 +7,6 @@ A summary of the steps for optimizing and deploying a model that was trained wit
 3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in the target environment via provided [OpenVINO samples](../../../OV_Runtime_UG/Samples_Overview.md)
 4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in your application to deploy the model in the target environment
 
-## Supported Topologies
-
-* **Classification models:**
-	* AlexNet
-	* VGG-16, VGG-19
-	* SqueezeNet v1.0, SqueezeNet v1.1
-	* ResNet-50, ResNet-101, Res-Net-152
-	* Inception v1, Inception v2, Inception v3, Inception v4
-	* CaffeNet
-	* MobileNet
-	* Squeeze-and-Excitation Networks: SE-BN-Inception, SE-Resnet-101, SE-ResNet-152, SE-ResNet-50, SE-ResNeXt-101, SE-ResNeXt-50
-	* ShuffleNet v2
-
-* **Object detection models:**
-	* SSD300-VGG16, SSD500-VGG16
-	* Faster-RCNN
-	* RefineDet (MYRIAD plugin only)
-
-* **Face detection models:**
-	* VGG Face
-    * SSH: Single Stage Headless Face Detector
-
-* **Semantic segmentation models:**
-	* FCN8
-
-> **NOTE**: It is necessary to specify mean and scale values for most of the Caffe\* models to convert them with the Model Optimizer. The exact values should be determined separately for each model. For example, for Caffe\* models trained on ImageNet, the mean values usually are `123.68`, `116.779`, `103.939` for blue, green and red channels respectively. The scale value is usually `127.5`. Refer to the General Conversion Parameters section in [Converting a Model to Intermediate Representation (IR)](Converting_Model.md) for the information on how to specify mean and scale values.
-
 ## Convert a Caffe* Model <a name="Convert_From_Caffe"></a>
 
 To convert a Caffe\* model, run Model Optimizer with the path to the input model `.caffemodel` file and the path to an output directory with write permissions:
@@ -96,7 +63,7 @@ Caffe*-specific parameters:
 #### Command-Line Interface (CLI) Examples Using Caffe\*-Specific Parameters
 
 * Launching the Model Optimizer for the [bvlc_alexnet.caffemodel](https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet) with a specified `prototxt` file. This is needed when the name of the Caffe\* model and the `.prototxt` file are different or are placed in different directories. Otherwise, it is enough to provide only the path to the input `model.caffemodel` file. You must have write permissions for the output directory.
-   ```sh    
+   ```sh
    mo --input_model bvlc_alexnet.caffemodel --input_proto bvlc_alexnet.prototxt --output_dir <OUTPUT_MODEL_DIR>
    ```
 * Launching the Model Optimizer for the [bvlc_alexnet.caffemodel](https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet) with a specified `CustomLayersMapping` file. This is the legacy method of quickly enabling model conversion if your model has custom layers. This requires the Caffe\* system on the computer.
@@ -146,3 +113,6 @@ In this document, you learned:
 * Basic information about how the Model Optimizer works with Caffe\* models
 * Which Caffe\* models are supported
 * How to convert a trained Caffe\* model using the Model Optimizer with both framework-agnostic and Caffe-specific command-line options
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_Kaldi.md

@@ -1,17 +1,5 @@
 # Converting a Kaldi* Model {#openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Kaldi}
 
-@sphinxdirective
-
-.. _convert model kaldi:
-
-.. toctree::
-   :maxdepth: 1
-   :hidden:
-
-   openvino_docs_MO_DG_prepare_model_convert_model_kaldi_specific_Aspire_Tdnn_Model
-
-@endsphinxdirective
-
 A summary of the steps for optimizing and deploying a model that was trained with Kaldi\*:
 
 1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for Kaldi\*.
@@ -21,26 +9,6 @@ A summary of the steps for optimizing and deploying a model that was trained wit
 
 > **NOTE**: The Model Optimizer supports the [nnet1](http://kaldi-asr.org/doc/dnn1.html) and [nnet2](http://kaldi-asr.org/doc/dnn2.html) formats of Kaldi models. Support of the [nnet3](http://kaldi-asr.org/doc/dnn3.html) format is limited.
 
-## Supported Topologies
-* Convolutional Neural Networks (CNN):
-    * Wall Street Journal CNN (wsj_cnn4b)
-    * Resource Management CNN (rm_cnn4a_smbr)
-
-* Long Short Term Memory (LSTM) Networks:
-    * Resource Management LSTM (rm_lstm4f)
-    * TED-LIUM LSTM (ted_lstm4f)
-
-* Deep Neural Networks (DNN):
-    * Wall Street Journal DNN (wsj_dnn5b_smbr);
-    * TED-LIUM DNN (ted_dnn_smbr)
-
-* Time delay neural network (TDNN)
-    * [ASpIRE Chain TDNN](kaldi_specific/Aspire_Tdnn_Model.md);
-    * [Librispeech nnet3](https://github.com/ryanleary/kaldi-test/releases/download/v0.0/LibriSpeech-trained.tgz).
-
-* TDNN-LSTM model
-
-
 ## Convert a Kaldi* Model <a name="Convert_From_Kaldi"></a>
 
 To convert a Kaldi\* model, run Model Optimizer with the path to the input model `.nnet` or `.mdl` file and to an output directory where you have write permissions:
@@ -99,23 +67,25 @@ Kaldi-specific parameters:
 The Model Optimizer finds the last layer of the topology and removes this layer only if it is a SoftMax layer.
 
   > **NOTE**: Model Optimizer can remove SoftMax layer only if the topology has one output.
- 
+
-  > **NOTE**: For sample inference of Kaldi models, you can use the OpenVINO Speech Recognition sample application. The sample supports models with one output. If your model has several outputs, specify the desired one with the `--output` option.    
+  > **NOTE**: For sample inference of Kaldi models, you can use the OpenVINO Speech Recognition sample application. The sample supports models with one output. If your model has several outputs, specify the desired one with the `--output` option.
-  
+
- If you want to convert a model for inference on Intel® Movidius™ Myriad™, use the `--remove_memory` option. 
+ If you want to convert a model for inference on Intel® Movidius™ Myriad™, use the `--remove_memory` option.
-It removes Memory layers from the IR. Instead of it, additional inputs and outputs appear in the IR. 
+It removes Memory layers from the IR. Instead of it, additional inputs and outputs appear in the IR.
 The Model Optimizer outputs the mapping between inputs and outputs. For example:
 ```sh
-[ WARNING ]  Add input/output mapped Parameter_0_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out -> Result_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out 
+[ WARNING ]  Add input/output mapped Parameter_0_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out -> Result_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out
-[ WARNING ]  Add input/output mapped Parameter_1_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out -> Result_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out 
+[ WARNING ]  Add input/output mapped Parameter_1_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out -> Result_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out
-[ WARNING ]  Add input/output mapped Parameter_0_for_iteration_Offset_fastlstm3.c_trunc__3390 -> Result_for_iteration_Offset_fastlstm3.c_trunc__3390 
+[ WARNING ]  Add input/output mapped Parameter_0_for_iteration_Offset_fastlstm3.c_trunc__3390 -> Result_for_iteration_Offset_fastlstm3.c_trunc__3390
 ```
  Based on this mapping, link inputs and outputs in your application manually as follows:
- 
-1. Initialize inputs from the mapping as zeros in the first frame of an utterance.
-2. Copy output blobs from the mapping to the corresponding inputs. For example, data from `Result_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out` 
-must be copied to `Parameter_0_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out`.
 
+1. Initialize inputs from the mapping as zeros in the first frame of an utterance.
+2. Copy output blobs from the mapping to the corresponding inputs. For example, data from `Result_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out`
+must be copied to `Parameter_0_for_Offset_fastlstm2.r_trunc__2Offset_fastlstm2.r_trunc__2_out`.
 
 ## Supported Kaldi\* Layers
 Refer to [Supported Framework Layers ](../Supported_Frameworks_Layers.md) for the list of supported standard layers.
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_MxNet.md

@@ -1,18 +1,5 @@
 # Converting an MXNet* Model {#openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_MxNet}
 
-@sphinxdirective
-
-.. _convert model mxnet:
-
-.. toctree::
-   :maxdepth: 1
-   :hidden:
-
-   openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_Style_Transfer_From_MXNet
-   openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_GluonCV_Models
-
-@endsphinxdirective
-
 A summary of the steps for optimizing and deploying a model that was trained with the MXNet\* framework:
 
 1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for MXNet* (MXNet was used to train your model)
@@ -20,40 +7,6 @@ A summary of the steps for optimizing and deploying a model that was trained wit
 3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in the target environment via provided [OpenVINO Samples](../../../OV_Runtime_UG/Samples_Overview.md)
 4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in your application to deploy the model in the target environment
 
-## Supported Topologies
-
-> **NOTE**: SSD models from the table require converting to the deploy mode. For details, see the [Conversion Instructions](https://github.com/zhreshold/mxnet-ssd/#convert-model-to-deploy-mode) in the GitHub MXNet-SSD repository.
-
-| Model Name| Model File |
-| ------------- |:-------------:|
-|VGG-16|	[Repo](https://github.com/dmlc/mxnet-model-gallery/tree/master), [Symbol](http://data.mxnet.io/models/imagenet/vgg/vgg16-symbol.json), [Params](http://data.mxnet.io/models/imagenet/vgg/vgg16-0000.params)|
-|VGG-19|	[Repo](https://github.com/dmlc/mxnet-model-gallery/tree/master), [Symbol](http://data.mxnet.io/models/imagenet/vgg/vgg19-symbol.json), [Params](http://data.mxnet.io/models/imagenet/vgg/vgg19-0000.params)|
-|ResNet-152 v1|	[Repo](https://github.com/dmlc/mxnet-model-gallery/tree/master), [Symbol](http://data.mxnet.io/models/imagenet/resnet/152-layers/resnet-152-symbol.json), [Params](http://data.mxnet.io/models/imagenet/resnet/152-layers/resnet-152-0000.params)|
-|SqueezeNet_v1.1|	[Repo](https://github.com/dmlc/mxnet-model-gallery/tree/master), [Symbol](http://data.mxnet.io/models/imagenet/squeezenet/squeezenet_v1.1-symbol.json), [Params](http://data.mxnet.io/models/imagenet/squeezenet/squeezenet_v1.1-0000.params)|
-|Inception BN|	[Repo](https://github.com/dmlc/mxnet-model-gallery/tree/master), [Symbol](http://data.mxnet.io/models/imagenet/inception-bn/Inception-BN-symbol.json), [Params](http://data.mxnet.io/models/imagenet/inception-bn/Inception-BN-0126.params)|
-|CaffeNet|	[Repo](https://github.com/dmlc/mxnet-model-gallery/tree/master), [Symbol](http://data.mxnet.io/mxnet/models/imagenet/caffenet/caffenet-symbol.json), [Params](http://data.mxnet.io/models/imagenet/caffenet/caffenet-0000.params)|
-|DenseNet-121|	[Repo](https://github.com/miraclewkf/DenseNet), [Symbol](https://raw.githubusercontent.com/miraclewkf/DenseNet/master/model/densenet-121-symbol.json), [Params](https://drive.google.com/file/d/0ByXcv9gLjrVcb3NGb1JPa3ZFQUk/view?usp=drive_web)|
-|DenseNet-161|	[Repo](https://github.com/miraclewkf/DenseNet), [Symbol](https://raw.githubusercontent.com/miraclewkf/DenseNet/master/model/densenet-161-symbol.json), [Params](https://drive.google.com/file/d/0ByXcv9gLjrVcS0FwZ082SEtiUjQ/view)|
-|DenseNet-169| 	[Repo](https://github.com/miraclewkf/DenseNet), [Symbol](https://raw.githubusercontent.com/miraclewkf/DenseNet/master/model/densenet-169-symbol.json), [Params](https://drive.google.com/file/d/0ByXcv9gLjrVcOWZJejlMOWZvZmc/view)|
-|DenseNet-201|	[Repo](https://github.com/miraclewkf/DenseNet), [Symbol](https://raw.githubusercontent.com/miraclewkf/DenseNet/master/model/densenet-201-symbol.json), [Params](https://drive.google.com/file/d/0ByXcv9gLjrVcUjF4MDBwZ3FQbkU/view)|
-|MobileNet|	[Repo](https://github.com/KeyKy/mobilenet-mxnet), [Symbol](https://github.com/KeyKy/mobilenet-mxnet/blob/master/mobilenet.py), [Params](https://github.com/KeyKy/mobilenet-mxnet/blob/master/mobilenet-0000.params)|
-|SSD-ResNet-50|	[Repo](https://github.com/zhreshold/mxnet-ssd), [Symbol + Params](https://github.com/zhreshold/mxnet-ssd/releases/download/v0.6/resnet50_ssd_512_voc0712_trainval.zip)|
-|SSD-VGG-16-300|	[Repo](https://github.com/zhreshold/mxnet-ssd), [Symbol + Params](https://github.com/zhreshold/mxnet-ssd/releases/download/v0.5-beta/vgg16_ssd_300_voc0712_trainval.zip)|
-|SSD-Inception v3|	[Repo](https://github.com/zhreshold/mxnet-ssd), [Symbol + Params](https://github.com/zhreshold/mxnet-ssd/releases/download/v0.7-alpha/ssd_inceptionv3_512_voc0712trainval.zip)|
-|FCN8 (Semantic Segmentation)|	[Repo](https://github.com/apache/incubator-mxnet/tree/master/example/fcn-xs), [Symbol](https://www.dropbox.com/sh/578n5cxej7ofd6m/AAA9SFCBN8R_uL2CnAd3WQ5ia/FCN8s_VGG16-symbol.json?dl=0), [Params](https://www.dropbox.com/sh/578n5cxej7ofd6m/AABHWZHCtA2P6iR6LUflkxb_a/FCN8s_VGG16-0019-cpu.params?dl=0)|
-|MTCNN part 1 (Face Detection)| [Repo](https://github.com/pangyupo/mxnet_mtcnn_face_detection), [Symbol](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det1-symbol.json), [Params](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det1-0001.params)|
-|MTCNN part 2 (Face Detection)| [Repo](https://github.com/pangyupo/mxnet_mtcnn_face_detection), [Symbol](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det2-symbol.json), [Params](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det2-0001.params)|
-|MTCNN part 3 (Face Detection)| [Repo](https://github.com/pangyupo/mxnet_mtcnn_face_detection), [Symbol](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det3-symbol.json), [Params](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det3-0001.params)|
-|MTCNN part 4 (Face Detection)| [Repo](https://github.com/pangyupo/mxnet_mtcnn_face_detection), [Symbol](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det4-symbol.json), [Params](https://github.com/pangyupo/mxnet_mtcnn_face_detection/blob/master/model/det4-0001.params)|
-|Lightened_moon| [Repo](https://github.com/tornadomeet/mxnet-face/tree/master/model/lightened_moon), [Symbol](https://github.com/tornadomeet/mxnet-face/blob/master/model/lightened_moon/lightened_moon_fuse-symbol.json), [Params](https://github.com/tornadomeet/mxnet-face/blob/master/model/lightened_moon/lightened_moon_fuse-0082.params)|
-|RNN-Transducer| [Repo](https://github.com/HawkAaron/mxnet-transducer) |
-|word_lm| [Repo](https://github.com/apache/incubator-mxnet/tree/master/example/rnn/word_lm) |
-
-**Other supported topologies**
-
-* [GluonCV SSD and YOLO-v3 models](https://gluon-cv.mxnet.io/model_zoo/detection.html) can be converted using the following [instructions](mxnet_specific/Convert_GluonCV_Models.md).
-* [Style transfer model](https://github.com/zhaw/neural_style) can be converted using the following [instructions](mxnet_specific/Convert_Style_Transfer_From_MXNet.md).
-
 ## Convert an MXNet* Model <a name="ConvertMxNet"></a>
 
 To convert an MXNet\* model, run Model Optimizer with a path to the input model `.params` file and to an output directory where you have write permissions:
@@ -114,3 +67,6 @@ In this document, you learned:
 * Basic information about how the Model Optimizer works with MXNet\* models
 * Which MXNet\* models are supported
 * How to convert a trained MXNet\* model using the Model Optimizer with both framework-agnostic and MXNet-specific command-line options
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_ONNX.md

@@ -1,75 +1,9 @@
 # Converting a ONNX* Model {#openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_ONNX}
 
-@sphinxdirective
-
-.. _convert model onnx:
-
-.. toctree::
-   :maxdepth: 1
-   :hidden:
-
-   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Faster_RCNN
-   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Mask_RCNN
-   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_GPT2
-   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_DLRM
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_PyTorch
-
-@endsphinxdirective
-
 ## Introduction to ONNX
 
 [ONNX*](https://github.com/onnx/onnx) is a representation format for deep learning models. ONNX allows AI developers easily transfer models between different frameworks that helps to choose the best combination for them. Today, PyTorch\*, Caffe2\*, Apache MXNet\*, Microsoft Cognitive Toolkit\* and other tools are developing ONNX support.
 
-## Supported Public ONNX Topologies
-| Model Name | Path to <a href="https://github.com/onnx/models">Public Models</a> master branch|
-|:----|:----|
-| bert_large | [model archive](https://github.com/mlperf/inference/tree/master/v0.7/language/bert) |
-| bvlc_alexnet | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/bvlc_alexnet.tar.gz) |
-| bvlc_googlenet | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/bvlc_googlenet.tar.gz) |
-| bvlc_reference_caffenet | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/bvlc_reference_caffenet.tar.gz) |
-| bvlc_reference_rcnn_ilsvrc13 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/bvlc_reference_rcnn_ilsvrc13.tar.gz) |
-| inception_v1 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/inception_v1.tar.gz) |
-| inception_v2 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/inception_v2.tar.gz) |
-| resnet50 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/resnet50.tar.gz) |
-| squeezenet | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/squeezenet.tar.gz) |
-| densenet121 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/densenet121.tar.gz) |
-| emotion_ferplus | [model archive](https://www.cntk.ai/OnnxModels/emotion_ferplus/opset_2/emotion_ferplus.tar.gz) |
-| mnist | [model archive](https://www.cntk.ai/OnnxModels/mnist/opset_1/mnist.tar.gz) |
-| shufflenet | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/shufflenet.tar.gz) |
-| VGG19 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/vgg19.tar.gz) |
-| zfnet512 | [model archive](https://s3.amazonaws.com/download.onnx/models/opset_8/zfnet512.tar.gz) |
-| GPT-2 | [model archive](https://github.com/onnx/models/blob/master/text/machine_comprehension/gpt-2/model/gpt2-10.tar.gz) |
-| YOLOv3 | [model archive](https://github.com/onnx/models/blob/master/vision/object_detection_segmentation/yolov3/model/yolov3-10.tar.gz) |
-
-Listed models are built with the operation set version 8 except the GPT-2 model (which uses version 10). Models that are upgraded to higher operation set versions may not be supported.
-
-## Supported PaddlePaddle* Models via ONNX Conversion
-Starting from the R5 release, the OpenVINO™ toolkit officially supports public PaddlePaddle* models via ONNX conversion.
-The list of supported topologies downloadable from PaddleHub is presented below:
-
-| Model Name | Command to download the model from PaddleHub |
-|:----|:----|
-| [MobileNetV2](https://www.paddlepaddle.org.cn/hubdetail?name=mobilenet_v2_imagenet) | `hub install mobilenet_v2_imagenet==1.0.1` |
-| [ResNet18](https://www.paddlepaddle.org.cn/hubdetail?name=resnet_v2_18_imagenet) | `hub install resnet_v2_18_imagenet==1.0.0` |
-| [ResNet34](https://www.paddlepaddle.org.cn/hubdetail?name=resnet_v2_34_imagenet) | `hub install resnet_v2_34_imagenet==1.0.0` |
-| [ResNet50](https://www.paddlepaddle.org.cn/hubdetail?name=resnet_v2_50_imagenet) | `hub install resnet_v2_50_imagenet==1.0.1` |
-| [ResNet101](https://www.paddlepaddle.org.cn/hubdetail?name=resnet_v2_101_imagenet) | `hub install resnet_v2_101_imagenet==1.0.1` |
-| [ResNet152](https://www.paddlepaddle.org.cn/hubdetail?name=resnet_v2_152_imagenet) | `hub install resnet_v2_152_imagenet==1.0.1` |
-> **NOTE**: To convert a model downloaded from PaddleHub use [paddle2onnx](https://github.com/PaddlePaddle/paddle2onnx) converter.
-
-The list of supported topologies from the [models v1.5](https://github.com/PaddlePaddle/models/tree/release/1.5) package:
-* [MobileNetV1](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/mobilenet.py)
-* [MobileNetV2](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/mobilenet_v2.py)
-* [ResNet](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/resnet.py)
-* [ResNet_vc](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/resnet_vc.py)
-* [ResNet_vd](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/resnet_vd.py)
-* [ResNeXt](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/resnext.py)
-* [ResNeXt_vd](https://github.com/PaddlePaddle/models/blob/release/1.5/PaddleCV/image_classification/models/resnext_vd.py)
-
-> **NOTE**: To convert these topologies one should first serialize the model by calling `paddle.fluid.io.save_inference_model`
- ([description](https://www.paddlepaddle.org.cn/documentation/docs/en/1.3/api/io.html#save-inference-model)) command and
-  after that use [paddle2onnx](https://github.com/PaddlePaddle/paddle2onnx) converter.
-
 ## Convert an ONNX* Model <a name="Convert_From_ONNX"></a>
 The Model Optimizer process assumes you have an ONNX model that was directly downloaded from a public repository or converted from any framework that supports exporting to the ONNX format.
 
@@ -81,3 +15,6 @@ There are no ONNX\* specific parameters, so only framework-agnostic parameters a
 
 ## Supported ONNX\* Layers
 Refer to [Supported Framework Layers](../Supported_Frameworks_Layers.md) for the list of supported standard layers.
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_Paddle.md

@@ -7,28 +7,6 @@ A summary of the steps for optimizing and deploying a model trained with PaddleP
 3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in the target environment via provided [OpenVINO Samples](../../../OV_Runtime_UG/Samples_Overview.md).
 4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in your application to deploy the model in the target environment.
 
-## Supported Topologies
-
-| Model Name| Model Type| Description|
-| ------------- | ------------ | ------------- |
-|ppocr-det| optical character recognition| Models are exported from [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.1/). Refer to [READ.md](https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.1/#pp-ocr-20-series-model-listupdate-on-dec-15).|
-|ppocr-rec| optical character recognition| Models are exported from [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.1/). Refer to [READ.md](https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.1/#pp-ocr-20-series-model-listupdate-on-dec-15).|
-|ResNet-50| classification| Models are exported from [PaddleClas](https://github.com/PaddlePaddle/PaddleClas/tree/release/2.1/). Refer to [getting_started_en.md](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.1/docs/en/tutorials/getting_started_en.md#4-use-the-inference-model-to-predict)|
-|MobileNet v2| classification| Models are exported from [PaddleClas](https://github.com/PaddlePaddle/PaddleClas/tree/release/2.1/). Refer to [getting_started_en.md](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.1/docs/en/tutorials/getting_started_en.md#4-use-the-inference-model-to-predict)|
-|MobileNet v3| classification| Models are exported from [PaddleClas](https://github.com/PaddlePaddle/PaddleClas/tree/release/2.1/). Refer to [getting_started_en.md](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.1/docs/en/tutorials/getting_started_en.md#4-use-the-inference-model-to-predict)|
-|BiSeNet v2| semantic segmentation| Models are exported from [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.1). Refer to [model_export.md](https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.1/docs/model_export.md#)|
-|DeepLab v3 plus| semantic segmentation| Models are exported from [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.1). Refer to [model_export.md](https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.1/docs/model_export.md#)|
-|Fast-SCNN| semantic segmentation| Models are exported from [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.1). Refer to [model_export.md](https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.1/docs/model_export.md#)|
-|OCRNET| semantic segmentation| Models are exported from [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.1). Refer to [model_export.md](https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.1/docs/model_export.md#)|
-|Yolo v3| detection| Models are exported from [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.1). Refer to [EXPORT_MODEL.md](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.1/deploy/EXPORT_MODEL.md#).|
-|ppyolo| detection| Models are exported from [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.1). Refer to [EXPORT_MODEL.md](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.1/deploy/EXPORT_MODEL.md#).|
-|MobileNetv3-SSD| detection| Models are exported from [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.2). Refer to [EXPORT_MODEL.md](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.2/deploy/EXPORT_MODEL.md#).|
-|U-Net| semantic segmentation| Models are exported from [PaddleSeg](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.3). Refer to [model_export.md](https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.3/docs/model_export.md#)|
-|BERT| language representation| Models are exported from [PaddleNLP](https://github.com/PaddlePaddle/PaddleNLP/tree/v2.1.1). Refer to [README.md](https://github.com/PaddlePaddle/PaddleNLP/tree/develop/examples/language_model/bert#readme)|
-|ernie| language representation| Models are exported from [PaddleNLP](https://github.com/PaddlePaddle/PaddleNLP/tree/v2.1.1). Refer to [README.md](https://github.com/PaddlePaddle/PaddleNLP/tree/develop/examples/language_model/bert#readme)|
-
-> **NOTE:** The verified models are exported from the repository of branch release/2.1.
-
 ## Convert a PaddlePaddle Model <a name="Convert_From_Paddle"></a>
 
 To convert a PaddlePaddle model:
@@ -56,3 +34,6 @@ Refer to [Supported Framework Layers](../Supported_Frameworks_Layers.md) for the
 ## Frequently Asked Questions (FAQ)
 
 When Model Optimizer is unable to run to completion due to issues like typographical errors, incorrectly used options, etc., it provides explanatory messages. They describe the potential cause of the problem and give a link to the [Model Optimizer FAQ](../Model_Optimizer_FAQ.md), which provides instructions on how to resolve most issues. The FAQ also includes links to relevant sections in the Model Optimizer Developer Guide to help you understand what went wrong.
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_PyTorch.md

@@ -1,49 +1,6 @@
 # Converting a PyTorch* Model {#openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_PyTorch}
 
-@sphinxdirective
+## Typical Steps to Convert PyTorch Model <a name="typical-pytorch"></a>
-
-.. toctree::
-   :maxdepth: 1
-   :hidden:
-
-   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_F3Net
-   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_QuartzNet
-   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RNNT
-   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_YOLACT
-   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_Bert_ner
-   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RCAN
-
-@endsphinxdirective
-
-## Supported Topologies
-
-Here is the list of models that are tested and guaranteed to be supported. However, you can also use these instructions to convert PyTorch\* models that are not presented in the list.
-
-* [Torchvision Models](https://pytorch.org/docs/stable/torchvision/index.html):  alexnet, densenet121, densenet161,
-  densenet169, densenet201, resnet101, resnet152, resnet18, resnet34, resnet50, vgg11, vgg13, vgg16, vgg19.
-  The models can be converted using [regular instructions](#typical-pytorch).
-* [Cadene Pretrained Models](https://github.com/Cadene/pretrained-models.pytorch): alexnet, fbresnet152, resnet101,
-  resnet152, resnet18, resnet34, resnet152, resnet18, resnet34, resnet50, resnext101_32x4d, resnext101_64x4d, vgg11.
-  The models can be converted using [regular instructions](#typical-pytorch).
-* [ESPNet Models](https://github.com/sacmehta/ESPNet/tree/master/pretrained) can be converted using [regular instructions](#typical-pytorch).
-* [MobileNetV3](https://github.com/d-li14/mobilenetv3.pytorch) can be converted using [regular instructions](#typical-pytorch).
-* [iSeeBetter](https://github.com/amanchadha/iSeeBetter) can be converted using [regular instructions](#typical-pytorch).
-  Please refer to [`iSeeBetterTest.py`](https://github.com/amanchadha/iSeeBetter/blob/master/iSeeBetterTest.py) script for code to initialize the model.
-* F3Net topology can be converted using steps described in [Convert PyTorch\* F3Net to the IR](pytorch_specific/Convert_F3Net.md)
-  instruction which is used instead of steps 2 and 3 of [regular instructions](#typical-pytorch).
-* QuartzNet topologies from [NeMo project](https://github.com/NVIDIA/NeMo) can be converted using steps described in
-  [Convert PyTorch\* QuartzNet to the IR](pytorch_specific/Convert_QuartzNet.md) instruction which is used instead of
-  steps 2 and 3 of [regular instructions](#typical-pytorch).
-* YOLACT topology can be converted using steps described in [Convert PyTorch\* YOLACT to the IR](pytorch_specific/Convert_YOLACT.md)
-  instruction which is used instead of steps 2 and 3 of [regular instructions](#typical-pytorch).
-* [RCAN](https://github.com/yulunzhang/RCAN) topology can be converted using steps described in [Convert PyTorch\* RCAN to the IR](pytorch_specific/Convert_RCAN.md)
-  instruction which is used instead of steps 2 and 3 of [regular instructions](#typical-pytorch).
-* [BERT_NER](https://github.com/kamalkraj/BERT-NER) topology can be converted using steps described in [Convert PyTorch* BERT-NER to the IR](pytorch_specific/Convert_Bert_ner.md)
-  instruction which is used instead of steps 2 and 3 of [regular instructions](#typical-pytorch).
-* ResNeXt-101 from [facebookresearch/semi-supervised-ImageNet1K-models](https://github.com/facebookresearch/semi-supervised-ImageNet1K-models)
-  can be converted using [regular instructions](#typical-pytorch).
-
-## Typical steps to convert PyTorch\* model <a name="typical-pytorch"></a>
 
 PyTorch* framework is supported through export to ONNX\* format. A summary of the steps for optimizing and deploying a model that was trained with the PyTorch\* framework:
 
@@ -51,7 +8,7 @@ PyTorch* framework is supported through export to ONNX\* format. A summary of th
 2. [Export PyTorch model to ONNX\*](#export-to-onnx).
 3. [Convert an ONNX\* model](Convert_Model_From_ONNX.md) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values.
 4. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in the target environment via provided [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
-5. [Integrate OpenVINO Runtime](../../../OV_Runtime_UG/Samples_Overview.md) in your application to deploy the model in the target environment.
+5. [Integrate OpenVINO Runtime](../../../OV_Runtime_UG/integrate_with_your_application.md) in your application to deploy the model in the target environment.
 
 ## Export PyTorch\* Model to ONNX\* Format <a name="export-to-onnx"></a>
 
@@ -68,7 +25,7 @@ import torch
 model = SomeModel()
 # Evaluate the model to switch some operations from training mode to inference.
 model.eval()
-# Create dummy input for the model. It will be used to run the model inside export function. 
+# Create dummy input for the model. It will be used to run the model inside export function.
 dummy_input = torch.randn(1, 3, 224, 224)
 # Call the export function
 torch.onnx.export(model, (dummy_input, ), 'model.onnx')
@@ -79,3 +36,6 @@ torch.onnx.export(model, (dummy_input, ), 'model.onnx')
 * Not all PyTorch\* operations can be exported to ONNX\* opset 9 which is used by default, as of version 1.8.1.
 It is recommended to export models to opset 11 or higher when export to default opset 9 is not working. In that case, use `opset_version`
 option of the `torch.onnx.export`. For more information about ONNX* opset, refer to the [Operator Schemas](https://github.com/onnx/onnx/blob/master/docs/Operators.md).
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_From_TensorFlow.md

@@ -1,194 +1,12 @@
 # Converting a TensorFlow* Model {#openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_TensorFlow}
 
-@sphinxdirective
-
-.. _convert model tf:
-
-.. toctree::
-   :maxdepth: 1
-   :hidden:
-   
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_RetinaNet_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_AttentionOCR_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_FaceNet_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_NCF_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_DeepSpeech_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_lm_1b_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Object_Detection_API_Models
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Slim_Library_Models
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_CRNN_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_GNMT_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_BERT_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_XLNet_From_Tensorflow
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_WideAndDeep_Family_Models
-   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_EfficientDet_Models
-
-@endsphinxdirective
-
 A summary of the steps for optimizing and deploying a model that was trained with the TensorFlow\* framework:
 
 1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for TensorFlow\* (TensorFlow was used to train your model).
 2. [Freeze the TensorFlow model](#freeze-the-tensorflow-model) if your model is not already frozen or skip this step and use the [instruction](#loading-nonfrozen-models) to a convert a non-frozen model.
 3. [Convert a TensorFlow\* model](#Convert_From_TF) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values.
 4. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/openvino_intro.md) in the target environment via provided [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
-5. [Integrate OpenVINO Runtime](../../../OV_Runtime_UG/Samples_Overview.md) in your application to deploy the model in the target environment.
+5. [Integrate OpenVINO Runtime](../../../OV_Runtime_UG/integrate_with_your_application.md) in your application to deploy the model in the target environment.
-
-## Supported Topologies
-
-**Supported Non-Frozen Topologies with Links to the Associated Slim Model Classification Download Files**
-
-Detailed information on how to convert models from the <a href="https://github.com/tensorflow/models/tree/master/research/slim/README.md">TensorFlow\*-Slim Image Classification Model Library</a> is available in the [Converting TensorFlow*-Slim Image Classification Model Library Models](tf_specific/Convert_Slim_Library_Models.md) chapter. The table below contains list of supported TensorFlow\*-Slim Image Classification Model Library models and required mean/scale values. The mean values are specified as if the input image is read in BGR channels order layout like OpenVINO classification sample does.
-
-| Model Name| Slim Model Checkpoint File| \-\-mean_values | \-\-scale|
-| ------------- | ------------ | ------------- | -----:|
-|Inception v1| [inception_v1_2016_08_28.tar.gz](http://download.tensorflow.org/models/inception_v1_2016_08_28.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|Inception v2| [inception_v1_2016_08_28.tar.gz](http://download.tensorflow.org/models/inception_v1_2016_08_28.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|Inception v3| [inception_v3_2016_08_28.tar.gz](http://download.tensorflow.org/models/inception_v3_2016_08_28.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|Inception V4| [inception_v4_2016_09_09.tar.gz](http://download.tensorflow.org/models/inception_v4_2016_09_09.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|Inception ResNet v2| [inception_resnet_v2_2016_08_30.tar.gz](http://download.tensorflow.org/models/inception_resnet_v2_2016_08_30.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|MobileNet v1 128| [mobilenet_v1_0.25_128.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_02_22/mobilenet_v1_0.25_128.tgz)| [127.5,127.5,127.5]| 127.5|
-|MobileNet v1 160| [mobilenet_v1_0.5_160.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_02_22/mobilenet_v1_0.5_160.tgz)| [127.5,127.5,127.5]| 127.5|
-|MobileNet v1 224| [mobilenet_v1_1.0_224.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_02_22/mobilenet_v1_1.0_224.tgz)| [127.5,127.5,127.5]| 127.5|
-|NasNet Large| [nasnet-a_large_04_10_2017.tar.gz](https://storage.googleapis.com/download.tensorflow.org/models/nasnet-a_large_04_10_2017.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|NasNet Mobile| [nasnet-a_mobile_04_10_2017.tar.gz](https://storage.googleapis.com/download.tensorflow.org/models/nasnet-a_mobile_04_10_2017.tar.gz)| [127.5,127.5,127.5]| 127.5|
-|ResidualNet-50 v1| [resnet_v1_50_2016_08_28.tar.gz](http://download.tensorflow.org/models/resnet_v1_50_2016_08_28.tar.gz)| [103.94,116.78,123.68] | 1 |
-|ResidualNet-50 v2| [resnet_v2_50_2017_04_14.tar.gz](http://download.tensorflow.org/models/resnet_v2_50_2017_04_14.tar.gz)| [103.94,116.78,123.68] | 1 |
-|ResidualNet-101 v1| [resnet_v1_101_2016_08_28.tar.gz](http://download.tensorflow.org/models/resnet_v1_101_2016_08_28.tar.gz)| [103.94,116.78,123.68] | 1 |
-|ResidualNet-101 v2| [resnet_v2_101_2017_04_14.tar.gz](http://download.tensorflow.org/models/resnet_v2_101_2017_04_14.tar.gz)| [103.94,116.78,123.68] | 1 |
-|ResidualNet-152 v1| [resnet_v1_152_2016_08_28.tar.gz](http://download.tensorflow.org/models/resnet_v1_152_2016_08_28.tar.gz)| [103.94,116.78,123.68] | 1 |
-|ResidualNet-152 v2| [resnet_v2_152_2017_04_14.tar.gz](http://download.tensorflow.org/models/resnet_v2_152_2017_04_14.tar.gz)| [103.94,116.78,123.68] | 1 |
-|VGG-16| [vgg_16_2016_08_28.tar.gz](http://download.tensorflow.org/models/vgg_16_2016_08_28.tar.gz)| [103.94,116.78,123.68] | 1 |
-|VGG-19| [vgg_19_2016_08_28.tar.gz](http://download.tensorflow.org/models/vgg_19_2016_08_28.tar.gz)| [103.94,116.78,123.68] | 1 |
-
-**Supported Pre-Trained Topologies from TensorFlow 1 Detection Model Zoo**
-
-Detailed information on how to convert models from the <a href="https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf1_detection_zoo.md">TensorFlow 1 Detection Model Zoo</a> is available in the [Converting TensorFlow Object Detection API Models](tf_specific/Convert_Object_Detection_API_Models.md) chapter. The table below contains models from the Object Detection Models zoo that are supported.
-
-| Model Name| TensorFlow 1 Object Detection API Models|
-| :------------- | -----:|
-|SSD MobileNet V1 COCO\*| [ssd_mobilenet_v1_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_coco_2018_01_28.tar.gz)|
-|SSD MobileNet V1 0.75 Depth COCO|  [ssd_mobilenet_v1_0.75_depth_300x300_coco14_sync_2018_07_03.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_0.75_depth_300x300_coco14_sync_2018_07_03.tar.gz)|
-|SSD MobileNet V1 PPN COCO|  [ssd_mobilenet_v1_ppn_shared_box_predictor_300x300_coco14_sync_2018_07_03.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_ppn_shared_box_predictor_300x300_coco14_sync_2018_07_03.tar.gz)|
-|SSD MobileNet V1 FPN COCO|  [ssd_mobilenet_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03.tar.gz)|
-|SSD ResNet50 FPN COCO|  [ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03.tar.gz)|
-|SSD MobileNet V2 COCO|  [ssd_mobilenet_v2_coco_2018_03_29.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v2_coco_2018_03_29.tar.gz)|
-|SSD Lite MobileNet V2 COCO|  [ssdlite_mobilenet_v2_coco_2018_05_09.tar.gz](http://download.tensorflow.org/models/object_detection/ssdlite_mobilenet_v2_coco_2018_05_09.tar.gz)|
-|SSD Inception V2 COCO|	[ssd_inception_v2_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/ssd_inception_v2_coco_2018_01_28.tar.gz)|
-|RFCN ResNet 101 COCO|  [rfcn_resnet101_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/rfcn_resnet101_coco_2018_01_28.tar.gz)|
-|Faster R-CNN Inception V2 COCO|  [faster_rcnn_inception_v2_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_v2_coco_2018_01_28.tar.gz)|
-|Faster R-CNN ResNet 50 COCO|  [faster_rcnn_resnet50_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_resnet50_coco_2018_01_28.tar.gz)|
-|Faster R-CNN ResNet 50 Low Proposals COCO|  [faster_rcnn_resnet50_lowproposals_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_resnet50_lowproposals_coco_2018_01_28.tar.gz)|
-|Faster R-CNN ResNet 101 COCO|  [faster_rcnn_resnet101_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_resnet101_coco_2018_01_28.tar.gz)|
-|Faster R-CNN ResNet 101 Low Proposals COCO|  [faster_rcnn_resnet101_lowproposals_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_resnet101_lowproposals_coco_2018_01_28.tar.gz)|
-|Faster R-CNN Inception ResNet V2 COCO|  [faster_rcnn_inception_resnet_v2_atrous_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_resnet_v2_atrous_coco_2018_01_28.tar.gz)|
-|Faster R-CNN Inception ResNet V2 Low Proposals COCO|  [faster_rcnn_inception_resnet_v2_atrous_lowproposals_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_resnet_v2_atrous_lowproposals_coco_2018_01_28.tar.gz)|
-|Faster R-CNN NasNet COCO|  [faster_rcnn_nas_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_nas_coco_2018_01_28.tar.gz)|
-|Faster R-CNN NasNet Low Proposals COCO|  [faster_rcnn_nas_lowproposals_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_nas_lowproposals_coco_2018_01_28.tar.gz)|
-|Mask R-CNN Inception ResNet V2 COCO|  [mask_rcnn_inception_resnet_v2_atrous_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/mask_rcnn_inception_resnet_v2_atrous_coco_2018_01_28.tar.gz)|
-|Mask R-CNN Inception V2 COCO|  [mask_rcnn_inception_v2_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/mask_rcnn_inception_v2_coco_2018_01_28.tar.gz)|
-|Mask R-CNN ResNet 101 COCO|  [mask_rcnn_resnet101_atrous_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/mask_rcnn_resnet101_atrous_coco_2018_01_28.tar.gz)|
-|Mask R-CNN ResNet 50 COCO|  [mask_rcnn_resnet50_atrous_coco_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/mask_rcnn_resnet50_atrous_coco_2018_01_28.tar.gz)|
-|Faster R-CNN ResNet 101 Kitti\*|  [faster_rcnn_resnet101_kitti_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_resnet101_kitti_2018_01_28.tar.gz)|
-|Faster R-CNN Inception ResNet V2 Open Images\*|  [faster_rcnn_inception_resnet_v2_atrous_oid_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_resnet_v2_atrous_oid_2018_01_28.tar.gz)|
-|Faster R-CNN Inception ResNet V2 Low Proposals Open Images\*|  [faster_rcnn_inception_resnet_v2_atrous_lowproposals_oid_2018_01_28.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_inception_resnet_v2_atrous_lowproposals_oid_2018_01_28.tar.gz)|
-|Faster R-CNN ResNet 101 AVA v2.1\*|  [faster_rcnn_resnet101_ava_v2.1_2018_04_30.tar.gz](http://download.tensorflow.org/models/object_detection/faster_rcnn_resnet101_ava_v2.1_2018_04_30.tar.gz)|
-
-**Supported Pre-Trained Topologies from TensorFlow 2 Detection Model Zoo**
-
-Detailed information on how to convert models from the <a href="https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf2_detection_zoo.md">TensorFlow 2 Detection Model Zoo</a> is available in the [Converting TensorFlow Object Detection API Models](tf_specific/Convert_Object_Detection_API_Models.md) chapter. The table below contains models from the Object Detection Models zoo that are supported.
-
-| Model Name| TensorFlow 2 Object Detection API Models|
-| :------------- | -----:|
-| EfficientDet D0 512x512 |  [efficientdet_d0_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d0_coco17_tpu-32.tar.gz)|
-| EfficientDet D1 640x640 |  [efficientdet_d1_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d1_coco17_tpu-32.tar.gz)|
-| EfficientDet D2 768x768 |  [efficientdet_d2_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d2_coco17_tpu-32.tar.gz)|
-| EfficientDet D3 896x896 |  [efficientdet_d3_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d3_coco17_tpu-32.tar.gz)|
-| EfficientDet D4 1024x1024 |  [efficientdet_d4_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d4_coco17_tpu-32.tar.gz)|
-| EfficientDet D5 1280x1280 |  [efficientdet_d5_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d5_coco17_tpu-32.tar.gz)|
-| EfficientDet D6 1280x1280 |  [efficientdet_d6_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d6_coco17_tpu-32.tar.gz)|
-| EfficientDet D7 1536x1536 |  [efficientdet_d7_coco17_tpu-32.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d7_coco17_tpu-32.tar.gz)|
-| SSD MobileNet v2 320x320 |  [ssd_mobilenet_v2_320x320_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_320x320_coco17_tpu-8.tar.gz)|
-| SSD MobileNet V1 FPN 640x640 |  [ssd_mobilenet_v1_fpn_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v1_fpn_640x640_coco17_tpu-8.tar.gz)|
-| SSD MobileNet V2 FPNLite 320x320 |  [ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz)|
-| SSD MobileNet V2 FPNLite 640x640 |  [ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_640x640_coco17_tpu-8.tar.gz)|
-| SSD ResNet50 V1 FPN 640x640 (RetinaNet50) |  [ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz)|
-| SSD ResNet50 V1 FPN 1024x1024 (RetinaNet50) |  [ssd_resnet50_v1_fpn_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_1024x1024_coco17_tpu-8.tar.gz)|
-| SSD ResNet101 V1 FPN 640x640 (RetinaNet101) |  [ssd_resnet101_v1_fpn_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_640x640_coco17_tpu-8.tar.gz)|
-| SSD ResNet101 V1 FPN 1024x1024 (RetinaNet101) |  [ssd_resnet101_v1_fpn_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet101_v1_fpn_1024x1024_coco17_tpu-8.tar.gz)|
-| SSD ResNet152 V1 FPN 640x640 (RetinaNet152) |  [ssd_resnet152_v1_fpn_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_640x640_coco17_tpu-8.tar.gz)|
-| SSD ResNet152 V1 FPN 1024x1024 (RetinaNet152) |  [ssd_resnet152_v1_fpn_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet152_v1_fpn_1024x1024_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet50 V1 640x640 |  [faster_rcnn_resnet50_v1_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet50_v1_640x640_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet50 V1 1024x1024 |  [faster_rcnn_resnet50_v1_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet50_v1_1024x1024_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet50 V1 800x1333 |  [faster_rcnn_resnet50_v1_800x1333_coco17_gpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet50_v1_800x1333_coco17_gpu-8.tar.gz)|
-| Faster R-CNN ResNet101 V1 640x640 |  [faster_rcnn_resnet101_v1_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet101_v1_640x640_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet101 V1 1024x1024 |  [faster_rcnn_resnet101_v1_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet101_v1_1024x1024_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet101 V1 800x1333 |  [faster_rcnn_resnet101_v1_800x1333_coco17_gpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet101_v1_800x1333_coco17_gpu-8.tar.gz)|
-| Faster R-CNN ResNet152 V1 640x640 |  [faster_rcnn_resnet152_v1_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet152_v1_640x640_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet152 V1 1024x1024 |  [faster_rcnn_resnet152_v1_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet152_v1_1024x1024_coco17_tpu-8.tar.gz)|
-| Faster R-CNN ResNet152 V1 800x1333 |  [faster_rcnn_resnet152_v1_800x1333_coco17_gpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_resnet152_v1_800x1333_coco17_gpu-8.tar.gz)|
-| Faster R-CNN Inception ResNet V2 640x640 |  [faster_rcnn_inception_resnet_v2_640x640_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_inception_resnet_v2_640x640_coco17_tpu-8.tar.gz)|
-| Faster R-CNN Inception ResNet V2 1024x1024 |  [faster_rcnn_inception_resnet_v2_1024x1024_coco17_tpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/faster_rcnn_inception_resnet_v2_1024x1024_coco17_tpu-8.tar.gz)|
-| Mask R-CNN Inception ResNet V2 1024x1024 |  [mask_rcnn_inception_resnet_v2_1024x1024_coco17_gpu-8.tar.gz](http://download.tensorflow.org/models/object_detection/tf2/20200711/mask_rcnn_inception_resnet_v2_1024x1024_coco17_gpu-8.tar.gz)|
-
-**Supported Frozen Quantized Topologies**
-
-The topologies hosted on the TensorFlow\* Lite [site](https://www.tensorflow.org/lite/guide/hosted_models). The frozen model file (`.pb` file) should be fed to the Model Optimizer.
-
-| Model Name            |                                                                                                                Frozen Model File |
-|:----------------------|---------------------------------------------------------------------------------------------------------------------------------:|
-| Mobilenet V1 0.25 128 | [mobilenet_v1_0.25_128_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.25_128_quant.tgz) |
-| Mobilenet V1 0.25 160 | [mobilenet_v1_0.25_160_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.25_160_quant.tgz) |
-| Mobilenet V1 0.25 192 | [mobilenet_v1_0.25_192_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.25_192_quant.tgz) |
-| Mobilenet V1 0.25 224 | [mobilenet_v1_0.25_224_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.25_224_quant.tgz) |
-| Mobilenet V1 0.50 128 |   [mobilenet_v1_0.5_128_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.5_128_quant.tgz) |
-| Mobilenet V1 0.50 160 |   [mobilenet_v1_0.5_160_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.5_160_quant.tgz) |
-| Mobilenet V1 0.50 192 |   [mobilenet_v1_0.5_192_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.5_192_quant.tgz) |
-| Mobilenet V1 0.50 224 |   [mobilenet_v1_0.5_224_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.5_224_quant.tgz) |
-| Mobilenet V1 0.75 128 | [mobilenet_v1_0.75_128_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.75_128_quant.tgz) |
-| Mobilenet V1 0.75 160 | [mobilenet_v1_0.75_160_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.75_160_quant.tgz) |
-| Mobilenet V1 0.75 192 | [mobilenet_v1_0.75_192_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.75_192_quant.tgz) |
-| Mobilenet V1 0.75 224 | [mobilenet_v1_0.75_224_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_0.75_224_quant.tgz) |
-| Mobilenet V1 1.0 128  |   [mobilenet_v1_1.0_128_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_128_quant.tgz) |
-| Mobilenet V1 1.0 160  |   [mobilenet_v1_1.0_160_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_160_quant.tgz) |
-| Mobilenet V1 1.0 192  |   [mobilenet_v1_1.0_192_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_192_quant.tgz) |
-| Mobilenet V1 1.0 224  |   [mobilenet_v1_1.0_224_quant.tgz](http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_224_quant.tgz) |
-| Mobilenet V2 1.0 224  |           [mobilenet_v2_1.0_224_quant.tgz](http://download.tensorflow.org/models/tflite_11_05_08/mobilenet_v2_1.0_224_quant.tgz) |
-| Inception V1          |                 [inception_v1_224_quant_20181026.tgz](http://download.tensorflow.org/models/inception_v1_224_quant_20181026.tgz) |
-| Inception V2          |                 [inception_v2_224_quant_20181026.tgz](http://download.tensorflow.org/models/inception_v2_224_quant_20181026.tgz) |
-| Inception V3          |                           [inception_v3_quant.tgz](http://download.tensorflow.org/models/tflite_11_05_08/inception_v3_quant.tgz) |
-| Inception V4          |                 [inception_v4_299_quant_20181026.tgz](http://download.tensorflow.org/models/inception_v4_299_quant_20181026.tgz) |
-
-It is necessary to specify the following command line parameters for the Model Optimizer to convert some of the models from the list above: `--input input --input_shape [1,HEIGHT,WIDTH,3]`.
-Where `HEIGHT` and `WIDTH` are the input images height and width for which the model was trained.
-
-**Other supported topologies**
-
-| Model Name| Repository |
-| :------------- | -----:|
-| ResNext | [Repo](https://github.com/taki0112/ResNeXt-Tensorflow)|
-| DenseNet | [Repo](https://github.com/taki0112/Densenet-Tensorflow)|
-| CRNN | [Repo](https://github.com/MaybeShewill-CV/CRNN_Tensorflow) |
-| NCF | [Repo](https://github.com/tensorflow/models/tree/master/official/recommendation) |
-| lm_1b | [Repo](https://github.com/tensorflow/models/tree/master/research/lm_1b) |
-| DeepSpeech | [Repo](https://github.com/mozilla/DeepSpeech) |
-| A3C | [Repo](https://github.com/miyosuda/async_deep_reinforce) |
-| VDCNN | [Repo](https://github.com/WenchenLi/VDCNN) |
-| Unet | [Repo](https://github.com/kkweon/UNet-in-Tensorflow) |
-| Keras-TCN | [Repo](https://github.com/philipperemy/keras-tcn) |
-| PRNet | [Repo](https://github.com/YadiraF/PRNet) |
-| YOLOv4 | [Repo](https://github.com/Ma-Dan/keras-yolo4) |
-| STN | [Repo](https://github.com/oarriaga/STN.keras) |
-
-* YOLO topologies from DarkNet* can be converted using [these instructions](tf_specific/Convert_YOLO_From_Tensorflow.md).
-* FaceNet topologies can be converted using [these instructions](tf_specific/Convert_FaceNet_From_Tensorflow.md).
-* CRNN topologies can be converted using [these instructions](tf_specific/Convert_CRNN_From_Tensorflow.md).
-* NCF topologies can be converted using [these instructions](tf_specific/Convert_NCF_From_Tensorflow.md).
-* [GNMT](https://github.com/tensorflow/nmt) topology can be converted using [these instructions](tf_specific/Convert_GNMT_From_Tensorflow.md).
-* [BERT](https://github.com/google-research/bert) topology can be converted using [these instructions](tf_specific/Convert_BERT_From_Tensorflow.md).
-* [XLNet](https://github.com/zihangdai/xlnet) topology can be converted using [these instructions](tf_specific/Convert_XLNet_From_Tensorflow.md).
-* [Attention OCR](https://github.com/emedvedev/attention-ocr) topology can be converted using [these instructions](tf_specific/Convert_AttentionOCR_From_Tensorflow.md).
-  
 
 ## Loading Non-Frozen Models to the Model Optimizer <a name="loading-nonfrozen-models"></a>
 
@@ -339,16 +157,6 @@ TensorFlow*-specific parameters:
  mo --input_model inception_v1.pbtxt --input_model_is_text -b 1 --output_dir <OUTPUT_MODEL_DIR>
 ```
 
-* Launching the Model Optimizer for Inception V1 frozen model and update custom sub-graph replacement file `transform.json` with information about input and output nodes of the matched sub-graph, specifying a writable output directory. For more information about this feature, refer to [Sub-Graph Replacement in the Model Optimizer](../customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md).
-```sh
- mo --input_model inception_v1.pb -b 1 --tensorflow_custom_operations_config_update transform.json --output_dir <OUTPUT_MODEL_DIR>
-```
-
-* Launching the Model Optimizer for Inception V1 frozen model and use custom sub-graph replacement file `transform.json` for model conversion. For more information about this feature, refer to [Sub-Graph Replacement in the Model Optimizer](../customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md).
-```sh
- mo --input_model inception_v1.pb -b 1 --transformations_config transform.json --output_dir <OUTPUT_MODEL_DIR>
-```
-
 * Launching the Model Optimizer for Inception V1 frozen model and dump information about the graph to TensorBoard log dir `/tmp/log_dir`
 ```sh
  mo --input_model inception_v1.pb -b 1 --tensorboard_logdir /tmp/log_dir --output_dir <OUTPUT_MODEL_DIR>
@@ -363,12 +171,12 @@ TensorFlow*-specific parameters:
 ## Convert TensorFlow* 2 Models <a name="Convert_From_TF2X"></a>
 
 In order to convert TensorFlow* 2 models, installation of dependencies from `requirements_tf.txt` is required.
-TensorFlow* 2.X officially supports two model formats: SavedModel and Keras H5 (or HDF5).    
+TensorFlow* 2.X officially supports two model formats: SavedModel and Keras H5 (or HDF5).
 Below are the instructions on how to convert each of them.
 
-### SavedModel Format     
+### SavedModel Format
 
-A model in the SavedModel format consists of a directory with a `saved_model.pb` file and two subfolders: `variables` and `assets`. 
+A model in the SavedModel format consists of a directory with a `saved_model.pb` file and two subfolders: `variables` and `assets`.
 To convert such a model:
 1. Go to the `<INSTALL_DIR>/tools/model_optimizer` directory.
 2. Run the `mo` script with a path to the SavedModel directory and a writable output directory:
@@ -377,19 +185,19 @@ To convert such a model:
 ```
 
 TensorFlow* 2 SavedModel format strictly requires the 2.x version of TensorFlow installed in the
-environment for conversion to the Intermediate Representation (IR). 
+environment for conversion to the Intermediate Representation (IR).
 
 If a model contains operations currently unsupported by OpenVINO™,
 prune these operations by explicit specification of input nodes using the `--input` or `--output`
-options. To determine custom input nodes, visualize a model graph in the TensorBoard.   
+options. To determine custom input nodes, visualize a model graph in the TensorBoard.
 
 To generate TensorBoard logs of the graph, use the Model Optimizer `--tensorboard_logs` command-line
-option.      
+option.
 
 TensorFlow* 2 SavedModel format has a specific graph structure due to eager execution. In case of
 pruning, find custom input nodes in the `StatefulPartitionedCall/*` subgraph.
 
-### Keras H5        
+### Keras H5
 
 If you have a model in the HDF5 format, load the model using TensorFlow* 2 and serialize it in the
 SavedModel format. Here is an example of how to do it:
@@ -451,3 +259,6 @@ In this document, you learned:
 * Which TensorFlow models are supported
 * How to freeze a TensorFlow model
 * How to convert a trained TensorFlow model using the Model Optimizer with both framework-agnostic and TensorFlow-specific command-line options
+
+## See Also
+[Model Conversion Tutorials](Convert_Model_Tutorials.md)

docs/MO_DG/prepare_model/convert_model/Convert_Model_Tutorials.md

@@ -0,0 +1,41 @@
+# Model Conversion Tutorials {#openvino_docs_MO_DG_prepare_model_convert_model_tutorials}
+
+@sphinxdirective
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_AttentionOCR_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_BERT_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_CRNN_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_DeepSpeech_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_EfficientDet_Models
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_FaceNet_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_GNMT_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_lm_1b_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_NCF_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Object_Detection_API_Models
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_RetinaNet_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Slim_Library_Models
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_WideAndDeep_Family_Models
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_XLNet_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow
+   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Faster_RCNN
+   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_GPT2
+   openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Mask_RCNN
+   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_Bert_ner
+   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_F3Net
+   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_QuartzNet
+   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RCAN
+   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RNNT
+   openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_YOLACT
+   openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_GluonCV_Models
+   openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_Style_Transfer_From_MXNet
+   openvino_docs_MO_DG_prepare_model_convert_model_kaldi_specific_Aspire_Tdnn_Model
+
+@endsphinxdirective
+
+This section provides you with a set of tutorials that demonstrate conversion steps for specific TensorFlow, ONNX, PyTorch, MXNet and Kaldi models.
+
+You can also find a collection of [Python tutorials](../../../tutorials.md) written for running on Jupyter* notebooks that provide an introduction to the OpenVINO™ toolkit and explain how to use the Python API and tools for optimized deep learning inference.

docs/MO_DG/prepare_model/convert_model/Converting_Model.md

@@ -1,296 +1,32 @@
-# Converting a Model to Intermediate Representation (IR)  {#openvino_docs_MO_DG_prepare_model_convert_model_Converting_Model}
+# General Conversion Parameters {#openvino_docs_MO_DG_prepare_model_convert_model_Converting_Model}
 
-@sphinxdirective
+To get the full list of general (framework-agnostic) conversion parameters available in Model Optimizer, run the following command:
-
-.. toctree::
-   :maxdepth: 1
-   :hidden:
-
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_TensorFlow
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Caffe
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_MxNet
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Kaldi
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_ONNX
-   openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Paddle
-   openvino_docs_MO_DG_prepare_model_Model_Optimization_Techniques
-   openvino_docs_MO_DG_prepare_model_convert_model_Cutting_Model
-   openvino_docs_MO_DG_prepare_model_Supported_Frameworks_Layers
-   openvino_docs_MO_DG_prepare_model_convert_model_IR_suitable_for_INT8_inference
-   openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Subgraph_Replacement_Model_Optimizer
-   openvino_docs_MO_DG_prepare_model_convert_model_Legacy_IR_Layers_Catalog_Spec
-
-@endsphinxdirective
-
-To convert the model to the Intermediate Representation (IR), run Model Optimizer using the following command:
 
 ```sh
-mo --input_model INPUT_MODEL
+mo --help
 ```
 
-The output directory must have write permissions, so you can run Model Optimizer from the output directory or specify an output path with the `--output_dir` option.
+Paragraphs below provide useful details on relevant parameters.
 
-> **NOTE**: The color channel order (RGB or BGR) of an input data should match the channel order of the model training dataset. If they are different, perform the `RGB<->BGR` conversion specifying the command-line parameter: `--reverse_input_channels`. Otherwise, inference results may be incorrect. For details, refer to [When to Reverse Input Channels](#when_to_reverse_input_channels).
+## When to Specify --input_shape Command Line Parameter <a name="when_to_specify_input_shapes"></a>
-
-To adjust the conversion process, you may use general parameters defined in the [General Conversion Parameters](#general_conversion_parameters) and 
-Framework-specific parameters for:
-* [Caffe](Convert_Model_From_Caffe.md)
-* [TensorFlow](Convert_Model_From_TensorFlow.md)
-* [MXNet](Convert_Model_From_MxNet.md)
-* [ONNX](Convert_Model_From_ONNX.md)
-* [PaddlePaddle](Convert_Model_From_Paddle.md)
-* [Kaldi](Convert_Model_From_Kaldi.md)
-
-
-## General Conversion Parameters
-
-To adjust the conversion process, you can also use the general (framework-agnostic) parameters:
-
-```sh
-optional arguments:
-  -h, --help            show this help message and exit
-  --framework {tf,caffe,mxnet,kaldi,onnx}
-                        Name of the framework used to train the input model.
-
-Framework-agnostic parameters:
-  --input_model INPUT_MODEL, -w INPUT_MODEL, -m INPUT_MODEL
-                        Tensorflow*: a file with a pre-trained model (binary
-                        or text .pb file after freezing). Caffe*: a model
-                        proto file with model weights
-  --model_name MODEL_NAME, -n MODEL_NAME
-                        Model_name parameter passed to the final create_ir
-                        transform. This parameter is used to name a network in
-                        a generated IR and output .xml/.bin files.
-  --output_dir OUTPUT_DIR, -o OUTPUT_DIR
-                        Directory that stores the generated IR. By default, it
-                        is the directory from where the Model Optimizer is
-                        launched.
-  --input_shape INPUT_SHAPE
-                        Input shape(s) that should be fed to an input node(s)
-                        of the model. Shape is defined as a comma-separated
-                        list of integer numbers enclosed in parentheses or
-                        square brackets, for example [1,3,227,227] or
-                        (1,227,227,3), where the order of dimensions depends
-                        on the framework input layout of the model. For
-                        example, [N,C,H,W] is used for ONNX* models and
-                        [N,H,W,C] for TensorFlow* models. The shape can contain 
-                        undefined dimensions (? or -1) and should fit the dimensions
-                        defined in the input operation of the graph. Boundaries 
-                        of undefined dimension can be specified with ellipsis, 
-                        for example [1,1..10,128,128]. One boundary can be undefined, 
-                        for example [1,..100] or [1,3,1..,1..]. If there
-                        are multiple inputs in the model, --input_shape should
-                        contain definition of shape for each input separated
-                        by a comma, for example: [1,3,227,227],[2,4] for a
-                        model with two inputs with 4D and 2D shapes.
-                        Alternatively, specify shapes with the --input
-                        option.
-  --scale SCALE, -s SCALE
-                        All input values coming from original network inputs
-                        will be divided by this value. When a list of inputs
-                        is overridden by the --input parameter, this scale is
-                        not applied for any input that does not match with the
-                        original input of the model.
-                        If both --mean and --scale are specified,
-                        the mean is subtracted first and then scale is applied
-                        regardless of the order of options in command line.
-  --reverse_input_channels
-                        Switch the input channels order from RGB to BGR (or
-                        vice versa). Applied to original inputs of the model
-                        if and only if a number of channels equals 3.
-                        When --mean_values/--scale_values are also specified,
-                        reversing of channels will be applied to user's input
-                        data first, so that numbers in --mean_values and
-                        --scale_values go in the order of channels used in
-                        the original model. In other words, if both options are
-                        specified then the data flow in the model looks as following:
-                        Parameter -> ReverseInputChannels -> Mean/Scale apply -> the original body of the model.                        
-  --log_level {CRITICAL,ERROR,WARN,WARNING,INFO,DEBUG,NOTSET}
-                        Logger level
-  --input INPUT         Quoted list of comma-separated input nodes names with shapes, 
-                        data types, and values for freezing. The order of inputs in converted 
-                        model is the same as order of specified operation names. The shape and value are 
-                        specified as space-separated lists. The data type of input 
-                        node is specified in braces and can have one of the values: 
-                        f64 (float64), f32 (float32), f16 (float16), i64 (int64), 
-                        i32 (int32), u8 (uint8), boolean (bool). Data type is optional. 
-                        If it's not specified explicitly then there are two options: 
-                        if input node is a parameter, data type is taken from the 
-                        original node dtype, if input node is not a parameter, data type 
-                        is set to f32. Example, to set `input_1` with shape [1 100], 
-                        and Parameter node `sequence_len` with scalar input with value `150`, 
-                        and boolean input `is_training` with `False` value use the 
-                        following format: "input_1[1 10],sequence_len->150,is_training->False". 
-                        Another example, use the following format to set input port 0 
-                        of the node `node_name1` with the shape [3 4] as an input node 
-                        and freeze output port 1 of the node `node_name2` with the 
-                        value [20 15] of the int32 type and shape [2]: 
-                        "0:node_name1[3 4],node_name2:1[2]{i32}->[20 15]".
-  --output OUTPUT       The name of the output operation of the model. For
-                        TensorFlow*, do not add :0 to this name.
-                        The order of outputs in converted model is the same as order of
-                        specified operation names.
-  --mean_values MEAN_VALUES, -ms MEAN_VALUES
-                        Mean values to be used for the input image per
-                        channel. Values to be provided in the (R,G,B) or
-                        [R,G,B] format. Can be defined for desired input of
-                        the model, for example: "--mean_values
-                        data[255,255,255],info[255,255,255]". The exact
-                        meaning and order of channels depend on how the
-                        original model was trained.
-  --scale_values SCALE_VALUES
-                        Scale values to be used for the input image per
-                        channel. Values are provided in the (R,G,B) or [R,G,B]
-                        format. Can be defined for desired input of the model,
-                        for example: "--scale_values
-                        data[255,255,255],info[255,255,255]". The exact
-                        meaning and order of channels depend on how the
-                        original model was trained.
-                        If both --mean_values and --scale_values are specified,
-                        the mean is subtracted first and then scale is applied
-                        regardless of the order of options in command line.
-  --data_type {FP16,FP32,half,float}
-                        Data type for all intermediate tensors and weights. If
-                        original model is in FP32 and --data_type=FP16 is
-                        specified, all model weights and biases are compressed
-                        to FP16.
-  --disable_fusing      [DEPRECATED] Turn off fusing of linear operations to Convolution.
-  --disable_resnet_optimization
-                        [DEPRECATED] Turn off ResNet optimization.
-  --finegrain_fusing FINEGRAIN_FUSING
-                        [DEPRECATED] Regex for layers/operations that won't be fused.
-                        Example: --finegrain_fusing Convolution1,.*Scale.*
-  --enable_concat_optimization
-                        Turn on Concat optimization.
-  --extensions EXTENSIONS
-                        Directory or a comma separated list of directories
-                        with extensions. To disable all extensions including
-                        those that are placed at the default location, pass an
-                        empty string.
-  --batch BATCH, -b BATCH
-                        Input batch size
-  --version             Version of Model Optimizer
-  --silent              Prevent any output messages except those that
-                        correspond to log level equals ERROR, that can be set
-                        with the following option: --log_level. By default,
-                        log level is already ERROR.
-  --freeze_placeholder_with_value FREEZE_PLACEHOLDER_WITH_VALUE
-                        Replaces input layer with constant node with provided
-                        value, for example: "node_name->True". It will be
-                        DEPRECATED in future releases. Use --input option to
-                        specify a value for freezing.
-  --static_shape        Enables IR generation for fixed input shape (folding
-                        `ShapeOf` operations and shape-calculating sub-graphs
-                        to `Constant`). Changing model input shape using
-                        the OpenVINO Runtime API in runtime may fail for such an IR.
-  --disable_weights_compression
-                        [DEPRECATED] Disable compression and store weights with original
-                        precision.
-  --progress            Enable model conversion progress display.
-  --stream_output       Switch model conversion progress display to a
-                        multiline mode.
-  --transformations_config TRANSFORMATIONS_CONFIG
-                        Use the configuration file with transformations
-                        description.
-  --use_new_frontend    Force the usage of new Frontend of Model Optimizer for model conversion into IR.
-                        The new Frontend is C++ based and is available for ONNX* and PaddlePaddle* models.
-                        Model optimizer uses new Frontend for ONNX* and PaddlePaddle* by default that means
-                        `--use_new_frontend` and `--use_legacy_frontend` options are not specified.
-  --use_legacy_frontend Force the usage of legacy Frontend of Model Optimizer for model conversion into IR.
-                        The legacy Frontend is Python based and is available for TensorFlow*, ONNX*, MXNet*,
-                        Caffe*, and Kaldi* models.
-```
-
-The sections below provide details on using particular parameters and examples of CLI commands.
-
-## When to Specify Mean and Scale Values
-Usually neural network models are trained with the normalized input data. This means that the input data values are converted to be in a specific range, for example, `[0, 1]` or `[-1, 1]`. Sometimes the mean values (mean images) are subtracted from the input data values as part of the pre-processing. There are two cases how the input data pre-processing is implemented.
- * The input pre-processing operations are a part of a topology. In this case, the application that uses the framework to infer the topology does not pre-process the input.
- * The input pre-processing operations are not a part of a topology and the pre-processing is performed within the application which feeds the model with an input data.
- 
-In the first case, the Model Optimizer generates the IR with required pre-processing operations and OpenVINO Samples may be used to infer the model. 
- 
-In the second case, information about mean/scale values should be provided to the Model Optimizer to embed it to the generated IR. Model Optimizer provides a number of command line parameters to specify them: `--mean`, `--scale`, `--scale_values`, `--mean_values`. 
-
-> **NOTE:** If both mean and scale values are specified, the mean is subtracted first and then scale is applied regardless of the order of options in command line. Input values are *divided* by the scale value(s). If also `--reverse_input_channels` option is used, the reverse_input_channels will be applied first, then mean and after that scale.
-
-There is no a universal recipe for determining the mean/scale values for a particular model. The steps below could help to determine them:
-* Read the model documentation. Usually the documentation describes mean/scale value if the pre-processing is required.
-* Open the example script/application executing the model and track how the input data is read and passed to the framework.
-* Open the model in a visualization tool and check for layers performing subtraction or multiplication (like `Sub`, `Mul`, `ScaleShift`, `Eltwise` etc) of the input data. If such layers exist, pre-processing is probably part of the model.
-
-## When to Specify Input Shapes <a name="when_to_specify_input_shapes"></a>
 There are situations when Model Optimizer is unable to deduce input shapes of the model, for example, in case of model cutting due to unsupported operations.
 The solution is to provide input shapes of a static rank explicitly.
 
-## When to Reverse Input Channels <a name="when_to_reverse_input_channels"></a>
+## When to Specify --static_shape Command Line Parameter
-Input data for your application can be of RGB or BRG color input order. For example, OpenVINO Samples load input images in the BGR channels order. However, the model may be trained on images loaded with the opposite order (for example, most TensorFlow\* models are trained with images in RGB order). In this case, inference results using the OpenVINO samples may be incorrect. The solution is to provide `--reverse_input_channels` command line parameter. Taking this parameter, the Model Optimizer performs first convolution or other channel dependent operation weights modification so these operations output will be like the image is passed with RGB channels order.
-
-## When to Specify `--static_shape` Command Line Parameter
 If the `--static_shape` command line parameter is specified the Model Optimizer evaluates shapes of all operations in the model (shape propagation) for a fixed input(s) shape(s). During the shape propagation the Model Optimizer evaluates operations *Shape* and removes them from the computation graph. With that approach, the initial model which can consume inputs of different shapes may be converted to IR working with the input of one fixed shape only. For example, consider the case when some blob is reshaped from 4D of a shape *[N, C, H, W]* to a shape *[N, C, H \* W]*. During the model conversion the Model Optimize calculates output shape as a constant 1D blob with values *[N, C, H \* W]*. So if the input shape changes to some other value *[N,C,H1,W1]* (it is possible scenario for a fully convolutional model) then the reshape layer becomes invalid.
 Resulting Intermediate Representation will not be resizable with the help of OpenVINO Runtime API.
 
-## Examples of CLI Commands
+## Parameters for Pre-Processing
-
+Input data may require pre-processing such as `RGB<->BGR` conversion and mean and scale normalization. To learn about Model Optimizer parameters used for pre-processing, refer to [Optimize Preprocessing Computation](../Additional_Optimizations.md).
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with debug log level:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --log_level DEBUG
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with the output IR called `result.*` in the specified `output_dir`:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --model_name result --output_dir <OUTPUT_MODEL_DIR>
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with one input with scale values:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --scale_values [59,59,59]
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with multiple inputs with scale values:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --input data,rois --scale_values [59,59,59],[5,5,5]
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with multiple inputs with scale and mean values specified for the particular nodes:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --input data,rois --mean_values data[59,59,59] --scale_values rois[5,5,5]
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with specified input layer, overridden input shape, scale 5, batch 8 and specified name of an output operation:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --input data --output pool5 -s 5 -b 8
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with reversed input channels order between RGB and BGR, specified mean values to be used for the input image per channel and specified data type for input tensor values:
-```sh
-mo --input_model bvlc_alexnet.caffemodel --reverse_input_channels --mean_values [255,255,255] --data_type FP16
-```
-
-Launch the Model Optimizer for the Caffe bvlc_alexnet model with extensions listed in specified directories, specified mean_images binaryproto 
- file. For more information about extensions, please refer to the [OpenVINO™ Extensibility Mechanism](../../../Extensibility_UG/Intro.md).
-```sh
-mo --input_model bvlc_alexnet.caffemodel --extensions /home/,/some/other/path/ --mean_file /path/to/binaryproto
-```
-
-Launch the Model Optimizer for TensorFlow* FaceNet* model with a placeholder freezing value. 
-It replaces the placeholder with a constant layer that contains the passed value.
-For more information about FaceNet conversion, please refer to [this](tf_specific/Convert_FaceNet_From_Tensorflow.md) page.
-```sh
-mo --input_model FaceNet.pb --input "phase_train->False"
-```
-Launch the Model Optimizer for any model with a placeholder freezing tensor of values. 
-It replaces the placeholder with a constant layer that contains the passed values.
-
-Tensor here is represented in square brackets with each value separated from another by a whitespace. 
-If data type is set in the model, this tensor will be reshaped to a placeholder shape and casted to placeholder data type.
-Otherwise, it will be casted to data type passed to `--data_type` parameter (by default, it is FP32).
-```sh
-mo --input_model FaceNet.pb --input "placeholder_layer_name->[0.1 1.2 2.3]"
-```
-
 
 ## See Also
 * [Configuring the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md)
-* [IR Notation Reference](../../IR_and_opsets.md)
-* [Model Optimizer Extensibility](../customize_model_optimizer/Customize_Model_Optimizer.md)
 * [Model Cutting](Cutting_Model.md)
+* [Optimize Preprocessing Computation](../Additional_Optimizations.md)
+* [Convert TensorFlow Models](Convert_Model_From_TensorFlow.md)
+* [Convert ONNX Models](Convert_Model_From_ONNX.md)
+* [Convert PyTorch Models](Convert_Model_From_PyTorch.md)
+* [Convert PaddlePaddle Models](Convert_Model_From_Paddle.md)
+* [Convert MXNet Models](Convert_Model_From_MxNet.md)
+* [Convert Caffe Models](Convert_Model_From_Caffe.md)
+* [Convert Kaldi Models](Convert_Model_From_Kaldi.md)

docs/MO_DG/prepare_model/convert_model/kaldi_specific/Aspire_Tdnn_Model.md

@@ -1,6 +1,6 @@
-# Convert Kaldi* ASpIRE Chain Time Delay Neural Network (TDNN) Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_kaldi_specific_Aspire_Tdnn_Model}
+# Convert Kaldi* ASpIRE Chain Time Delay Neural Network (TDNN) Model {#openvino_docs_MO_DG_prepare_model_convert_model_kaldi_specific_Aspire_Tdnn_Model}
 
-You can [download a pre-trained model](https://kaldi-asr.org/models/1/0001_aspire_chain_model.tar.gz) 
+You can [download a pre-trained model](https://kaldi-asr.org/models/1/0001_aspire_chain_model.tar.gz)
 for the ASpIRE Chain Time Delay Neural Network (TDNN) from the Kaldi* project official website.
 
 ## Convert ASpIRE Chain TDNN Model to IR
@@ -10,15 +10,15 @@ To generate the Intermediate Representation (IR) of the model, run the Model Opt
  mo --input_model exp/chain/tdnn_7b/final.mdl --output output
 ```
 
-The IR will have two inputs: `input` for data and `ivector` for ivectors. 
+The IR will have two inputs: `input` for data and `ivector` for ivectors.
 
 ## Example: Run ASpIRE Chain TDNN Model with the Speech Recognition Sample
 
 These instructions show how to run the converted model with the [Speech Recognition sample](../../../../../samples/cpp/speech_sample/README.md).
-In this example, the input data contains one utterance from one speaker. 
+In this example, the input data contains one utterance from one speaker.
 
-To follow the steps described below, you must first do the following: 
+To follow the steps described below, you must first do the following:
-1. Download a [Kaldi repository](https://github.com/kaldi-asr/kaldi). 
+1. Download a [Kaldi repository](https://github.com/kaldi-asr/kaldi).
 2. Build it using instructions in `README.md` in the repository.
 3. Download the [model archive](https://kaldi-asr.org/models/1/0001_aspire_chain_model.tar.gz) from Kaldi website.
 4. Extract the downloaded model archive to the `egs/aspire/s5` folder of the Kaldi repository.
@@ -49,10 +49,10 @@ cd <path_to_kaldi_repo>/egs/aspire/s5/
 
 2. Extract ivectors from the data:
 ```sh
-./steps/online/nnet2/extract_ivectors_online.sh --nj 1 --ivector_period <max_frame_count_in_utterance> <data folder> exp/tdnn_7b_chain_online/ivector_extractor <ivector folder> 
+./steps/online/nnet2/extract_ivectors_online.sh --nj 1 --ivector_period <max_frame_count_in_utterance> <data folder> exp/tdnn_7b_chain_online/ivector_extractor <ivector folder>
 ```
-To simplify the preparation of ivectors for the Speech Recognition sample, 
+To simplify the preparation of ivectors for the Speech Recognition sample,
-specify the maximum number of frames in utterances as a parameter for `--ivector_period` 
+specify the maximum number of frames in utterances as a parameter for `--ivector_period`
 to get only one ivector per utterance.
 
 To get the maximum number of frames in utterances, you can use the following command line:
@@ -71,7 +71,7 @@ cd <ivector folder>
 <path_to_kaldi_repo>/src/featbin/copy-feats --binary=False ark:ivector_online.1.ark ark,t:ivector_online.1.ark.txt
 ```
 
-5. For the Speech Recognition sample, the `.ark` file must contain an ivector 
+5. For the Speech Recognition sample, the `.ark` file must contain an ivector
 for each frame. You must copy the ivector `frame_count` times.
 To do this, you can run the following script in the Python* command prompt:
 ```python
@@ -108,5 +108,5 @@ Run the Speech Recognition sample with the created ivector `.ark` file as follow
 speech_sample -i feats.ark,ivector_online_ie.ark -m final.xml -d CPU -o prediction.ark -cw_l 17 -cw_r 12
 ```
 
-Results can be decoded as described in "Use of Sample in Kaldi* Speech Recognition Pipeline" chapter 
+Results can be decoded as described in "Use of Sample in Kaldi* Speech Recognition Pipeline" chapter
 in [the Speech Recognition Sample description](../../../../../samples/cpp/speech_sample/README.md).

docs/MO_DG/prepare_model/convert_model/mxnet_specific/Convert_GluonCV_Models.md

@@ -1,15 +1,15 @@
-# Converting GluonCV* Models {#openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_GluonCV_Models}
+# Convert MXNet GluonCV* Models {#openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_GluonCV_Models}
 
 This document provides the instructions and examples on how to use Model Optimizer to convert [GluonCV SSD and YOLO-v3 models](https://gluon-cv.mxnet.io/model_zoo/detection.html) to IR.
 
-1. Choose the topology available from the [GluonCV Model Zoo](https://gluon-cv.mxnet.io/model_zoo/detection.html) and export to the MXNet format using the GluonCV API. For example, for the `ssd_512_mobilenet1.0` topology: 
+1. Choose the topology available from the [GluonCV Model Zoo](https://gluon-cv.mxnet.io/model_zoo/detection.html) and export to the MXNet format using the GluonCV API. For example, for the `ssd_512_mobilenet1.0` topology:
 ```python
 from gluoncv import model_zoo, data, utils
 from gluoncv.utils import export_block
 net = model_zoo.get_model('ssd_512_mobilenet1.0_voc', pretrained=True)
 export_block('ssd_512_mobilenet1.0_voc', net, preprocess=True, layout='HWC')
 ```
-As a result, you will get an MXNet model representation in `ssd_512_mobilenet1.0.params` and `ssd_512_mobilenet1.0.json` files generated in the current directory. 
+As a result, you will get an MXNet model representation in `ssd_512_mobilenet1.0.params` and `ssd_512_mobilenet1.0.json` files generated in the current directory.
 2. Run the Model Optimizer tool specifying the `--enable_ssd_gluoncv` option. Make sure the `--input_shape` parameter is set to the input shape layout of your model (NHWC or NCHW). The examples below illustrates running the Model Optimizer for the SSD and YOLO-v3 models trained with the NHWC layout and located in the `<model_directory>`:
 * **For GluonCV SSD topologies:**
 ```sh

docs/MO_DG/prepare_model/convert_model/mxnet_specific/Convert_Style_Transfer_From_MXNet.md

@@ -1,4 +1,4 @@
-# Converting a Style Transfer Model from MXNet*  {#openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_Style_Transfer_From_MXNet}
+# Convert MXNet Style Transfer Model {#openvino_docs_MO_DG_prepare_model_convert_model_mxnet_specific_Convert_Style_Transfer_From_MXNet}
 
 The tutorial explains how to generate a model for style transfer using the public MXNet\* neural style transfer sample.
 To use the style transfer sample from OpenVINO™, follow the steps below as no public pre-trained style transfer model is provided with the OpenVINO toolkit.
@@ -86,8 +86,8 @@ import make_image
 maker = make_image.Maker('models/13', (1024, 768))
 maker.generate('output.jpg', '../images/tubingen.jpg')
 ```
-Where the `models/13` string is composed of the following substrings: 
+Where the `models/13` string is composed of the following substrings:
-* `models/`: path to the folder that contains .nd files with pre-trained styles weights 
+* `models/`: path to the folder that contains .nd files with pre-trained styles weights
 * `13`: prefix pointing to 13_decoder, which is the default decoder for the repository.
 
 > **NOTE**: If you get an error saying "No module named 'cPickle'", try running the script from this step in Python 2. Then return to Python 3 for the remaining steps.
@@ -114,4 +114,4 @@ cp models/13_decoder_auxs.nd nst_model
 ```sh
 mo --input_symbol <path/to/nst_model>/nst_vgg19-symbol.json --framework mxnet --output_dir <path/to/output_dir> --input_shape [1,3,224,224] --nd_prefix_name 13_decoder --pretrained_model <path/to/nst_model>/vgg19-0000.params
 ```
-4. The IR is generated (`.bin`, `.xml` and `.mapping` files) in the specified output directory and ready to be consumed by the OpenVINO Runtime. 
+4. The IR is generated (`.bin`, `.xml` and `.mapping` files) in the specified output directory and ready to be consumed by the OpenVINO Runtime.

docs/MO_DG/prepare_model/convert_model/onnx_specific/Convert_DLRM.md

@@ -1,32 +0,0 @@
-[DEPRECATED] Convert ONNX* DLRM to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_DLRM}
-===============================
-
-> **NOTE**: These instructions are currently deprecated. Since OpenVINO™ 2020.4 version, no specific steps are needed to convert ONNX\* DLRM models. For general instructions on converting ONNX models, please refer to [Converting a ONNX* Model](../Convert_Model_From_ONNX.md) topic.
-
-These instructions are applicable only to the DLRM converted to the ONNX* file format from the [facebookresearch/dlrm model](https://github.com/facebookresearch/dlrm).
-
-**Step 1**. Save trained Pytorch* model to ONNX* format or download pretrained ONNX* from 
-[MLCommons/inference/recommendation/dlrm](https://github.com/mlcommons/inference/tree/r1.0/recommendation/dlrm/pytorch#supported-models) repository. 
-If you train the model using the [script provided in model repository](https://github.com/facebookresearch/dlrm/blob/master/dlrm_s_pytorch.py), just add the `--save-onnx` flag to the command line parameters and you'll get the `dlrm_s_pytorch.onnx` file containing the model serialized in ONNX* format.
-
-**Step 2**. To generate the Intermediate Representation (IR) of the model, change your current working directory to the Model Optimizer installation directory and run the Model Optimizer with the following parameters:
-```sh
-mo --input_model dlrm_s_pytorch.onnx
-```
-
-Note that Pytorch model uses operation `torch.nn.EmbeddingBag`. This operation converts to onnx as custom `ATen` layer and not directly supported by OpenVINO*, but it is possible to convert this operation to:
-* `Gather` if each "bag" consists of exactly one index. In this case `offsets` input becomes obsolete and not needed. They will be removed during conversion.
-* `ExperimentalSparseWeightedSum` if "bags" contain not just one index. In this case Model Optimizer will print warning that pre-process of offsets is needed, because `ExperimentalSparseWeightedSum` and `torch.nn.EmbeddingBag` have different format of inputs.
-For example if you have `indices` input of shape [indices_shape] and `offsets` input of shape [num_bags] you need to get offsets of shape [indices_shape, 2]. To do that you may use the following code snippet:
-```python
-import numpy as np
-
-new_offsets = np.zeros((indices.shape[-1], 2), dtype=np.int32)
-new_offsets[:, 1] = np.arange(indices.shape[-1])
-bag_index = 0
-for i in range(offsets.shape[-1] - 1):
-    new_offsets[offsets[i]:offsets[i + 1], 0] = bag_index
-    bag_index += 1
-new_offsets[offsets[-1]:, 0] = bag_index
-```
-If you have more than one `torch.nn.EmbeddingBag` operation you'll need to do that for every offset input. If your offsets have same shape they will be merged into one input of shape [num_embedding_bags, indices_shape, 2].

docs/MO_DG/prepare_model/convert_model/onnx_specific/Convert_Faster_RCNN.md

@@ -1,4 +1,4 @@
-# Convert ONNX* Faster R-CNN Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Faster_RCNN}
+# Convert ONNX* Faster R-CNN Model {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Faster_RCNN}
 
 These instructions are applicable only to the Faster R-CNN model converted to the ONNX* file format from the [facebookresearch/maskrcnn-benchmark model](https://github.com/facebookresearch/maskrcnn-benchmark).
 
@@ -11,7 +11,7 @@ These instructions are applicable only to the Faster R-CNN model converted to th
 --input_shape [1,3,800,800] \
 --input 0:2 \
 --mean_values [102.9801,115.9465,122.7717] \
---transformations_config front/onnx/faster_rcnn.json 
+--transformations_config front/onnx/faster_rcnn.json
 ```
 
 Note that the height and width specified with the `input_shape` command line parameter could be different. Refer to the [documentation](https://github.com/onnx/models/tree/master/vision/object_detection_segmentation/faster-rcnn) for more information about supported input image dimensions and required pre- and post-processing steps.

docs/MO_DG/prepare_model/convert_model/onnx_specific/Convert_GPT2.md

@@ -1,4 +1,4 @@
-# Convert ONNX* GPT-2 Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_GPT2}
+# Convert ONNX* GPT-2 Model {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_GPT2}
 
 [Public pre-trained GPT-2 model](https://github.com/onnx/models/tree/master/text/machine_comprehension/gpt-2)  is a large
 transformer-based language model with a simple objective: predict the next word, given all of the previous words within some text.

docs/MO_DG/prepare_model/convert_model/onnx_specific/Convert_Mask_RCNN.md

@@ -1,4 +1,4 @@
-# Convert ONNX* Mask R-CNN Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Mask_RCNN}
+# Convert ONNX* Mask R-CNN Model {#openvino_docs_MO_DG_prepare_model_convert_model_onnx_specific_Convert_Mask_RCNN}
 
 These instructions are applicable only to the Mask R-CNN model converted to the ONNX* file format from the [facebookresearch/maskrcnn-benchmark model](https://github.com/facebookresearch/maskrcnn-benchmark).
 
@@ -11,7 +11,7 @@ These instructions are applicable only to the Mask R-CNN model converted to the
 --input "0:2" \
 --input_shape [1,3,800,800] \
 --mean_values [102.9801,115.9465,122.7717] \
---transformations_config front/onnx/mask_rcnn.json 
+--transformations_config front/onnx/mask_rcnn.json
 ```
 
 Note that the height and width specified with the `input_shape` command line parameter could be different. Refer to the [documentation](https://github.com/onnx/models/tree/master/vision/object_detection_segmentation/mask-rcnn) for more information about supported input image dimensions and required pre- and post-processing steps.

docs/MO_DG/prepare_model/convert_model/pytorch_specific/Convert_Bert_ner.md

@@ -1,4 +1,4 @@
-# Convert PyTorch* BERT-NER to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_Bert_ner}
+# Convert PyTorch* BERT-NER Model {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_Bert_ner}
 
 ## Download and Convert the Model to ONNX*
 

docs/MO_DG/prepare_model/convert_model/pytorch_specific/Convert_F3Net.md

@@ -1,4 +1,4 @@
-# Convert PyTorch* F3Net to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_F3Net}
+# Convert PyTorch* F3Net Model {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_F3Net}
 
 [F3Net](https://github.com/weijun88/F3Net): Fusion, Feedback and Focus for Salient Object Detection
 
@@ -7,12 +7,12 @@
 To clone the repository, run the following command:
 
 ```sh
-git clone http://github.com/weijun88/F3Net.git 
+git clone http://github.com/weijun88/F3Net.git
 ```
 
 ## Download and Convert the Model to ONNX*
 
-To download the pre-trained model or train the model yourself, refer to the 
+To download the pre-trained model or train the model yourself, refer to the
 [instruction](https://github.com/weijun88/F3Net/blob/master/README.md) in the F3Net model repository. First, convert the model to ONNX\* format. Create and run the following Python script in the `src` directory of the model repository:
 ```python
 import torch

docs/MO_DG/prepare_model/convert_model/pytorch_specific/Convert_QuartzNet.md

@@ -1,4 +1,4 @@
-# Convert PyTorch* QuartzNet to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_QuartzNet}
+# Convert PyTorch* QuartzNet Model {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_QuartzNet}
 
 [NeMo project](https://github.com/NVIDIA/NeMo) provides the QuartzNet model.
 

docs/MO_DG/prepare_model/convert_model/pytorch_specific/Convert_RCAN.md

@@ -1,4 +1,4 @@
-# Convert PyTorch* RCAN to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RCAN}
+# Convert PyTorch* RCAN Model {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RCAN}
 
 [RCAN](https://github.com/yulunzhang/RCAN): Image Super-Resolution Using Very Deep Residual Channel Attention Networks
 

docs/MO_DG/prepare_model/convert_model/pytorch_specific/Convert_RNNT.md

@@ -1,22 +1,22 @@
-# Convert PyTorch\* RNN-T Model to the Intermediate Representation (IR) {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RNNT}
+# Convert PyTorch* RNN-T Model {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_RNNT}
 
-This instruction covers conversion of RNN-T model from [MLCommons](https://github.com/mlcommons) repository. Follow 
+This instruction covers conversion of RNN-T model from [MLCommons](https://github.com/mlcommons) repository. Follow
 the steps below to export a PyTorch* model into ONNX* before converting it to IR:
 
-**Step 1**. Clone RNN-T PyTorch implementation from MLCommons repository (revision r1.0). Make a shallow clone to pull 
+**Step 1**. Clone RNN-T PyTorch implementation from MLCommons repository (revision r1.0). Make a shallow clone to pull
 only RNN-T model without full repository. If you already have a full repository, skip this and go to **Step 2**:
 ```bash
 git clone -b r1.0 -n https://github.com/mlcommons/inference rnnt_for_openvino --depth 1
 cd rnnt_for_openvino
-git checkout HEAD speech_recognition/rnnt 
+git checkout HEAD speech_recognition/rnnt
 ```
 
-**Step 2**. If you already have a full clone of MLCommons inference repository, create a folder for 
+**Step 2**. If you already have a full clone of MLCommons inference repository, create a folder for
-pretrained PyTorch model, where conversion into IR will take place. You will also need to specify the path to 
+pretrained PyTorch model, where conversion into IR will take place. You will also need to specify the path to
 your full clone at **Step 5**. Skip this step if you have a shallow clone.
 
 ```bash
-mkdir rnnt_for_openvino 
+mkdir rnnt_for_openvino
 cd rnnt_for_openvino
 ```
 
@@ -25,7 +25,7 @@ For UNIX*-like systems you can use `wget`:
 ```bash
 wget https://zenodo.org/record/3662521/files/DistributedDataParallel_1576581068.9962234-epoch-100.pt
 ```
-The link was taken from `setup.sh` in the `speech_recoginitin/rnnt` subfolder. You will get exactly the same weights as 
+The link was taken from `setup.sh` in the `speech_recoginitin/rnnt` subfolder. You will get exactly the same weights as
 if you were following the steps from [https://github.com/mlcommons/inference/tree/master/speech_recognition/rnnt](https://github.com/mlcommons/inference/tree/master/speech_recognition/rnnt).
 
 **Step 4**. Install required Python packages:
@@ -33,7 +33,7 @@ if you were following the steps from [https://github.com/mlcommons/inference/tre
 pip3 install torch toml
 ```
 
-**Step 5**. Export RNN-T model into ONNX with the script below. Copy the code below into a file named 
+**Step 5**. Export RNN-T model into ONNX with the script below. Copy the code below into a file named
 `export_rnnt_to_onnx.py` and run it in the current directory `rnnt_for_openvino`:
 
 > **NOTE**: If you already have a full clone of MLCommons inference repository, you need to
@@ -94,7 +94,7 @@ torch.onnx.export(model.joint, (f, g), "rnnt_joint.onnx", opset_version=12,
 python3 export_rnnt_to_onnx.py
 ```
 
-After completing this step, the files `rnnt_encoder.onnx`, `rnnt_prediction.onnx`, and `rnnt_joint.onnx` will be saved in the current directory. 
+After completing this step, the files `rnnt_encoder.onnx`, `rnnt_prediction.onnx`, and `rnnt_joint.onnx` will be saved in the current directory.
 
 **Step 6**. Run the conversion commands:
 
@@ -103,6 +103,6 @@ mo --input_model rnnt_encoder.onnx --input "input[157 1 240],feature_length->157
 mo --input_model rnnt_prediction.onnx --input "symbol[1 1],hidden_in_1[2 1 320],hidden_in_2[2 1 320]"
 mo --input_model rnnt_joint.onnx --input "0[1 1 1024],1[1 1 320]"
 ```
-Please note that hardcoded value for sequence length = 157 was taken from the MLCommons but conversion to IR preserves 
+Please note that hardcoded value for sequence length = 157 was taken from the MLCommons but conversion to IR preserves
-network [reshapeability](../../../../OV_Runtime_UG/ShapeInference.md), this means you can change input shapes manually to any value either during conversion or 
+network [reshapeability](../../../../OV_Runtime_UG/ShapeInference.md), this means you can change input shapes manually to any value either during conversion or
 inference.

docs/MO_DG/prepare_model/convert_model/pytorch_specific/Convert_YOLACT.md

@@ -1,4 +1,4 @@
-# Convert PyTorch* YOLACT to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_YOLACT}
+# Convert PyTorch* YOLACT Model {#openvino_docs_MO_DG_prepare_model_convert_model_pytorch_specific_Convert_YOLACT}
 
 You Only Look At CoefficienTs (YOLACT) is a simple, fully convolutional model for real-time instance segmentation.
 The PyTorch\* implementation is publicly available in [this GitHub* repository](https://github.com/dbolya/yolact).
@@ -29,7 +29,7 @@ index 547bc0a..bde0680 100644
 +++ b/eval.py
 @@ -593,9 +593,12 @@ def badhash(x):
      return x
- 
+
  def evalimage(net:Yolact, path:str, save_path:str=None):
 -    frame = torch.from_numpy(cv2.imread(path)).cuda().float()
 +    frame = torch.from_numpy(cv2.imread(path)).float()
@@ -38,9 +38,9 @@ index 547bc0a..bde0680 100644
      batch = FastBaseTransform()(frame.unsqueeze(0))
      preds = net(batch)
 +    torch.onnx.export(net, batch, "yolact.onnx", opset_version=11)
- 
+
      img_numpy = prep_display(preds, frame, None, None, undo_transform=False)
-     
+
 diff --git a/utils/augmentations.py b/utils/augmentations.py
 index cc7a73a..2420603 100644
 --- a/utils/augmentations.py
@@ -48,7 +48,7 @@ index cc7a73a..2420603 100644
 @@ -623,8 +623,11 @@ class FastBaseTransform(torch.nn.Module):
      def __init__(self):
          super().__init__()
- 
+
 -        self.mean = torch.Tensor(MEANS).float().cuda()[None, :, None, None]
 -        self.std  = torch.Tensor( STD ).float().cuda()[None, :, None, None]
 +        self.mean = torch.Tensor(MEANS).float()[None, :, None, None]
@@ -57,7 +57,7 @@ index cc7a73a..2420603 100644
 +            self.mean.cuda()
 +            self.std.cuda()
          self.transform = cfg.backbone.transform
- 
+
      def forward(self, img):
 diff --git a/yolact.py b/yolact.py
 index d83703b..f8c787c 100644
@@ -66,7 +66,7 @@ index d83703b..f8c787c 100644
 @@ -17,19 +17,22 @@ import torch.backends.cudnn as cudnn
  from utils import timer
  from utils.functions import MovingAverage, make_net
- 
+
 -# This is required for Pytorch 1.0.1 on Windows to initialize Cuda on some driver versions.
 -# See the bug report here: https://github.com/pytorch/pytorch/issues/17108
 -torch.cuda.current_device()
@@ -76,11 +76,11 @@ index d83703b..f8c787c 100644
 -if not use_jit:
 -    print('Multiple GPUs detected! Turning off JIT.')
 +use_jit = False
- 
+
  ScriptModuleWrapper = torch.jit.ScriptModule if use_jit else nn.Module
  script_method_wrapper = torch.jit.script_method if use_jit else lambda fn, _rcn=None: fn
- 
+
- 
+
 +def decode(loc, priors):
 +    variances = [0.1, 0.2]
 +    boxes = torch.cat((priors[:, :2] + loc[:, :, :2] * variances[0] * priors[:, 2:], priors[:, 2:] * torch.exp(loc[:, :, 2:] * variances[1])), 2)
@@ -91,11 +91,11 @@ index d83703b..f8c787c 100644
 +
 +    return boxes_result
 +
- 
+
  class Concat(nn.Module):
      def __init__(self, nets, extra_params):
 @@ -476,7 +479,10 @@ class Yolact(nn.Module):
-     
+
      def load_weights(self, path):
          """ Loads weights from a compressed save file. """
 -        state_dict = torch.load(path)
@@ -103,23 +103,23 @@ index d83703b..f8c787c 100644
 +            state_dict = torch.load(path)
 +        else:
 +            state_dict = torch.load(path, map_location=torch.device('cpu'))
- 
+
          # For backward compatability, remove these (the new variable is called layers)
          for key in list(state_dict.keys()):
 @@ -673,8 +679,11 @@ class Yolact(nn.Module):
                  else:
                      pred_outs['conf'] = F.softmax(pred_outs['conf'], -1)
- 
+
 -            return self.detect(pred_outs, self)
 +            pred_outs['boxes'] = decode(pred_outs['loc'], pred_outs['priors']) # decode output boxes
- 
+
 +            pred_outs.pop('priors') # remove unused in postprocessing layers
 +            pred_outs.pop('loc') # remove unused in postprocessing layers
 +            return pred_outs
- 
+
- 
+
- 
+
--- 
+--
 ```
 3. Save and close the file.
 

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

@@ -1,4 +1,4 @@
-# Convert TensorFlow* Attention OCR Model to Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_AttentionOCR_From_Tensorflow}
+# Convert TensorFlow Attention OCR Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_AttentionOCR_From_Tensorflow}
 
 This tutorial explains how to convert the Attention OCR (AOCR) model from the [TensorFlow* Attention OCR repository](https://github.com/emedvedev/attention-ocr) to the Intermediate Representation (IR).
 
@@ -20,7 +20,7 @@ The original AOCR model contains data preprocessing which consists of the follow
 * Decoding input data to binary format where input data is an image represented as a string.
 * Resizing binary image to working resolution.
 
-After that, the resized image is sent to the convolution neural network (CNN). The Model Optimizer does not support image decoding so you should cut of preprocessing part of the model using '--input' command line parameter. 
+After that, the resized image is sent to the convolution neural network (CNN). The Model Optimizer does not support image decoding so you should cut of preprocessing part of the model using '--input' command line parameter.
 ```sh
 mo \
 --input_model=model/path/frozen_graph.pb \

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

@@ -1,4 +1,4 @@
-# Convert TensorFlow* BERT Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_BERT_From_Tensorflow}
+# Convert TensorFlow BERT Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_BERT_From_Tensorflow}
 
 Pre-trained models for BERT (Bidirectional Encoder Representations from Transformers) are
 [publicly available](https://github.com/google-research/bert).
@@ -112,7 +112,7 @@ Run the Model Optimizer with the following command line parameters to generate r
 ```sh
  mo \
 --input_model inference_graph.pb \
---input "IteratorGetNext:0{i32}[1 128],IteratorGetNext:1{i32}[1 128],IteratorGetNext:4{i32}[1 128]" 
+--input "IteratorGetNext:0{i32}[1 128],IteratorGetNext:1{i32}[1 128],IteratorGetNext:4{i32}[1 128]"
 ```
 For other applicable parameters, refer to [Convert Model from TensorFlow](../Convert_Model_From_TensorFlow.md).
 

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

@@ -1,4 +1,4 @@
-# Convert CRNN* Models to the Intermediate Representation (IR) {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_CRNN_From_Tensorflow}
+# Convert TensorFlow CRNN Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_CRNN_From_Tensorflow}
 
 This tutorial explains how to convert a CRNN model to Intermediate Representation (IR).
 

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

@@ -1,4 +1,4 @@
-# Convert TensorFlow* DeepSpeech Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_DeepSpeech_From_Tensorflow}
+# Convert TensorFlow DeepSpeech Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_DeepSpeech_From_Tensorflow}
 
 [DeepSpeech project](https://github.com/mozilla/DeepSpeech) provides an engine to train speech-to-text models.
 
@@ -9,7 +9,7 @@ Create a directory where model and metagraph with pretrained weights will be sto
 mkdir deepspeech
 cd deepspeech
 ```
-[Pretrained English speech-to-text model](https://github.com/mozilla/DeepSpeech/releases/tag/v0.8.2) is publicly available. 
+[Pretrained English speech-to-text model](https://github.com/mozilla/DeepSpeech/releases/tag/v0.8.2) is publicly available.
 To download the model, follow the instruction below:
 
 * For UNIX*-like systems, run the following command:
@@ -24,7 +24,7 @@ wget -O - https://github.com/mozilla/DeepSpeech/releases/download/v0.8.2/deepspe
 
 ## Freeze the Model into a *.pb File
 
-After unpacking the archives above, you have to freeze the model. Note that this requires 
+After unpacking the archives above, you have to freeze the model. Note that this requires
 TensorFlow* version 1 which is not available under Python 3.8, so you need Python 3.7 or lower.
 Before freezing, deploy a virtual environment and install the required packages:
 ```
@@ -37,29 +37,29 @@ Freeze the model with the following command:
 ```
 python3 DeepSpeech.py --checkpoint_dir ../deepspeech-0.8.2-checkpoint --export_dir ../
 ```
-After that, you will get the pretrained frozen model file `output_graph.pb` in the directory `deepspeech` created at 
+After that, you will get the pretrained frozen model file `output_graph.pb` in the directory `deepspeech` created at
-the beginning. The model contains the preprocessing and main parts. The first preprocessing part performs conversion of input 
+the beginning. The model contains the preprocessing and main parts. The first preprocessing part performs conversion of input
-spectrogram into a form useful for speech recognition (mel). This part of the model is not convertible into 
+spectrogram into a form useful for speech recognition (mel). This part of the model is not convertible into
 IR because it contains unsupported operations `AudioSpectrogram` and `Mfcc`.
 
-The main and most computationally expensive part of the model converts the preprocessed audio into text. 
+The main and most computationally expensive part of the model converts the preprocessed audio into text.
-There are two specificities with the supported part of the model. 
+There are two specificities with the supported part of the model.
 
-The first is that the model contains an input with sequence length. So the model can be converted with 
+The first is that the model contains an input with sequence length. So the model can be converted with
-a fixed input length shape, thus the model is not reshapeable. 
+a fixed input length shape, thus the model is not reshapeable.
 Refer to the [Using Shape Inference](../../../../OV_Runtime_UG/ShapeInference.md).
 
-The second is that the frozen model still has two variables: `previous_state_c` and `previous_state_h`, figure 
+The second is that the frozen model still has two variables: `previous_state_c` and `previous_state_h`, figure
-with the frozen *.pb model is below. It means that the model keeps training these variables at each inference. 
+with the frozen *.pb model is below. It means that the model keeps training these variables at each inference.
 
 ![DeepSpeech model view](../../../img/DeepSpeech-0.8.2.png)
 
-At the first inference the variables are initialized with zero tensors. After executing, the results of the `BlockLSTM` 
+At the first inference the variables are initialized with zero tensors. After executing, the results of the `BlockLSTM`
 are assigned to cell state and hidden state, which are these two variables.
 
 ## Convert the Main Part of DeepSpeech Model into IR
 
-Model Optimizer assumes that the output model is for inference only. That is why you should cut `previous_state_c` 
+Model Optimizer assumes that the output model is for inference only. That is why you should cut `previous_state_c`
 and `previous_state_h` variables off and resolve keeping cell and hidden states on the application level.
 
 There are certain limitations for the model conversion:
@@ -75,7 +75,7 @@ mo                             \
 ```
 
 Where:
-* `input_lengths->[16]` Replaces the input node with name "input_lengths" with a constant tensor of shape [1] with a 
+* `input_lengths->[16]` Replaces the input node with name "input_lengths" with a constant tensor of shape [1] with a
   single integer value 16. This means that the model now can consume input sequences of length 16 only.
 * `input_node[1 16 19 26],previous_state_h[1 2048],previous_state_c[1 2048]` replaces the variables with a placeholder.
 * `--output ".../GatherNd_1,.../GatherNd,logits" ` output node names.

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

@@ -1,11 +1,11 @@
-# Converting EfficientDet Models from TensorFlow {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_EfficientDet_Models}
+# Convert TensorFlow EfficientDet Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_EfficientDet_Models}
 
-This tutorial explains how to convert EfficientDet\* public object detection models to the Intermediate Representation (IR). 
+This tutorial explains how to convert EfficientDet\* public object detection models to the Intermediate Representation (IR).
 
 ## <a name="efficientdet-to-ir"></a>Convert EfficientDet Model to IR
 
-On GitHub*, you can find several public versions of EfficientDet model implementation. This tutorial explains how to 
+On GitHub*, you can find several public versions of EfficientDet model implementation. This tutorial explains how to
-convert models from the [https://github.com/google/automl/tree/master/efficientdet](https://github.com/google/automl/tree/master/efficientdet) 
+convert models from the [https://github.com/google/automl/tree/master/efficientdet](https://github.com/google/automl/tree/master/efficientdet)
 repository (commit 96e1fee) to IR.
 
 ### Get Frozen TensorFlow\* Model
@@ -60,15 +60,15 @@ dictionary in the [hparams_config.py](https://github.com/google/automl/blob/96e1
 The attribute `image_size` specifies the shape to be specified for the model conversion.
 
 The `transformations_config` command line parameter specifies the configuration json file containing hints
-to the Model Optimizer on how to convert the model and trigger transformations implemented in the 
+to the Model Optimizer on how to convert the model and trigger transformations implemented in the
 `<PYTHON_SITE_PACKAGES>/openvino/tools/mo/front/tf/AutomlEfficientDet.py`. The json file contains some parameters which must be changed if you
 train the model yourself and modified the `hparams_config` file or the parameters are different from the ones used for EfficientDet-D4.
 The attribute names are self-explanatory or match the name in the `hparams_config` file.
 
 > **NOTE**: The color channel order (RGB or BGR) of an input data should match the channel order of the model training dataset. If they are different, perform the `RGB<->BGR` conversion specifying the command-line parameter: `--reverse_input_channels`. Otherwise, inference results may be incorrect. For more information about the parameter, refer to **When to Reverse Input Channels** section of [Converting a Model to Intermediate Representation (IR)](../Converting_Model.md).
 
-OpenVINO&trade; toolkit provides samples that can be used to infer EfficientDet model. For more information, refer to 
+OpenVINO&trade; toolkit provides samples that can be used to infer EfficientDet model. For more information, refer to
-[Open Model Zoo Demos](@ref omz_demos) and 
+[Open Model Zoo Demos](@ref omz_demos) and
 
 ## <a name="efficientdet-ir-results-interpretation"></a>Interpreting Results of the TensorFlow Model and the IR
 
@@ -90,9 +90,4 @@ The output of the IR is a list of 7-element tuples: `[image_id, class_id, confid
 * `x_max` -- normalized `x` coordinate of the upper right corner of the detected object.
 * `y_max` -- normalized `y` coordinate of the upper right corner of the detected object.
 
-The first element with `image_id = -1` means end of data.
+The first element with `image_id = -1` means end of data.
-
----
-## See Also
-
-* [Sub-Graph Replacement in Model Optimizer](../../customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md)

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

@@ -1,4 +1,4 @@
-# Convert TensorFlow* FaceNet Models to Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_FaceNet_From_Tensorflow}
+# Convert TensorFlow FaceNet Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_FaceNet_From_Tensorflow}
 
 [Public pre-trained FaceNet models](https://github.com/davidsandberg/facenet#pre-trained-models) contain both training
 and inference part of graph. Switch between this two states is manageable with placeholder value.

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

@@ -1,4 +1,4 @@
-# Convert GNMT* Model to the Intermediate Representation (IR) {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_GNMT_From_Tensorflow}
+# Convert TensorFlow GNMT Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_GNMT_From_Tensorflow}
 
 This tutorial explains how to convert Google\* Neural Machine Translation (GNMT) model to the Intermediate Representation (IR).
 
@@ -17,20 +17,20 @@ index 2cbef07..e185490 100644
 +++ b/nmt/inference.py
 @@ -17,9 +17,11 @@
  from __future__ import print_function
- 
+
  import codecs
 +import os
  import time
- 
+
  import tensorflow as tf
 +from tensorflow.python.framework import graph_io
- 
+
  from . import attention_model
  from . import gnmt_model
 @@ -105,6 +107,29 @@ def start_sess_and_load_model(infer_model, ckpt_path):
    return sess, loaded_infer_model
- 
+
- 
+
 +def inference_dump_graph(ckpt_path, path_to_dump, hparams, scope=None):
 +    model_creator = get_model_creator(hparams)
 +    infer_model = model_helper.create_infer_model(model_creator, hparams, scope)
@@ -64,7 +64,7 @@ index f5823d8..a733748 100644
 @@ -310,6 +310,13 @@ def add_arguments(parser):
    parser.add_argument("--num_intra_threads", type=int, default=0,
                        help="number of intra_op_parallelism_threads")
- 
+
 +  # Special argument for inference model dumping without inference
 +  parser.add_argument("--dump_inference_model", type="bool", nargs="?",
 +                      const=True, default=False,
@@ -72,7 +72,7 @@ index f5823d8..a733748 100644
 +
 +  parser.add_argument("--path_to_dump", type=str, default="",
 +                      help="Path to dump inference graph.")
- 
+
  def create_hparams(flags):
    """Create training hparams."""
 @@ -396,6 +403,9 @@ def create_hparams(flags):
@@ -83,12 +83,12 @@ index f5823d8..a733748 100644
 +      dump_inference_model=flags.dump_inference_model,
 +      path_to_dump=flags.path_to_dump,
    )
- 
+
- 
+
 @@ -613,7 +623,7 @@ def create_or_load_hparams(
    return hparams
- 
+
- 
+
 -def run_main(flags, default_hparams, train_fn, inference_fn, target_session=""):
 +def run_main(flags, default_hparams, train_fn, inference_fn, inference_dump, target_session=""):
    """Run main."""
@@ -97,7 +97,7 @@ index f5823d8..a733748 100644
 @@ -653,8 +663,26 @@ def run_main(flags, default_hparams, train_fn, inference_fn, target_session=""):
          out_dir, default_hparams, flags.hparams_path,
          save_hparams=(jobid == 0))
- 
+
 -  ## Train / Decode
 -  if flags.inference_input_file:
 +  #  Dumping inference model
@@ -130,8 +130,8 @@ index f5823d8..a733748 100644
 -  run_main(FLAGS, default_hparams, train_fn, inference_fn)
 +  inference_dump = inference.inference_dump_graph
 +  run_main(FLAGS, default_hparams, train_fn, inference_fn, inference_dump)
- 
+
- 
+
  if __name__ == "__main__":
 
 ```
@@ -224,7 +224,7 @@ For more information about model cutting, refer to [Cutting Off Parts of a Model
 Inputs of the model:
 * `IteratorGetNext/placeholder_out_port_0` input with shape `[batch_size, max_sequence_length]` contains `batch_size` decoded input sentences.
  Every sentence is decoded the same way as indices of sentence elements in vocabulary and padded with index of `eos` (end of sentence symbol). If the length of the sentence is less than `max_sequence_length`, remaining elements are filled with index of `eos` token.
- 
+
 * `IteratorGetNext/placeholder_out_port_1` input with shape `[batch_size]` contains sequence lengths for every sentence from the first input. \
  For example, if `max_sequence_length = 50`, `batch_size = 1` and the sentence has only 30 elements, then the input tensor for `IteratorGetNext/placeholder_out_port_1` should be `[30]`.
 

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

@@ -1,12 +1,12 @@
-# Convert Neural Collaborative Filtering Model from TensorFlow* to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_NCF_From_Tensorflow}
+# Convert TensorFlow Neural Collaborative Filtering Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_NCF_From_Tensorflow}
 
 This tutorial explains how to convert Neural Collaborative Filtering (NCF) model to Intermediate Representation (IR).
 
 [Public TensorFlow NCF model](https://github.com/tensorflow/models/tree/master/official/recommendation) does not contain pre-trained weights. To convert this model to the IR:
- 1. Use [the instructions](https://github.com/tensorflow/models/tree/master/official/recommendation#train-and-evaluate-model) from this repository to train the model. 
+ 1. Use [the instructions](https://github.com/tensorflow/models/tree/master/official/recommendation#train-and-evaluate-model) from this repository to train the model.
- 2. Freeze the inference graph you get on previous step in `model_dir` following 
+ 2. Freeze the inference graph you get on previous step in `model_dir` following
-the instructions from the Freezing Custom Models in Python* section of 
+the instructions from the Freezing Custom Models in Python* section of
-[Converting a TensorFlow* Model](../Convert_Model_From_TensorFlow.md). 
+[Converting a TensorFlow* Model](../Convert_Model_From_TensorFlow.md).
 Run the following commands:
 ```python
 import tensorflow as tf
@@ -22,12 +22,12 @@ graph_io.write_graph(frozen, './', 'inference_graph.pb', as_text=False)
 ```
 where `rating/BiasAdd` is an output node.
 
- 3. Convert the model to the IR.If you look at your frozen model, you can see that 
+ 3. Convert the model to the IR.If you look at your frozen model, you can see that
 it has one input that is split into four `ResourceGather` layers. (Click image to zoom in.)
 
 ![NCF model beginning](../../../img/NCF_start.png)
 
- But as the Model Optimizer does not support such data feeding, you should skip it. Cut 
+ But as the Model Optimizer does not support such data feeding, you should skip it. Cut
 the edges incoming in `ResourceGather`s port 1:
 ```sh
  mo --input_model inference_graph.pb                    \

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

@@ -1,4 +1,4 @@
-# Converting TensorFlow* Object Detection API Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Object_Detection_API_Models}
+# Convert TensorFlow Object Detection API Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Object_Detection_API_Models}
 
 > **NOTES**:
 > * Starting with the 2022.1 release, the Model Optimizer can convert the TensorFlow\* Object Detection API Faster and Mask RCNNs topologies differently. By default, the Model Optimizer adds operation "Proposal" to the generated IR. This operation needs an additional input to the model with name "image_info" which should be fed with several values describing the pre-processing applied to the input image (refer to the [Proposal](../../../../ops/detection/Proposal_4.md) operation specification for more information). However, this input is redundant for the models trained and inferred with equal size images. Model Optimizer can generate IR for such models and insert operation [DetectionOutput](../../../../ops/detection/DetectionOutput_1.md) instead of `Proposal`. The `DetectionOutput` operation does not require additional model input "image_info" and moreover, for some models the produced inference results are closer to the original TensorFlow\* model. In order to trigger new behaviour the attribute "operation_to_add" in the corresponding JSON transformation configuration file should be set to value "DetectionOutput" instead of default one "Proposal".
@@ -128,7 +128,7 @@ Models with `keep_aspect_ratio_resizer` were trained to recognize object in real
 
 ## Detailed Explanations of Model Conversion Process
 
-This section is intended for users who want to understand how the Model Optimizer performs Object Detection API models conversion in details. The knowledge given in this section is also useful for users having complex models that are not converted with the Model Optimizer out of the box. It is highly recommended to read [Sub-Graph Replacement in Model Optimizer](../../customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md) chapter first to understand sub-graph replacement concepts which are used here.
+This section is intended for users who want to understand how the Model Optimizer performs Object Detection API models conversion in details. The knowledge given in this section is also useful for users having complex models that are not converted with the Model Optimizer out of the box. It is highly recommended to read the **Graph Transformation Extensions** section in the [Model Optimizer Extensibility](../../customize_model_optimizer/Customize_Model_Optimizer.md) documentation first to understand sub-graph replacement concepts which are used here.
 
 It is also important to open the model in the [TensorBoard](https://www.tensorflow.org/guide/summaries_and_tensorboard) to see the topology structure. Model Optimizer can create an event file that can be then fed to the TensorBoard* tool. Run the Model Optimizer with providing two command line parameters:
 * `--input_model <path_to_frozen.pb>` --- Path to the frozen model

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

@@ -1,8 +1,8 @@
-# Converting RetinaNet Model from TensorFlow* to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_RetinaNet_From_Tensorflow}
+# Converting TensorFlow RetinaNet Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_RetinaNet_From_Tensorflow}
 
 This tutorial explains how to convert RetinaNet model to the Intermediate Representation (IR).
 
-[Public RetinaNet model](https://github.com/fizyr/keras-retinanet) does not contain pretrained TensorFlow\* weights. 
+[Public RetinaNet model](https://github.com/fizyr/keras-retinanet) does not contain pretrained TensorFlow\* weights.
 To convert this model to the TensorFlow\* format, you can use [Reproduce Keras* to TensorFlow* Conversion tutorial](https://docs.openvino.ai/latest/omz_models_model_retinanet_tf.html).
 
 After you convert the model to TensorFlow* format, run the Model Optimizer command below:

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

@@ -1,13 +1,13 @@
-# Converting TensorFlow*-Slim Image Classification Model Library Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Slim_Library_Models}
+# Convert TensorFlow Slim Image Classification Model Library Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Slim_Library_Models}
 
-<a href="https://github.com/tensorflow/models/tree/master/research/slim/README.md">TensorFlow\*-Slim Image Classification Model Library</a> is a library to define, train and evaluate classification models in TensorFlow\*. The library contains Python scripts defining the classification topologies together with checkpoint files for several pre-trained classification topologies. To convert a TensorFlow\*-Slim library model, complete the following steps: 
+<a href="https://github.com/tensorflow/models/tree/master/research/slim/README.md">TensorFlow\*-Slim Image Classification Model Library</a> is a library to define, train and evaluate classification models in TensorFlow\*. The library contains Python scripts defining the classification topologies together with checkpoint files for several pre-trained classification topologies. To convert a TensorFlow\*-Slim library model, complete the following steps:
 
 1. Download the TensorFlow\*-Slim models [git repository](https://github.com/tensorflow/models).
 2. Download the pre-trained model [checkpoint](https://github.com/tensorflow/models/tree/master/research/slim#pre-trained-models).
 3. Export the inference graph.
 4. Convert the model using the Model Optimizer.
 
-The [Example of an Inception V1 Model Conversion](#example_of_an_inception_v1_model_conversion) section below illustrates the process of converting an Inception V1 Model. 
+The [Example of an Inception V1 Model Conversion](#example_of_an_inception_v1_model_conversion) section below illustrates the process of converting an Inception V1 Model.
 
 ## Example of an Inception V1 Model Conversion <a name="example_of_an_inception_v1_model_conversion"></a>
 This example demonstrates how to convert the model on Linux\* OSes, but it could be easily adopted for the Windows\* OSes.
@@ -39,7 +39,7 @@ python3 tf_models/research/slim/export_inference_graph.py \
 ```
 
 Model Optimizer comes with the summarize graph utility, which identifies graph input and output nodes. Run the utility to determine input/output nodes of the Inception V1 model:
-    
+
 ```sh
 python3 <PYTHON_SITE_PACKAGES>/openvino/tools/mo/utils/summarize_graph.py --input_model ./inception_v1_inference_graph.pb
 ```
@@ -66,7 +66,7 @@ Refer to the [Mean and Scale Values for TensorFlow\*-Slim Models](#tf_slim_mean_
 ## Mean and Scale Values for TensorFlow\*-Slim Models <a name="tf_slim_mean_scale_values"></a>
 The TensorFlow\*-Slim Models were trained with normalized input data. There are several different normalization algorithms used in the Slim library. OpenVINO classification sample does not perform image pre-processing except resizing to the input layer size. It is necessary to pass mean and scale values to the Model Optimizer so they are embedded into the generated IR in order to get correct classification results.
 
-The file [preprocessing_factory.py](https://github.com/tensorflow/models/blob/master/research/slim/preprocessing/preprocessing_factory.py) contains a dictionary variable `preprocessing_fn_map` defining mapping between the model type and pre-processing function to be used. The function code should be analyzed to figure out the mean/scale values. 
+The file [preprocessing_factory.py](https://github.com/tensorflow/models/blob/master/research/slim/preprocessing/preprocessing_factory.py) contains a dictionary variable `preprocessing_fn_map` defining mapping between the model type and pre-processing function to be used. The function code should be analyzed to figure out the mean/scale values.
 
 The [inception_preprocessing.py](https://github.com/tensorflow/models/blob/master/research/slim/preprocessing/inception_preprocessing.py) file defines the pre-processing function for the Inception models. The `preprocess_for_eval` function contains the following code:
 

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

@@ -1,4 +1,4 @@
-# Converting TensorFlow* Wide and Deep Family Models to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_WideAndDeep_Family_Models}
+# Convert TensorFlow Wide and Deep Family Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_WideAndDeep_Family_Models}
 
 The Wide and Deep models is a combination of wide and deep parts for memorization and generalization of object features respectively.
 These models can contain different types of object features such as numerical, categorical, sparse and sequential features. These feature types are specified
@@ -24,7 +24,7 @@ The Wide and Deep model is no longer in the master branch of the repository but
 
 **Step 2**. Train the model
 
-As the OpenVINO™ toolkit does not support the categorical with hash and crossed features, such feature types must be switched off in the model 
+As the OpenVINO™ toolkit does not support the categorical with hash and crossed features, such feature types must be switched off in the model
 by changing the `build_model_columns()` function in `census_dataset.py` as follows:
 
 ```python
@@ -61,7 +61,7 @@ def build_model_columns():
       age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])
   # Wide columns and deep columns.
   base_columns = [
-      education, marital_status, relationship, workclass, 
+      education, marital_status, relationship, workclass,
       age_buckets,
   ]
   crossed_columns = []
@@ -92,7 +92,7 @@ python census_main.py
 Use the following command line to convert the saved model file with the checkpoint:
 
 ```sh
- mo 
+ mo
 --input_checkpoint checkpoint --input_meta_graph model.ckpt.meta
 --input "IteratorGetNext:0[2],
          IteratorGetNext:1[2],
@@ -122,7 +122,7 @@ Use the following command line to convert the saved model file with the checkpoi
          dnn/input_from_feature_columns/input_layer/relationship_indicator/to_sparse_input/dense_shape:0[2]{i64}->[2 50],
          dnn/input_from_feature_columns/input_layer/workclass_indicator/to_sparse_input/indices:0[10 2]{i64},
          dnn/input_from_feature_columns/input_layer/workclass_indicator/hash_table_Lookup/LookupTableFindV2:0[10]{i64},
-         dnn/input_from_feature_columns/input_layer/workclass_indicator/to_sparse_input/dense_shape:0[2]{i64}->[2 50]" 
+         dnn/input_from_feature_columns/input_layer/workclass_indicator/to_sparse_input/dense_shape:0[2]{i64}->[2 50]"
 --output head/predictions/probabilities
 ```
 

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

@@ -1,4 +1,4 @@
-# Convert TensorFlow* XLNet Model to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_XLNet_From_Tensorflow}
+# Convert TensorFlow XLNet Model {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_XLNet_From_Tensorflow}
 
 Pre-trained models for XLNet (Bidirectional Encoder Representations from Transformers) are
 [publicly available](https://github.com/zihangdai/xlnet).
@@ -16,8 +16,8 @@ Download and unzip an archive with the [XLNet-Base, Cased](https://storage.googl
 
 After the archive is unzipped, the directory `cased_L-12_H-768_A-12` is created and contains the following files:
 * TensorFlow checkpoint (`xlnet_model.ckpt`) containing the pre-trained weights (which is actually 3 files)
-* sentence piece model (`spiece.model`) used for (de)tokenization 
+* sentence piece model (`spiece.model`) used for (de)tokenization
-* config file (`xlnet_config.json`) which specifies the hyperparameters of the model 
+* config file (`xlnet_config.json`) which specifies the hyperparameters of the model
 
 To get pb-file from the archive contents, you need to do the following.
 
@@ -33,7 +33,7 @@ To get pb-file from the archive contents, you need to do the following.
    mkdir try_save
 ```
 
-   
+
 
 2. Save and run the following Python script in `~/XLNet-Base/xlnet`:
 
@@ -102,8 +102,8 @@ Download and unzip an archive with the [XLNet-Large, Cased](https://storage.goog
 After the archive is unzipped, the directory `cased_L-12_H-1024_A-16` is created and contains the following files:
 
 * TensorFlow checkpoint (`xlnet_model.ckpt`) containing the pre-trained weights (which is actually 3 files)
-* sentence piece model (`spiece.model`) used for (de)tokenization 
+* sentence piece model (`spiece.model`) used for (de)tokenization
-* config file (`xlnet_config.json`) which specifies the hyperparameters of the model 
+* config file (`xlnet_config.json`) which specifies the hyperparameters of the model
 
 To get pb-file from the archive contents, you need to do the following.
 

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

@@ -1,7 +1,7 @@
-# Converting YOLO* Models to the Intermediate Representation (IR) {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow}
+# Convert TensorFlow YOLO Models {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow}
 
 This document explains how to convert real-time object detection YOLOv1\*, YOLOv2\*, YOLOv3\* and YOLOv4\* public models to the Intermediate Representation (IR). All YOLO\* models are originally implemented in the DarkNet\* framework and consist of two files:
-* `.cfg` file with model configurations  
+* `.cfg` file with model configurations
 * `.weights` file with model weights
 
 Depending on a YOLO model version, the Model Optimizer converts it differently:
@@ -37,7 +37,7 @@ python keras-YOLOv3-model-set/tools/model_converter/convert.py <path_to_cfg_file
 
 > **NOTE:** Before you run the conversion, make sure you have installed all the Model Optimizer dependencies for TensorFlow 2.
 ```sh
-mo --saved_model_dir yolov4 --output_dir models/IRs --input_shape [1,608,608,3] --model_name yolov4 
+mo --saved_model_dir yolov4 --output_dir models/IRs --input_shape [1,608,608,3] --model_name yolov4
 ```
 
 ## <a name="yolov3-to-ir"></a>Convert YOLOv3 Model to IR
@@ -115,7 +115,7 @@ It consists of several attributes:<br>
 where:
 - `id` and `match_kind` are parameters that you cannot change.
 - `custom_attributes` is a parameter that stores all the YOLOv3 specific attributes:
-    - `classes`, `coords`, `num`, and `masks` are attributes that you should copy from the configuration 
+    - `classes`, `coords`, `num`, and `masks` are attributes that you should copy from the configuration
     file that was used for model training. If you used DarkNet officially shared weights,
     you can use `yolov3.cfg` or `yolov3-tiny.cfg` configuration file from https://github.com/david8862/keras-YOLOv3-model-set/tree/master/cfg. Replace the default values in `custom_attributes` with the parameters that
     follow the `[yolo]` titles in the configuration file.
@@ -184,8 +184,8 @@ To convert YOLOv1 or YOLOv2 model to TensorFlow, go to the root directory of the
 python3 flow --model yolov1.cfg --load yolov1.weights --savepb
 ```
 
-- For YOLOv2 with VOC dataset `--labels` argument should be specified and additional changes in the original exporting script are required. 
+- For YOLOv2 with VOC dataset `--labels` argument should be specified and additional changes in the original exporting script are required.
-In the file [https://github.com/thtrieu/darkflow/blob/b187c65/darkflow/utils/loader.py#L121](https://github.com/thtrieu/darkflow/blob/b187c65630f9aa1bb8b809c33ec67c8cc5d60124/darkflow/utils/loader.py#L121) 
+In the file [https://github.com/thtrieu/darkflow/blob/b187c65/darkflow/utils/loader.py#L121](https://github.com/thtrieu/darkflow/blob/b187c65630f9aa1bb8b809c33ec67c8cc5d60124/darkflow/utils/loader.py#L121)
 change line 121 from `self.offset = 16` to `self.offset = 20`. Then run:
 ```sh
 python3 flow --model yolov2-voc.cfg --load yolov2-voc.weights --labels voc-labels.txt --savepb
@@ -204,7 +204,7 @@ File `<model_name>.pb` is a TensorFlow representation of the YOLO model.
 #### <a name="yolov1-v2-to-ir"></a>Convert TensorFlow YOLOv1 or YOLOv2 Model to the IR
 
 Converted TensorFlow YOLO model is missing `Region` layer and its parameters. Original YOLO `Region` layer parameters are stored in the configuration `<path_to_model>/<model_name>.cfg`
-file under the `[region]` title.   
+file under the `[region]` title.
 
 To recreate the original model structure, use the corresponding yolo `.json` configuration file with custom operations and `Region` layer
 parameters when converting the model to the IR. This file is located in the `<OPENVINO_INSTALL_DIR>/tools/model_optimizer/extensions/front/tf` directory.
@@ -223,7 +223,7 @@ To generate the IR of the YOLOv1 model, provide TensorFlow YOLOv1 or YOLOv2 mode
 where:
 
 * `--batch` defines shape of model input. In the example, `--batch` is equal to 1, but you can also specify other integers larger than 1.
-* `--scale` specifies scale factor that input values will be divided by. 
+* `--scale` specifies scale factor that input values will be divided by.
 The model was trained with input values in the range `[0,1]`. OpenVINO&trade; toolkit samples read input images as values in `[0,255]` range, so the scale 255 must be applied.
 * `--transformations_config` adds missing `Region` layers to the model. In the IR, the `Region` layer has name `RegionYolo`.
 For other applicable parameters, refer to [Convert Model from TensorFlow](../Convert_Model_From_TensorFlow.md).

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

@@ -1,4 +1,4 @@
-# Converting TensorFlow* Language Model on One Billion Word Benchmark to the Intermediate Representation {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_lm_1b_From_Tensorflow}
+# Convert TensorFlow Language Model on One Billion Word Benchmark {#openvino_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_lm_1b_From_Tensorflow}
 
 ## Download the Pre-trained Language Model on One Billion Word Benchmark
 
@@ -51,14 +51,14 @@ lm_1b/
         ckpt-char-embedding
         ckpt-lstm
         ckpt-softmax0
-        ckpt-softmax1        
+        ckpt-softmax1
-        ckpt-softmax2        
+        ckpt-softmax2
-        ckpt-softmax3        
+        ckpt-softmax3
-        ckpt-softmax4        
+        ckpt-softmax4
-        ckpt-softmax5        
+        ckpt-softmax5
-        ckpt-softmax6        
+        ckpt-softmax6
-        ckpt-softmax7        
+        ckpt-softmax7
-        ckpt-softmax8        
+        ckpt-softmax8
 ```
 
 

docs/MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md

@@ -10,7 +10,7 @@
 
 @endsphinxdirective
 
-<a name="model-optimizer-extensibility"></a>Model Optimizer extensibility mechanism enables support of new operations and custom transformations to generate the optimized intermediate representation (IR) as described in the 
+<a name="model-optimizer-extensibility"></a>Model Optimizer extensibility mechanism enables support of new operations and custom transformations to generate the optimized intermediate representation (IR) as described in the
 [Deep Learning Network Intermediate Representation and Operation Sets in OpenVINO™](../../IR_and_opsets.md). This
 mechanism is a core part of the Model Optimizer. The Model Optimizer itself uses it under the hood, being a huge set of examples on how to add custom logic to support your model.
 
@@ -144,7 +144,7 @@ OpenVINO&trade; [TopK](../../../ops/sort/TopK_3.md) operation semantic, which re
 
 It is important to mention that sometimes it seems like transformation cannot be implemented during the front phase
 because the actual values of inputs or shapes are needed. But in fact shapes or values manipulations can be implemented
-using operations that are added to the graph. Consider the 
+using operations that are added to the graph. Consider the
 `extensions/front/onnx/flattenONNX_to_reshape.py` transformation, which replaces an ONNX\* operation
 [Flatten](https://github.com/onnx/onnx/blob/master/docs/Operators.md#Flatten) with a sub-graph of operations performing
 the following (for the case when `axis` is not equal to 0 and 1):
@@ -260,7 +260,7 @@ More information on how to develop middle transformations and dedicated API desc
 
 There are several middle transformations responsible for changing model layout from NHWC to NCHW. These transformations are triggered by default for TensorFlow models as TensorFlow supports Convolution operations in the NHWC layout.
 
-This layout change is disabled automatically if the model does not have operations that OpenVINO&trade needs to execute in the NCHW layout, for example, Convolutions in NHWC layout. 
+This layout change is disabled automatically if the model does not have operations that OpenVINO&trade needs to execute in the NCHW layout, for example, Convolutions in NHWC layout.
 
 It is still possible to force Model Optimizer to do layout change, using `--disable_nhwc_to_nchw` command-line parameter, although it is not advised.
 
@@ -287,7 +287,7 @@ The back phase starts after the layout change to NCHW. This phase contains mostl
 
 1. Transformations that should work with a graph in the NCHW layout and thus cannot be implemented in the middle
 phase.
-2. Transformations that replace nodes corresponding to internal Model Optimizer operations with nodes corresponding to the 
+2. Transformations that replace nodes corresponding to internal Model Optimizer operations with nodes corresponding to the
 [opset](@ref openvino_docs_ops_opset) operations.
 3. Transformations that normalize operations inputs according to the specification.
 4. Final optimization transformations.
@@ -703,7 +703,7 @@ to enable or disable execution of the transformation during a model conversion.
 2. Attribute `id` specifies a unique transformation string identifier. This transformation identifier can be used to
 enable (disable) the transformation by setting environment variable `MO_ENABLED_TRANSFORMS` (`MO_DISABLED_TRANSFORMS`)
 with a comma separated list of `id`s. The environment variables override the value of the `enabled` attribute of the
-transformation. Instead of using `id` attribute value you can add fully defined class name to `MO_ENABLED_TRANSFORMS` 
+transformation. Instead of using `id` attribute value you can add fully defined class name to `MO_ENABLED_TRANSFORMS`
 (`MO_DISABLED_TRANSFORMS`) variable, `extensions.back.NonmalizeToNormalizeL2.NormalizeToNormalizeL2` for example. Optional attribute.
 3. Attribute `run_not_recursively` specifies whether the transformation should be executed in the sub-graphs, for
 example, body of the [TensorIterator](../../../ops/infrastructure/TensorIterator_1.md) and

docs/MO_DG/prepare_model/customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md

@@ -1,4 +0,0 @@
-# [DEPRECATED] Sub-Graph Replacement in the Model Optimizer  {#openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Subgraph_Replacement_Model_Optimizer}
-
-The document has been deprecated. Refer to the [Model Optimizer Extensibility](Customize_Model_Optimizer.md)
-for the up-to-date documentation.

docs/resources/resources.md

@@ -7,7 +7,7 @@
    :maxdepth: 1
    :hidden:
    :caption: Additional Resources
-   
+
    Release Notes <https://software.intel.com/content/www/us/en/develop/articles/openvino-relnotes.html>
    openvino_docs_IE_DG_supported_plugins_Supported_Devices
    openvino_docs_OV_Glossary
@@ -16,12 +16,17 @@
 
 .. toctree::
    :maxdepth: 1
-   :caption: Intermediate Representation and Operations Sets
+   :caption: Developer Documentation
    :hidden:
-    
+
+   openvino_docs_MO_DG_IR_and_opsets
    openvino_docs_ops_opset
    openvino_docs_ops_broadcast_rules
    openvino_docs_operations_specifications
+   openvino_docs_MO_DG_prepare_model_Supported_Frameworks_Layers
+   openvino_docs_MO_DG_prepare_model_Model_Optimization_Techniques
+   openvino_docs_MO_DG_prepare_model_convert_model_IR_suitable_for_INT8_inference
+   openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Customize_Model_Optimizer
 
 
 .. toctree::
@@ -39,14 +44,14 @@ This section includes a variety of reference information in three broad categori
 ### Additional Resources
 [Release Notes](https://software.intel.com/content/www/us/en/develop/articles/openvino-relnotes.html) contains change logs and notes for each OpenVINO release.
 
-[Supported Devices](OV_Runtime_UG/supported_plugins/Supported_Devices.md) is compatibility information about supported hardware accelerators.
+[Supported Devices](../OV_Runtime_UG/supported_plugins/Supported_Devices.md) is compatibility information about supported hardware accelerators.
 
-[Legal Information](Legal_Information.md) has trademark information and other legal statements.
+[Legal Information](../Legal_Information.md) has trademark information and other legal statements.
 
 ### Intermediate Representation and Operations Sets
-[Available Operation Sets](ops/opset.md) is a list of supported operations and explanation of supported capabilities.
+[Available Operation Sets](../ops/opset.md) is a list of supported operations and explanation of supported capabilities.
 
-[Broadcast Rules for Elementwise Operations](ops/broadcast_rules.md) explains the rules used for to support an arbitrary number of dimensions in neural nets.
+[Broadcast Rules for Elementwise Operations](../ops/broadcast_rules.md) explains the rules used for to support an arbitrary number of dimensions in neural nets.
 
 ### Case Studies
 Links to [articles](https://www.intel.com/openvino-success-stories) about real-world examples of OpenVINO™ usage.

tools/pot/docs/ModelRepresentation.md

@@ -1,14 +1,14 @@
 # Low-precision model representation {#pot_docs_model_representation}
 
 ## Introduction
-The goal of this document is to describe how optimized models are represented in OpenVINO Intermediate Representation (IR) and provide guidance on interpretation rules for such models at runtime. 
+The goal of this document is to describe how optimized models are represented in OpenVINO Intermediate Representation (IR) and provide guidance on interpretation rules for such models at runtime.
 Currently, there are two groups of optimization methods that can change the IR after applying them to the full-precision model:
 - **Sparsity**. It is represented by zeros inside the weights and this is up to the hardware plugin how to interpret these zeros (use weights as is or apply special compression algorithms and sparse arithmetic). No additional mask is provided with the model.
 - **Quantization**. The rest of this document is dedicated to the representation of quantized models.
 
 ## Representation of quantized models
-The OpenVINO Toolkit represents all the quantized models using the so-called [FakeQuantize](https://docs.openvino.ai/latest/openvino_docs_MO_DG_prepare_model_convert_model_Legacy_IR_Layers_Catalog_Spec.html#fakequantize-layer) operation. This operation is very expressive and allows mapping values from arbitrary input and output ranges. The whole idea behind that is quite simple: we project (discretize) the input values to the low-precision data type using affine transformation (with clamp and rounding) and then reproject discrete values back to the original range and data type. It can be considered as an emulation of the quantization/dequantization process which happens at runtime. The figure below shows a part of the DL model, namely the Convolutional layer, that undergoes various transformations on way from being a floating-point model to an integer model executed in the OpenVINO runtime. Column 2 of this figure below shows a model quantized with [Neural Network Compression Framework (NNCF)](https://github.com/openvinotoolkit/nncf).
+The OpenVINO Toolkit represents all the quantized models using the so-called [FakeQuantize](../../../docs/ops/quantization/FakeQuantize_1.md) operation. This operation is very expressive and allows mapping values from arbitrary input and output ranges. The whole idea behind that is quite simple: we project (discretize) the input values to the low-precision data type using affine transformation (with clamp and rounding) and then reproject discrete values back to the original range and data type. It can be considered as an emulation of the quantization/dequantization process which happens at runtime. The figure below shows a part of the DL model, namely the Convolutional layer, that undergoes various transformations on way from being a floating-point model to an integer model executed in the OpenVINO runtime. Column 2 of this figure below shows a model quantized with [Neural Network Compression Framework (NNCF)](https://github.com/openvinotoolkit/nncf).
-![](images/model_flow.png) 
+![](images/model_flow.png)
 
 To reduce memory footprint weights of quantized models are transformed to a target data type, e.g. in the case of 8-bit quantization, this is int8. During this transformation, the floating-point weights tensor and one of the FakeQuantize operations that correspond to it are replaced with 8-bit weight tensor and the sequence of Convert, Subtract, Multiply operations that represent the typecast and dequantization parameters (scale and zero-point) as it is shown in column 3 of the figure.
 
@@ -16,14 +16,14 @@ To reduce memory footprint weights of quantized models are transformed to a targ
 At inference time, the quantized model undergoes the second set of transformations that allows interpreting floating-point operations with quantization rules as integer operations. OpenVINO Deep Learning Deployment Toolkit has a special component which is called Low-Precision Transformations (LPT) for that purpose.
 At runtime each FakeQuantize can be split into two independent operations: **Quantize** and **Dequantize** (column 4). The former is aimed to transform the input data into the target precision while the latter transforms the resulting values back to the original range. *Dequantize* operations can be propagated forward through the linear layers, such as *Convolution* or *Fully-Connected*, and in some cases fused with the following *Quantize* operation for the next layer into the so-called *Requantize* operation (column 5).
 
-From the computation standpoint, the FakeQuantize formula also is split into two parts accordingly:  
+From the computation standpoint, the FakeQuantize formula also is split into two parts accordingly:
-`output = round((x - input_low) / (input_high - input_low) * (levels-1)) / (levels-1) * (output_high - output_low) + output_low`  
+`output = round((x - input_low) / (input_high - input_low) * (levels-1)) / (levels-1) * (output_high - output_low) + output_low`
-The first part of this fomula represents *Quantize* operation:  
+The first part of this fomula represents *Quantize* operation:
-`q = round((x - input_low) / (input_high - input_low) * (levels-1))`  
+`q = round((x - input_low) / (input_high - input_low) * (levels-1))`
-The second is responsible for the dequantization:  
+The second is responsible for the dequantization:
-`r = q / (levels-1) * (output_high - output_low) + output_low`  
+`r = q / (levels-1) * (output_high - output_low) + output_low`
-From the scale/zero-point notation standpoint the latter formula can be written as follows:  
+From the scale/zero-point notation standpoint the latter formula can be written as follows:
-`r = (output_high - output_low) / (levels-1) * (q + output_low / (output_high - output_low) * (levels-1))`  
+`r = (output_high - output_low) / (levels-1) * (q + output_low / (output_high - output_low) * (levels-1))`
 Thus we can define:
 - **Scale** as `(output_high - output_low) / (levels-1)`
 - **Zero-point** as `-output_low / (output_high - output_low) * (levels-1)`