Split Transformations between MOC and Common pipelines (#7580)

* Split Transformations between MOC and Common pipelines

* Test

* Split passes

* Fix int8 issue

* Small refactoring

inference-engine/ie_bridges/python/src/openvino/offline_transformations/offline_transformations_api_impl.cpp

@@ -5,13 +5,13 @@
 #include "offline_transformations_api_impl.hpp"
 
 #include <generate_mapping_file.hpp>
-#include <moc_transformations.hpp>
 #include <ngraph/opsets/opset6.hpp>
 #include <ngraph/pass/constant_folding.hpp>
 #include <ngraph/pass/low_latency.hpp>
 #include <ngraph/pass/manager.hpp>
 #include <pot_transformations.hpp>
 #include <pruning.hpp>
+#include <transformations/common_optimizations/moc_transformations.hpp>
 #include <transformations/control_flow/unroll_tensor_iterator.hpp>
 
 void InferenceEnginePython::ApplyMOCTransformations(InferenceEnginePython::IENetwork network, bool cf) {

inference-engine/src/transformations/include/transformations/common_optimizations/disable_random_uniform_constant_folding.hpp

@@ -5,12 +5,15 @@
 #pragma once
 
 #include <memory>
+
+#include <transformations_visibility.hpp>
+
 #include <ngraph/pass/graph_rewrite.hpp>
 
 namespace ngraph {
 namespace pass {
 
-class DisableRandomUniformConstantFolding;
+class TRANSFORMATIONS_API DisableRandomUniformConstantFolding;
 
 }  // namespace pass
 }  // namespace ngraph

inference-engine/src/transformations/include/transformations/common_optimizations/disable_shapeof_constant_folding.hpp

@@ -6,12 +6,14 @@
 
 #include <memory>
 
+#include <transformations_visibility.hpp>
+
 #include <ngraph/pass/graph_rewrite.hpp>
 
 namespace ngraph {
 namespace pass {
 
-class DisableShapeOfConstantFolding;
+class TRANSFORMATIONS_API DisableShapeOfConstantFolding;
 
 }  // namespace pass
 }  // namespace ngraph

inference-engine/src/transformations/include/transformations/common_optimizations/moc_transformations.hpp

@@ -6,12 +6,14 @@
 
 #include <memory>
 
+#include <transformations_visibility.hpp>
+
 #include <ngraph/pass/graph_rewrite.hpp>
 
 namespace ngraph {
 namespace pass {
 
-class MOCTransformations;
+class TRANSFORMATIONS_API MOCTransformations;
 
 }  // namespace pass
 }  // namespace ngraph
@@ -23,11 +25,20 @@ class MOCTransformations;
  */
 
 class ngraph::pass::MOCTransformations: public ngraph::pass::FunctionPass {
-    bool m_cf;
+    bool m_use_shapes;
+    bool m_low_precision_enabled;
 
 public:
     NGRAPH_RTTI_DECLARATION;
-    explicit MOCTransformations(bool cf) : m_cf(cf) {}
+    /**
+     * use_shapes = True enables transformations which are depends on shapes and also it
+     * enables ConstantFolding for all ShapeOf operations.
+     *
+     * low_precision_enabled = True enables preserving mechanisms that helps to keep
+     * low_precision sub-graphs as is.
+     */
+    explicit MOCTransformations(bool use_shapes, bool low_precision_enabled = true)
+        : m_use_shapes(use_shapes), m_low_precision_enabled(low_precision_enabled) {}
 
     bool run_on_function(std::shared_ptr<ngraph::Function>) override;
 };

inference-engine/src/transformations/src/transformations/common_optimizations/common_optimizations.cpp

@@ -84,6 +84,7 @@
 #include <transformations/common_optimizations/simplify_shape_of_sub_graph.hpp>
 #include <transformations/op_conversions/normalize_l2_decomposition.hpp>
 #include <transformations/op_conversions/softmax_decomposition.hpp>
+#include <transformations/common_optimizations/moc_transformations.hpp>
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::CommonOptimizations, "CommonOptimizations", 0);
 
@@ -91,63 +92,23 @@ bool ngraph::pass::CommonOptimizations::run_on_function(std::shared_ptr<ngraph::
     RUN_ON_FUNCTION_SCOPE(CommonOptimizations);
     ngraph::pass::Manager manager(get_pass_config());
 
-    // This pass must be called first in pipeline
+    // Disable low_precision_enabled as all plugins handle low-precision sub-graph manually
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    // before CommonOptimization pipeline execution
-    manager.register_pass<ngraph::pass::DisableRandomUniformConstantFolding>();
+    manager.register_pass<ngraph::pass::MOCTransformations>(true, false);
-    manager.register_pass<ngraph::pass::SimplifyShapeOfSubGraph>();
-    manager.register_pass<ngraph::pass::ConstantFolding>();
-    manager.register_pass<ngraph::pass::RemoveFilteringBoxesBySize>(); // Resolves dynamism (replaces NonZero), CF needed
-    manager.register_pass<ngraph::pass::ConvertNmsGatherPathToUnsigned>(); // workaround until dynamism in NMS is not supported
 
     // TODO: move to KMB
-    manager.register_pass<ngraph::pass::ConvertQuantizeDequantize>();
     manager.register_pass<ngraph::pass::WeightsDequantizeToFakeQuantize>();
 
-    manager.register_pass<ngraph::pass::ConstantFolding>();
-    manager.register_pass<ngraph::pass::StridedSliceOptimization>(); // depends on CF
-    manager.register_pass<ngraph::pass::BroadcastElementwiseFusion>();
-
-    auto transpose_sinking = manager.register_pass<ngraph::pass::GraphRewrite>();
-    transpose_sinking->add_matcher<ngraph::pass::TransposeSinking>();
-    // SplitSqueezeConcatFusion should work in same GraphRewrite as TransposesSinking,
-    // because it replaces pattern that may contain Transposes which must be optimized before
-    // the transformation and it also inserts Transpose that can be optimized by TransposeSinking
-    transpose_sinking->add_matcher<ngraph::pass::SplitSqueezeConcatFusion>();
-
-    auto eliminations = manager.register_pass<ngraph::pass::GraphRewrite>();
-    eliminations->add_matcher<ngraph::pass::EliminateUnsqueezeGather>();
-    eliminations->add_matcher<ngraph::pass::NopElimination>(); // may introduce fake dynamism
-    eliminations->set_name("ngraph::pass::CommonEliminations");
-
-    manager.register_pass<ngraph::pass::ConstantFolding>();
-
     auto common_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
-    common_fusions->add_matcher<ngraph::pass::ConvertScatterElementsToScatter>();
     common_fusions->add_matcher<ngraph::pass::DepthToSpaceFusion>();
-    common_fusions->add_matcher<ngraph::pass::SoftPlusFusion>();
-    common_fusions->add_matcher<ngraph::pass::SoftPlusToMishFusion>();
-    common_fusions->add_matcher<ngraph::pass::SwishFusion>();
     common_fusions->add_matcher<ngraph::pass::ShuffleChannelsFusion>(false);
-    common_fusions->add_matcher<ngraph::pass::HSwishFusion>();
-    common_fusions->add_matcher<ngraph::pass::HSigmoidFusion>();
-    common_fusions->add_matcher<ngraph::pass::NormalizeL2Fusion>();
-    common_fusions->add_matcher<ngraph::pass::ClampFusion>();
-    common_fusions->add_matcher<ngraph::pass::PadFusion>();
-    common_fusions->add_matcher<ngraph::pass::SoftmaxFusion>();
-    common_fusions->add_matcher<ngraph::pass::MVNFusion>();
     common_fusions->add_matcher<ngraph::pass::SpaceToBatchFusion>();
     common_fusions->add_matcher<ngraph::pass::BatchToSpaceFusion>();
-    common_fusions->add_matcher<ngraph::pass::DilatedConvolutionConverter>();
-    common_fusions->add_matcher<ngraph::pass::GeluFusion>();
     common_fusions->add_matcher<ngraph::pass::TransposeToReshape>();
-    common_fusions->add_matcher<ngraph::pass::LeakyReluFusion>();
-    common_fusions->add_matcher<ngraph::pass::RandomUniformFusion>();
     common_fusions->set_name("ngraph::pass::CommonFusions");
 
     manager.register_pass<ngraph::pass::ConvertPadToGroupConvolution, false>();
     manager.register_pass<ngraph::pass::ConvertInterpolate1ToInterpolate4, false>();
-    manager.register_pass<ngraph::pass::BinarizeWeights>();
-    manager.register_pass<ngraph::pass::ConvToBinaryConv>();
 
     auto decomp = manager.register_pass<ngraph::pass::GraphRewrite>();
     decomp->add_matcher<ngraph::pass::Gelu7Downgrade>();

inference-engine/src/transformations/src/transformations/common_optimizations/disable_shapeof_constant_folding.cpp

@@ -3,16 +3,13 @@
 //
 
 #include <memory>
-#include <ostream>
-#include <fstream>
 
 #include <ngraph/pattern/op/wrap_type.hpp>
 #include <ngraph/opsets/opset2.hpp>
 #include <ngraph/opsets/opset3.hpp>
-#include <ngraph/variant.hpp>
 #include <transformations/rt_info/disable_constant_folding.hpp>
 
-#include "disable_shapeof_constant_folding.hpp"
+#include <transformations/common_optimizations/disable_shapeof_constant_folding.hpp>
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::DisableShapeOfConstantFolding, "DisableShapeOfConstantFolding", 0);
 

inference-engine/src/transformations/src/transformations/common_optimizations/moc_transformations.cpp

@@ -4,8 +4,8 @@
 
 #include <memory>
 
-#include "moc_transformations.hpp"
+#include <transformations/common_optimizations/moc_transformations.hpp>
-#include "disable_shapeof_constant_folding.hpp"
+#include <transformations/common_optimizations/disable_shapeof_constant_folding.hpp>
 
 #include <ngraph/pass/manager.hpp>
 #include <ngraph/pass/constant_folding.hpp>
@@ -40,7 +40,14 @@
 #include <transformations/common_optimizations/normalize_l2_fusion.hpp>
 #include <transformations/common_optimizations/random_uniform_fusion.hpp>
 #include <transformations/common_optimizations/softmax_fusion.hpp>
-#include "transformations/common_optimizations/mul_conv_fusion.hpp"
+#include <transformations/common_optimizations/disable_random_uniform_constant_folding.hpp>
+#include <transformations/common_optimizations/optimize_strided_slice.hpp>
+#include <transformations/common_optimizations/depth_to_space_fusion.hpp>
+#include <transformations/common_optimizations/shuffle_channels_fusion.hpp>
+#include <transformations/common_optimizations/space_to_batch_fusion.hpp>
+#include <transformations/common_optimizations/transpose_to_reshape.hpp>
+#include <transformations/common_optimizations/batch_to_space_fusion.hpp>
+#include <transformations/common_optimizations/mul_conv_fusion.hpp>
 
 NGRAPH_RTTI_DEFINITION(ngraph::pass::MOCTransformations, "MOCTransformations", 0);
 
@@ -48,25 +55,41 @@ bool ngraph::pass::MOCTransformations::run_on_function(std::shared_ptr<ngraph::F
     // To avoid issues with dynamism we make nGraph Function dynamic and after we apply all
     // transformations we restore original shapes to the nGraph Function back
     std::unordered_map<ngraph::op::Parameter*, PartialShape> input_shapes;
-    for (auto && param : f->get_parameters()) {
+    if (!m_use_shapes) {
+        for (auto &&param : f->get_parameters()) {
             input_shapes[param.get()] = param->get_partial_shape();
             param->set_partial_shape(PartialShape::dynamic(param->get_partial_shape().rank()));
         }
         f->validate_nodes_and_infer_types();
+    }
 
     ngraph::pass::Manager manager(get_pass_config());
 
     manager.register_pass<ngraph::pass::InitNodeInfo>();
+    if (m_low_precision_enabled) {
         manager.register_pass<ngraph::pass::DisableConvertConstantFoldingOnConstPath>(
                 element::TypeVector{ ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4 });
+    }
+    if (!m_use_shapes) {
         manager.register_pass<ngraph::pass::DisableShapeOfConstantFolding>();
+    }
+    manager.register_pass<ngraph::pass::DisableRandomUniformConstantFolding>();
     manager.register_pass<ngraph::pass::ConstantFolding>();
     manager.register_pass<ngraph::pass::RemoveFilteringBoxesBySize>();
     manager.register_pass<ngraph::pass::ConvertQuantizeDequantize>();
     manager.register_pass<ngraph::pass::SimplifyShapeOfSubGraph>();
+    if (!m_use_shapes) {
+        manager.register_pass<ngraph::pass::DisableShapeOfConstantFolding>();
+    }
     // workaround until dynamism in NMS is not supported
     manager.register_pass<ngraph::pass::ConvertNmsGatherPathToUnsigned>();
 
+    if (m_use_shapes) {
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+    }
+
+    manager.register_pass<ngraph::pass::BroadcastElementwiseFusion>();
+
     auto transpose_sinking = manager.register_pass<ngraph::pass::GraphRewrite>();
     transpose_sinking->add_matcher<ngraph::pass::TransposeSinking>();
     // SplitSqueezeConcatFusion should work in same GraphRewrite as TransposesSinking,
@@ -76,12 +99,13 @@ bool ngraph::pass::MOCTransformations::run_on_function(std::shared_ptr<ngraph::F
 
     auto eliminations = manager.register_pass<ngraph::pass::GraphRewrite>();
     eliminations->add_matcher<ngraph::pass::EliminateUnsqueezeGather>();
-    eliminations->add_matcher<ngraph::pass::NopElimination>(false /* do not use shape for elimination */);
+    eliminations->add_matcher<ngraph::pass::NopElimination>(m_use_shapes /* do not use shape for elimination */);
     eliminations->set_name("ngraph::pass::CommonEliminations");
 
+    manager.register_pass<ngraph::pass::ConstantFolding>();
+
     auto common_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
     common_fusions->add_matcher<ngraph::pass::ConvertScatterElementsToScatter>();
-    common_fusions->add_matcher<ngraph::pass::BroadcastElementwiseFusion>();
     common_fusions->add_matcher<ngraph::pass::SoftPlusFusion>();
     common_fusions->add_matcher<ngraph::pass::SoftPlusToMishFusion>();
     common_fusions->add_matcher<ngraph::pass::SwishFusion>();
@@ -117,13 +141,17 @@ bool ngraph::pass::MOCTransformations::run_on_function(std::shared_ptr<ngraph::F
     conv_fusions->add_matcher<ngraph::pass::MultiplyGroupConvolutionBackpropDataFusion>();
     conv_fusions->set_name("ngraph::pass::ConvFusions");
 
+    manager.register_pass<ngraph::pass::ConstantFolding>();
+
     manager.run_passes(f);
 
+    if (!m_use_shapes) {
         // Restore original shapes to the nGraph Function
-    for (auto && param : f->get_parameters()) {
+        for (auto &&param : f->get_parameters()) {
             param->set_partial_shape(input_shapes.at(param.get()));
         }
         f->validate_nodes_and_infer_types();
+    }
 
     return false;
 }

inference-engine/tests/functional/inference_engine/transformations/disable_shapeof_constant_folding_tests.cpp

@@ -13,7 +13,7 @@
 #include <ngraph/pass/manager.hpp>
 #include <ngraph/pass/constant_folding.hpp>
 
-#include <disable_shapeof_constant_folding.hpp>
+#include <transformations/common_optimizations/disable_shapeof_constant_folding.hpp>
 #include <transformations/serialize.hpp>
 
 #include "common_test_utils/ngraph_test_utils.hpp"

model-optimizer/mo/utils/check_ie_bindings.py

@@ -98,7 +98,7 @@ def import_core_modules(silent: bool, path_to_module: str):
         return True
     except Exception as e:
         # Do not print a warning if module wasn't found or silent mode is on
-        if "No module named 'openvino'" not in str(e) and not silent:
+        if "No module named 'openvino'" not in str(e):
             print("[ WARNING ] Failed to import Inference Engine Python API in: {}".format(path_to_module))
             print("[ WARNING ] {}".format(e))