IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Core/CC]Verify add_matcher scope for Conditinal Compilation. (#13148)

Browse Source 
* My verification:
libopenvino.so original size: 10799560
After adding this patch, new size: 10684744

Reduce: (10799560 - 10684744)/1024.0 = 112.125K.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* try to fix clang issue

* Merge xuejun/cc_test

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Test

Signed-off-by: xuejun <Xuejun.Zhai@intel.com>

* TEST1

Signed-off-by: xuejun <Xuejun.Zhai@intel.com>

* TEST2

Signed-off-by: xuejun <Xuejun.Zhai@intel.com>

* Complete Add_matcher wraper.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* register_pass rebase

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* fix clang issue.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* fix some replace error.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* 1: Rename ADD_MATCHER_SCOPE_WITH_OBJ -> ADD_MATCHER_SCOPE;
2: Remove debug info;
3: Fix bug: REGISTER_PASS_WITH_FALSE_

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Add ADD_MATCHER_SCOPE_WITHOUT_NSPACE macro

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* fix macro define issue.

* Add register_pass for cnn_network_ngraph_impl.cpp

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Try to fix vpux plugin fail issue.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Fix clang issue

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Merge macro "REGISTER_PASS_MODEL_SCOPE" and "REGISTER_PASS_FUNCTION_SCOPE" to "REGISTER_PASS_SCOPE"

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Rename "REGISTER_PASS_SCOPE_WITH_FALSE" to "REGISTER_DISABLED_PASS_SCOPE_WITH"

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Rename ADD_MATCHER_SCOPE_WITHOUT_OBJ to ADD_MATCHER_SCOPE_FOR_THIS
ADD_MATCHER_SCOPE_WITHOUT_NSPACE to ADD_MATCHER_SCOPE_FOR_THIS_WITHOUT_NSPACE

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* In order to implement CC, I have to move "StridesOptimization()" constructor to cpp file.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Remove "SCOPE" in macro.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Recover changes to fix clang issue.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Remove "REGISTER_PASS_MODEL_IF"

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* 1: Remove "ADD_MATCHER_FOR_THIS_WITHOUT_NSPACE";
2: Remove param "nspace" in Macro, replace with "using namespace " in local.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* fix missing update.

* For MACRO REGISTER_PASS:
1: Only keep a external macro define;
2: Judge 3 possibilities, if one of them is true, it will be disable;

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Optimize ADD_MATCHER_FOR_THIS.
-#    define ADD_MATCHER_FOR_THIS(region, ...)        add_matcher<region>(__VA_ARGS__);
+#    define ADD_MATCHER_FOR_THIS(region, ...)        ADD_MATCHER(this, region, __VA_ARGS__)

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp

Co-authored-by: Ilya Churaev <ilyachur@gmail.com>

* Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp

Co-authored-by: Ilya Churaev <ilyachur@gmail.com>

* Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp

Co-authored-by: Ilya Churaev <ilyachur@gmail.com>

* Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp

Co-authored-by: Ilya Churaev <ilyachur@gmail.com>

* clang format

* Update OR defiation in MACRO, increasing code scalability.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

* Fix window compiles error.

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>

Signed-off-by: Yan, Xiping <xiping.yan@intel.com>
Signed-off-by: xuejun <Xuejun.Zhai@intel.com>
Co-authored-by: xuejun <Xuejun.Zhai@intel.com>
Co-authored-by: Ilya Churaev <ilyachur@gmail.com>
This commit is contained in:
Xiping Yan
2022-11-21 00:02:42 +08:00
committed by GitHub
parent 80b9a5eeae
commit 2a7dc5404b
18 changed files with 371 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp
View File

@@ -21,6 +21,9 @@ OV_CC_DOMAINS(ov_pass);
# define MATCHER_SCOPE(region) const std::string matcher_name(OV_PP_TOSTRING(region))
# define RUN_ON_MODEL_SCOPE(region) OV_SCOPE(ov_pass, OV_PP_CAT(region, _run_on_model))
# define ADD_MATCHER(obj, region, ...) obj->add_matcher<region>(__VA_ARGS__);
# define REGISTER_PASS(obj, region, ...) obj.register_pass<region>(__VA_ARGS__);
# define REGISTER_DISABLED_PASS(obj, region, ...) obj.register_pass<region, false>(__VA_ARGS__);
#elif defined(SELECTIVE_BUILD)
# define MATCHER_SCOPE_(scope, region) \
@@ -35,9 +38,47 @@ OV_CC_DOMAINS(ov_pass);
# define RUN_ON_MODEL_SCOPE(region) MATCHER_SCOPE_(ov_pass, OV_PP_CAT(region, _run_on_model))
# define ADD_MATCHER_OBJ_1(obj, region, ...) obj->add_matcher<region>(__VA_ARGS__);
# define ADD_MATCHER_OBJ_0(obj, region, ...)
# define ADD_MATCHER(obj, region, ...) \
OV_PP_CAT(ADD_MATCHER_OBJ_, OV_CC_SCOPE_IS_ENABLED(OV_PP_CAT3(ov_pass, _, region))) \
(obj, region, __VA_ARGS__)
# define REGISTER_PASS_1(obj, region, ...) obj.register_pass<region>(__VA_ARGS__);
# define REGISTER_PASS_0(obj, region, ...)
# define PASS_DEFAULT(region) OV_CC_SCOPE_IS_ENABLED(OV_PP_CAT3(ov_pass, _, region))
# define PASS_RUN_ON_MODEL(region) OV_CC_SCOPE_IS_ENABLED(OV_PP_CAT3(ov_pass, _, OV_PP_CAT(region, _run_on_model)))
# define PASS_RUN_ON_FUNCTION(region) \
OV_CC_SCOPE_IS_ENABLED(OV_PP_CAT3(ov_pass, _, OV_PP_CAT(region, _run_on_function)))
# define OV_PP_FIRST_ARG(...) OV_PP_EXPAND(OV_PP_FIRST_ARG_(__VA_ARGS__, 0))
# define OV_PP_FIRST_ARG_(...) OV_PP_EXPAND(OV_PP_FIRST_ARG_GET(__VA_ARGS__))
# define OV_PP_FIRST_ARG_GET(val, ...) val
# define OV_OR_ARG_PLACEHOLDER_1 1,
# define OV_OR_ARG_PLACEHOLDER_0
# define OV_OR_(arg1_or_junk, arg2_or_junk) OV_PP_FIRST_ARG(arg1_or_junk arg2_or_junk 0)
# define OV_OR_2(x, y) OV_OR_(OV_PP_CAT(OV_OR_ARG_PLACEHOLDER_, x), OV_PP_CAT(OV_OR_ARG_PLACEHOLDER_, y))
# define OV_OR_3(x, y, z) OV_OR_2(OV_OR_2(x, y), z)
# define REGISTER_PASS(obj, region, ...) \
OV_PP_CAT(REGISTER_PASS_, \
OV_OR_3(PASS_DEFAULT(region), PASS_RUN_ON_MODEL(region), PASS_RUN_ON_FUNCTION(region))) \
(obj, region, __VA_ARGS__)
# define REGISTER_PASS_WITH_FALSE_1(obj, ...) obj.register_pass<region, false>(__VA_ARGS__);
# define REGISTER_PASS_WITH_FALSE_0(obj, ...)
# define REGISTER_DISABLED_PASS(obj, region, ...) \
OV_PP_CAT(REGISTER_PASS_WITH_FALSE_, OV_CC_SCOPE_IS_ENABLED(OV_PP_CAT3(ov_pass, _, region))) \
(obj, region, __VA_ARGS__)
#else
# define MATCHER_SCOPE(region) const std::string matcher_name(OV_PP_TOSTRING(region))
# define RUN_ON_FUNCTION_SCOPE(region)
# define RUN_ON_MODEL_SCOPE(region)
# define ADD_MATCHER(obj, region, ...) obj->add_matcher<region>(__VA_ARGS__);
# define REGISTER_PASS(obj, region, ...) obj.register_pass<region>(__VA_ARGS__);
# define REGISTER_DISABLED_PASS(obj, region, ...) obj.register_pass<region, false>(__VA_ARGS__);
#endif
#define ADD_MATCHER_FOR_THIS(region, ...) ADD_MATCHER(this, region, __VA_ARGS__)

107
src/common/low_precision_transformations/src/low_precision.cpp
View File

@@ -74,15 +74,14 @@
#include "low_precision/move_fake_quantize.hpp"
// cleanup transformations
#include "itt.hpp"
#include "low_precision/convert.hpp"
#include "low_precision/fold_fake_quantize.hpp"
#include "low_precision/fuse_convert.hpp"
#include "low_precision/fuse_subtract_to_fake_quantize.hpp"
#include "low_precision/fuse_multiply_to_fake_quantize.hpp"
#include "low_precision/fuse_subtract_to_fake_quantize.hpp"
#include "low_precision/multiply_to_group_convolution.hpp"
#include "itt.hpp"
ngraph::pass::low_precision::LowPrecision::LowPrecision(
const std::vector<PrecisionsRestriction>& precisionRestrictions,
const std::vector<QuantizationGranularityRestriction>& quantizationRestrictions,
@@ -200,62 +199,70 @@ bool ngraph::pass::low_precision::LowPrecision::run_on_model(const std::shared_p
auto prerequisites = manager.register_pass<ngraph::pass::GraphRewrite>();
const std::vector<ngraph::element::Type> supportedTypes = {ngraph::element::i8, ngraph::element::u8};
prerequisites->add_matcher<PullReshapeThroughDequantization>(supportedTypes);
prerequisites->add_matcher<PullTransposeThroughDequantization>(supportedTypes);
prerequisites->add_matcher<ngraph::pass::LinOpSequenceFusion>();
prerequisites->add_matcher<ngraph::pass::low_precision::MoveFakeQuantize>();
ADD_MATCHER(prerequisites, PullReshapeThroughDequantization, supportedTypes)
ADD_MATCHER(prerequisites, PullTransposeThroughDequantization, supportedTypes)
using namespace ngraph::pass;
using namespace ngraph::pass::low_precision;
ADD_MATCHER(prerequisites, LinOpSequenceFusion)
ADD_MATCHER(prerequisites, MoveFakeQuantize)
manager.register_pass<TypeRelaxedReplacer>();
AttributeParameters attributeParams(params.deqPrecision, params.defaultPrecisions);
manager.register_pass<ngraph::pass::low_precision::MarkupOptimizations>(precisionRestrictions, quantizationRestrictions, attributeParams);
manager.register_pass<ngraph::pass::low_precision::MarkupOptimizations>(precisionRestrictions,
quantizationRestrictions,
attributeParams);
std::shared_ptr<ngraph::pass::GraphRewrite> common = manager.register_pass<ngraph::pass::GraphRewrite>();
common->add_matcher<ngraph::pass::low_precision::AddTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::AssignAndReadValueTransformation>(f, params);
common->add_matcher<ngraph::pass::low_precision::AvgPoolTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ClampTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ConcatTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ConvolutionTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ConvolutionBackpropDataTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::DepthToSpaceTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::FakeQuantizeDecompositionTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::FakeQuantizeTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::InterpolateTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::GroupConvolutionTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::MatMulTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::MaxPoolTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::MultiplyTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::MVNTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::NormalizeL2Transformation>(params);
common->add_matcher<ngraph::pass::low_precision::PadTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::PReluTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::RecurrentCellTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ReduceMaxTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ReduceMeanTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ReduceMinTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ReduceSumTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ReluTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ReshapeTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::SqueezeTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::ShuffleChannelsTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::SplitTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::StridedSliceTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::TransposeTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::UnsqueezeTransformation>(params);
common->add_matcher<ngraph::pass::low_precision::VariadicSplitTransformation>(params);
ADD_MATCHER(common, AddTransformation, params)
ADD_MATCHER(common, AssignAndReadValueTransformation, f, params)
ADD_MATCHER(common, AvgPoolTransformation, params)
ADD_MATCHER(common, ClampTransformation, params)
ADD_MATCHER(common, ConcatTransformation, params)
ADD_MATCHER(common, ConvolutionTransformation, params)
ADD_MATCHER(common, ConvolutionBackpropDataTransformation, params)
ADD_MATCHER(common, DepthToSpaceTransformation, params)
ADD_MATCHER(common, FakeQuantizeDecompositionTransformation, params)
ADD_MATCHER(common, FakeQuantizeTransformation, params)
ADD_MATCHER(common, InterpolateTransformation, params)
ADD_MATCHER(common, GroupConvolutionTransformation, params)
ADD_MATCHER(common, MatMulTransformation, params)
ADD_MATCHER(common, MaxPoolTransformation, params)
ADD_MATCHER(common, MultiplyTransformation, params)
ADD_MATCHER(common, MVNTransformation, params)
ADD_MATCHER(common, NormalizeL2Transformation, params)
ADD_MATCHER(common, PadTransformation, params)
ADD_MATCHER(common, PReluTransformation, params)
ADD_MATCHER(common, RecurrentCellTransformation, params)
ADD_MATCHER(common, ReduceMaxTransformation, params)
ADD_MATCHER(common, ReduceMeanTransformation, params)
ADD_MATCHER(common, ReduceMinTransformation, params)
ADD_MATCHER(common, ReduceSumTransformation, params)
ADD_MATCHER(common, ReluTransformation, params)
ADD_MATCHER(common, ReshapeTransformation, params)
ADD_MATCHER(common, SqueezeTransformation, params)
ADD_MATCHER(common, ShuffleChannelsTransformation, params)
ADD_MATCHER(common, SplitTransformation, params)
ADD_MATCHER(common, StridedSliceTransformation, params)
ADD_MATCHER(common, TransposeTransformation, params)
ADD_MATCHER(common, UnsqueezeTransformation, params)
ADD_MATCHER(common, VariadicSplitTransformation, params)
std::shared_ptr<ngraph::pass::GraphRewrite> cleanup = manager.register_pass<ngraph::pass::GraphRewrite>();
cleanup->add_matcher<ngraph::pass::low_precision::FoldConvertTransformation>(params);
cleanup->add_matcher<ngraph::pass::low_precision::FuseConvertTransformation>(params);
cleanup->add_matcher<ngraph::pass::low_precision::FuseSubtractToFakeQuantizeTransformation>(params);
cleanup->add_matcher<ngraph::pass::low_precision::FuseMultiplyToFakeQuantizeTransformation>(params);
ADD_MATCHER(cleanup, FoldConvertTransformation, params)
ADD_MATCHER(cleanup, FuseConvertTransformation, params)
ADD_MATCHER(cleanup, FuseSubtractToFakeQuantizeTransformation, params)
ADD_MATCHER(cleanup, FuseMultiplyToFakeQuantizeTransformation, params)
// WA: precision restrictions for groupConv must be propagated to MultiplyToGroupConvolution transformation
cleanup->add_matcher<ngraph::pass::low_precision::MultiplyToGroupConvolutionTransformation>(
params,
PrecisionsRestriction::getPrecisionsByOperationType<opset1::GroupConvolution>(precisionRestrictions));
manager.register_pass<ngraph::pass::low_precision::FoldFakeQuantizeTransformation>(params);
manager.register_pass<ngraph::pass::ConstantFolding>();
ADD_MATCHER(cleanup,
MultiplyToGroupConvolutionTransformation,
params,
PrecisionsRestriction::getPrecisionsByOperationType<opset1::GroupConvolution>(precisionRestrictions))
REGISTER_PASS(manager, FoldFakeQuantizeTransformation, params)
REGISTER_PASS(manager, ConstantFolding)
manager.run_passes(f);
return false;

6
src/common/transformations/include/transformations/common_optimizations/strides_optimization.hpp
View File

@@ -64,11 +64,7 @@ public:
class ov::pass::StridesOptimization : public ov::pass::BackwardGraphRewrite {
public:
OPENVINO_RTTI("StridesOptimization", "0");
StridesOptimization() {
add_matcher<ov::pass::ConvStridesPropagation>();
add_matcher<ov::pass::SupportedNodesStridesPropagation>();
add_matcher<ov::pass::UnsupportedNodesStridesPropagation>();
}
StridesOptimization();
};
namespace ngraph {

154
src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp
View File

@@ -112,117 +112,115 @@ bool ov::pass::CommonOptimizations::run_on_model(const std::shared_ptr<ngraph::F
ngraph::pass::Manager manager(get_pass_config());
manager.set_per_pass_validation(false);
manager.register_pass<ov::pass::DisableDecompressionConvertConstantFolding>();
using namespace ngraph::pass;
using namespace ov::pass;
REGISTER_PASS(manager, DisableDecompressionConvertConstantFolding)
// Disable low_precision_enabled as all plugins handle low-precision sub-graph manually
// before CommonOptimization pipeline execution
manager.register_pass<ngraph::pass::MOCTransformations>(true, false);
REGISTER_PASS(manager, MOCTransformations, true, false)
// Enabling conversion of FP16 IR to legacy representation, each plugin have to disable it
// after support for FP16 IR is implemented
manager.register_pass<ov::pass::ConvertCompressedOnlyToLegacy>();
manager.register_pass<ov::pass::MarkPrecisionSensitiveDivides>();
// TODO: move to KMB
manager.register_pass<ngraph::pass::WeightsDequantizeToFakeQuantize>();
REGISTER_PASS(manager, ConvertCompressedOnlyToLegacy)
REGISTER_PASS(manager, MarkPrecisionSensitiveDivides)
REGISTER_PASS(manager, WeightsDequantizeToFakeQuantize)
auto common_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
common_fusions->add_matcher<ngraph::pass::SpaceToBatchFusion>();
common_fusions->add_matcher<ngraph::pass::BatchToSpaceFusion>();
common_fusions->add_matcher<ngraph::pass::InterpolateSequenceFusion>();
common_fusions->add_matcher<ngraph::pass::SkipGatherBeforeTransposeAndReshape>();
common_fusions->add_matcher<ngraph::pass::ReduceMerge>();
ADD_MATCHER(common_fusions, SpaceToBatchFusion)
ADD_MATCHER(common_fusions, BatchToSpaceFusion)
ADD_MATCHER(common_fusions, InterpolateSequenceFusion)
ADD_MATCHER(common_fusions, SkipGatherBeforeTransposeAndReshape)
ADD_MATCHER(common_fusions, ReduceMerge)
common_fusions->set_name("ngraph::pass::CommonFusions");
manager.register_pass<ngraph::pass::ConcatReduceFusion>();
manager.register_pass<ngraph::pass::ConvertPadToGroupConvolution, false>();
manager.register_pass<ngraph::pass::ConvertInterpolate1ToInterpolate4, false>();
REGISTER_DISABLED_PASS(manager, ConvertPadToGroupConvolution)
REGISTER_DISABLED_PASS(manager, ConvertInterpolate1ToInterpolate4)
auto decomp = manager.register_pass<ngraph::pass::GraphRewrite>();
decomp->add_matcher<ngraph::pass::Gelu7Downgrade>();
decomp->add_matcher<ngraph::pass::BidirectionalSequenceDecomposition>();
decomp->add_matcher<ngraph::pass::ReduceL1Decomposition>();
decomp->add_matcher<ngraph::pass::ReduceL2Decomposition>();
decomp->add_matcher<ngraph::pass::HSwishDecomposition>();
decomp->add_matcher<ngraph::pass::HSigmoidDecomposition>();
decomp->add_matcher<ngraph::pass::LogSoftmaxDecomposition>();
decomp->add_matcher<ngraph::pass::ConvertReduceToPooling>();
decomp->add_matcher<ngraph::pass::ConvertBroadcastToTiles>();
decomp->add_matcher<ngraph::pass::ConvertMod>();
decomp->add_matcher<ngraph::pass::ConvertGELU>();
decomp->add_matcher<ngraph::pass::ConvertMinimum>();
decomp->add_matcher<ngraph::pass::ConvertSubtract>();
decomp->add_matcher<ngraph::pass::ConvertDivide>();
decomp->add_matcher<ngraph::pass::ConvertDepthToSpace>();
decomp->add_matcher<ngraph::pass::ConvertSpaceToDepth>();
decomp->add_matcher<ngraph::pass::ConvertConvertLike>();
decomp->add_matcher<ngraph::pass::BatchNormDecomposition>();
decomp->add_matcher<ngraph::pass::MVN6Decomposition>();
ADD_MATCHER(decomp, Gelu7Downgrade)
ADD_MATCHER(decomp, BidirectionalSequenceDecomposition)
ADD_MATCHER(decomp, ReduceL1Decomposition)
ADD_MATCHER(decomp, ReduceL2Decomposition)
ADD_MATCHER(decomp, HSwishDecomposition)
ADD_MATCHER(decomp, HSigmoidDecomposition)
ADD_MATCHER(decomp, LogSoftmaxDecomposition)
ADD_MATCHER(decomp, ConvertReduceToPooling)
ADD_MATCHER(decomp, ConvertBroadcastToTiles)
ADD_MATCHER(decomp, ConvertMod)
ADD_MATCHER(decomp, ConvertGELU)
ADD_MATCHER(decomp, ConvertMinimum)
ADD_MATCHER(decomp, ConvertSubtract)
ADD_MATCHER(decomp, ConvertDivide)
ADD_MATCHER(decomp, ConvertDepthToSpace)
ADD_MATCHER(decomp, ConvertSpaceToDepth)
ADD_MATCHER(decomp, ConvertConvertLike)
ADD_MATCHER(decomp, BatchNormDecomposition)
ADD_MATCHER(decomp, MVN6Decomposition)
decomp->add_matcher<ngraph::pass::NormalizeL2Decomposition, false>();
decomp->add_matcher<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
decomp->add_matcher<ngraph::pass::EinsumDecomposition>();
ADD_MATCHER(decomp, SimplifyCTCGreedyDecoderSeqLen)
ADD_MATCHER(decomp, EinsumDecomposition)
decomp->add_matcher<ngraph::pass::SoftmaxDecomposition, false>();
decomp->add_matcher<ngraph::pass::SoftSignDecomposition>();
decomp->add_matcher<ngraph::pass::GatherNegativeConstIndicesNormalize>();
decomp->add_matcher<ngraph::pass::DropoutWithRandomUniformReplacer>();
decomp->add_matcher<ngraph::pass::TransposeReshapeEliminationForMatmul>();
decomp->add_matcher<ov::pass::EyeDecomposition>();
decomp->add_matcher<ov::pass::UniqueDecomposition>();
ADD_MATCHER(decomp, SoftSignDecomposition)
ADD_MATCHER(decomp, GatherNegativeConstIndicesNormalize)
ADD_MATCHER(decomp, DropoutWithRandomUniformReplacer)
ADD_MATCHER(decomp, TransposeReshapeEliminationForMatmul)
ADD_MATCHER(decomp, EyeDecomposition)
ADD_MATCHER(decomp, UniqueDecomposition)
decomp->set_name("ngraph::pass::CommonDecompositions");
// CF is required after all decompositions
manager.register_pass<ngraph::pass::ConstantFolding>();
REGISTER_PASS(manager, ConstantFolding)
// LinOpSequenceFusion must be executed after all decompositions
manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
manager.register_pass<ngraph::pass::UnrollIf>();
REGISTER_PASS(manager, UnrollIf)
auto multiply_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
multiply_fusions->add_matcher<ngraph::pass::ConvolutionMultiplyFusion>();
multiply_fusions->add_matcher<ngraph::pass::GroupConvolutionMultiplyFusion>();
multiply_fusions->add_matcher<ngraph::pass::ConvolutionBackpropDataMultiplyFusion>();
multiply_fusions->add_matcher<ngraph::pass::GroupConvolutionBackpropDataMultiplyFusion>();
multiply_fusions->add_matcher<ngraph::pass::MultiplyConvolutionFusion>();
multiply_fusions->add_matcher<ngraph::pass::MultiplyGroupConvolutionFusion>();
multiply_fusions->add_matcher<ngraph::pass::MultiplyConvolutionBackpropDataFusion>();
multiply_fusions->add_matcher<ngraph::pass::MultiplyGroupConvolutionBackpropDataFusion>();
multiply_fusions->add_matcher<ngraph::pass::MatMulMultiplyFusion>();
ADD_MATCHER(multiply_fusions, ConvolutionMultiplyFusion)
ADD_MATCHER(multiply_fusions, GroupConvolutionMultiplyFusion)
ADD_MATCHER(multiply_fusions, ConvolutionBackpropDataMultiplyFusion)
ADD_MATCHER(multiply_fusions, GroupConvolutionBackpropDataMultiplyFusion)
ADD_MATCHER(multiply_fusions, MultiplyConvolutionFusion)
ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionFusion)
ADD_MATCHER(multiply_fusions, MultiplyConvolutionBackpropDataFusion)
ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionBackpropDataFusion)
ADD_MATCHER(multiply_fusions, MatMulMultiplyFusion)
multiply_fusions->set_name("ngraph::pass::MultiplyFusions");
manager.register_pass<ngraph::pass::ConstantFolding>();
manager.register_pass<ngraph::pass::ConvertGather8ToGather7>(); // not plugins implemented gather8
manager.register_pass<ngraph::pass::ConvertGather7ToGather1>(); // not plugins implemented gather7
manager.register_pass<ngraph::pass::ConvertGather1ToGather7, false>();
manager.register_pass<ngraph::pass::ConvertGather7ToGather8, false>();
manager.register_pass<ngraph::pass::ConvertDeformableConv8To1>();
manager.register_pass<ngraph::pass::ConvertSoftMax8ToSoftMax1>();
manager.register_pass<ngraph::pass::ConvertSoftMax1ToSoftMax8, false>();
manager.register_pass<ngraph::pass::ConvertMaxPool8ToMaxPool1>();
manager.register_pass<ngraph::pass::ConvertMaxPool1ToMaxPool8, false>();
manager.register_pass<ngraph::pass::ConvertPriorBox8To0>(); // not plugins implemented priorbox8
manager.register_pass<ngraph::pass::ConvertDetectionOutput1ToDetectionOutput8, false>();
manager.register_pass<ngraph::pass::ConvertDetectionOutput8ToDetectionOutput1>();
manager.register_pass<ngraph::pass::ConvertROIAlign3To9, false>();
manager.register_pass<ngraph::pass::ConvertROIAlign9To3>();
manager.register_pass<ngraph::pass::ConvertMulticlassNms8ToMulticlassNms9>();
REGISTER_PASS(manager, ConstantFolding)
REGISTER_PASS(manager, ConvertGather8ToGather7) // not plugins implemented gather8
REGISTER_PASS(manager, ConvertGather7ToGather1) // not plugins implemented gather7
REGISTER_DISABLED_PASS(manager, ConvertGather1ToGather7)
REGISTER_DISABLED_PASS(manager, ConvertGather7ToGather8)
REGISTER_PASS(manager, ConvertDeformableConv8To1)
REGISTER_PASS(manager, ConvertSoftMax8ToSoftMax1)
REGISTER_DISABLED_PASS(manager, ConvertSoftMax1ToSoftMax8)
REGISTER_PASS(manager, ConvertMaxPool8ToMaxPool1)
REGISTER_DISABLED_PASS(manager, ConvertMaxPool1ToMaxPool8)
REGISTER_PASS(manager, ConvertPriorBox8To0)
REGISTER_DISABLED_PASS(manager, ConvertDetectionOutput1ToDetectionOutput8)
REGISTER_PASS(manager, ConvertDetectionOutput8ToDetectionOutput1)
REGISTER_DISABLED_PASS(manager, ConvertROIAlign3To9)
REGISTER_PASS(manager, ConvertROIAlign9To3)
REGISTER_PASS(manager, ConvertMulticlassNms8ToMulticlassNms9)
auto fq_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
fq_fusions->add_matcher<ngraph::pass::FakeQuantizeMulFusion>();
fq_fusions->add_matcher<ngraph::pass::FakeQuantizeReshapeFusion>();
fq_fusions->add_matcher<ngraph::pass::PullTransposeThroughFQUp>();
fq_fusions->add_matcher<ngraph::pass::ReluFakeQuantizeFusion>();
fq_fusions->add_matcher<ngraph::pass::AddFakeQuantizeFusion>();
fq_fusions->add_matcher<ngraph::pass::MulFakeQuantizeFusion>();
ADD_MATCHER(fq_fusions, FakeQuantizeMulFusion)
ADD_MATCHER(fq_fusions, FakeQuantizeReshapeFusion)
ADD_MATCHER(fq_fusions, PullTransposeThroughFQUp)
ADD_MATCHER(fq_fusions, ReluFakeQuantizeFusion)
ADD_MATCHER(fq_fusions, AddFakeQuantizeFusion)
ADD_MATCHER(fq_fusions, MulFakeQuantizeFusion)
fq_fusions->set_name("ngraph::pass::FakeQuantizeFusions");
// StridesOptimization should be at the very end
// because we cannot insert any MaxPools since they may prevent
// other optimizations
manager.register_pass<ngraph::pass::StridesOptimization>();
manager.register_pass<ngraph::pass::Validate>();
REGISTER_PASS(manager, Validate)
manager.run_passes(f);
// Returning value is false because pass::Manager always apply Validation pass

6
src/common/transformations/src/transformations/common_optimizations/concat_reduce_fusion.cpp
View File

@@ -130,7 +130,7 @@ ov::pass::ReplaceConcatReduceByMinOrMax::ReplaceConcatReduceByMinOrMax() {
}
ov::pass::ConcatReduceFusion::ConcatReduceFusion() {
add_matcher<ReplaceConcatReduceByMinOrMax>();
add_matcher<PullSqueezeThroughEltwise>();
add_matcher<EliminateSqueeze>();
ADD_MATCHER_FOR_THIS(ReplaceConcatReduceByMinOrMax)
ADD_MATCHER_FOR_THIS(PullSqueezeThroughEltwise)
ADD_MATCHER_FOR_THIS(EliminateSqueeze)
}

5
src/common/transformations/src/transformations/common_optimizations/convert_compression_only_to_legacy.cpp
View File

@@ -35,8 +35,9 @@ bool ov::pass::ConvertCompressedOnlyToLegacy::run_on_model(const std::shared_ptr
const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
manager.register_pass<ngraph::pass::ConvertPrecision>(convert_precision_list);
manager.register_pass<ov::pass::EnableDecompressionConvertConstantFolding>();
manager.register_pass<ov::pass::ConstantFolding>();
using namespace ov::pass;
REGISTER_PASS(manager, EnableDecompressionConvertConstantFolding)
REGISTER_PASS(manager, ConstantFolding)
manager.run_passes(f);
}

6
src/common/transformations/src/transformations/common_optimizations/convert_nms_gather_path_to_unsigned.cpp
View File

@@ -103,7 +103,7 @@ public:
} // namespace ov
ov::pass::ConvertNmsGatherPathToUnsigned::ConvertNmsGatherPathToUnsigned() {
add_matcher<InitNMSPath>();
add_matcher<PropagateNMSPath>();
add_matcher<UpdateConvertGather>();
ADD_MATCHER_FOR_THIS(InitNMSPath)
ADD_MATCHER_FOR_THIS(PropagateNMSPath)
ADD_MATCHER_FOR_THIS(UpdateConvertGather)
}

4
src/common/transformations/src/transformations/common_optimizations/moc_legacy_transformations.cpp
View File

@@ -13,8 +13,8 @@
bool ov::pass::MOCLegacyTransformations::run_on_model(const std::shared_ptr<ov::Model>& f) {
RUN_ON_MODEL_SCOPE(MOCLegacyTransformations);
ov::pass::Manager manager(get_pass_config());
manager.register_pass<ov::pass::ChangePlaceholderTypes>(m_params_with_custom_types);
using namespace ov::pass;
REGISTER_PASS(manager, ChangePlaceholderTypes, m_params_with_custom_types)
manager.run_passes(f);
return false;

164
src/common/transformations/src/transformations/common_optimizations/moc_transformations.cpp
View File

@@ -93,8 +93,8 @@ bool ov::pass::MOCTransformations::run_on_model(const std::shared_ptr<ngraph::Fu
ov::pass::Manager manager(get_pass_config());
manager.set_per_pass_validation(false);
manager.register_pass<ngraph::pass::InitNodeInfo>();
using namespace ngraph::pass;
REGISTER_PASS(manager, InitNodeInfo)
if (m_low_precision_enabled) {
manager.register_pass<ov::pass::MarkDequantizationSubgraph>(
element::TypeVector{ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4});
@@ -108,125 +108,125 @@ bool ov::pass::MOCTransformations::run_on_model(const std::shared_ptr<ngraph::Fu
// Zero dimensions in shape causes creation empty tensors, which are incorrect during CF.
// In particular, if zero dim tensor is consumed in body of MultiSubGraphOp
// RemoveConcatZeroDimInput and RemoveMultiSubGraphOpDanglingParams should be called together.
manager.register_pass<ov::pass::RemoveConcatZeroDimInput>();
manager.register_pass<ov::pass::Validate>();
manager.register_pass<ov::pass::RemoveMultiSubGraphOpDanglingParams>();
manager.register_pass<ov::pass::FoldSubgraphEmptyInputs>();
manager.register_pass<ov::pass::DisableRandomUniformConstantFolding>();
manager.register_pass<ov::pass::ConstantFolding>();
manager.register_pass<ov::pass::Validate>();
using namespace ov::pass;
REGISTER_PASS(manager, RemoveConcatZeroDimInput)
REGISTER_PASS(manager, Validate)
REGISTER_PASS(manager, RemoveMultiSubGraphOpDanglingParams)
REGISTER_PASS(manager, FoldSubgraphEmptyInputs)
REGISTER_PASS(manager, DisableRandomUniformConstantFolding)
REGISTER_PASS(manager, ConstantFolding)
REGISTER_PASS(manager, Validate)
// FusedFilteringBoxesBySize transformation has the complex pattern
// which can be affected by further transformations. So we have to
// execute it at the beginning of the pipeline. Also, this pass resolves
// dynamism, so we have to execute type/shape propagation after.
manager.register_pass<ov::pass::FuseFilteringBoxesBySize>();
manager.register_pass<ov::pass::Validate>();
REGISTER_PASS(manager, FuseFilteringBoxesBySize)
REGISTER_PASS(manager, Validate)
if (!m_use_shapes) { // Approved Smart Reshape
manager.register_pass<ov::pass::LSTMStatesBroadcast>();
manager.register_pass<ov::pass::Validate>();
manager.register_pass<ov::pass::ReshapeSinkingMatMul>();
manager.register_pass<ov::pass::Validate>();
REGISTER_PASS(manager, LSTMStatesBroadcast)
REGISTER_PASS(manager, Validate)
REGISTER_PASS(manager, ReshapeSinkingMatMul)
REGISTER_PASS(manager, Validate)
}
REGISTER_PASS(manager, ConvertQuantizeDequantize)
REGISTER_PASS(manager, SimplifyShapeOfSubGraph)
manager.register_pass<ov::pass::ConvertQuantizeDequantize>();
manager.register_pass<ov::pass::SimplifyShapeOfSubGraph>();
if (!m_use_shapes) {
manager.register_pass<ov::pass::DisableShapeOfConstantFolding>();
}
// workaround until dynamism in NMS is not supported
manager.register_pass<ov::pass::ConvertNmsGatherPathToUnsigned>();
manager.register_pass<ov::pass::StridedSliceOptimization>(m_use_shapes);
manager.register_pass<ov::pass::BroadcastElementwiseFusion>();
manager.register_pass<ov::pass::PullThroughReduce>();
REGISTER_PASS(manager, ConvertNmsGatherPathToUnsigned)
REGISTER_PASS(manager, StridedSliceOptimization, m_use_shapes)
REGISTER_PASS(manager, BroadcastElementwiseFusion)
REGISTER_PASS(manager, PullThroughReduce)
auto transpose_sinking = manager.register_pass<ov::pass::GraphRewrite>();
transpose_sinking->add_matcher<ov::pass::TransposeSinking>();
ADD_MATCHER(transpose_sinking, 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<ov::pass::SplitSqueezeConcatFusion>();
ADD_MATCHER(transpose_sinking, SplitSqueezeConcatFusion)
auto eliminations = manager.register_pass<ov::pass::GraphRewrite>();
eliminations->add_matcher<ov::pass::EliminateUnsqueezeGather>();
eliminations->add_matcher<ov::pass::NopElimination>(m_use_shapes /* do not use shape for elimination */);
ADD_MATCHER(eliminations, EliminateUnsqueezeGather)
ADD_MATCHER(eliminations, NopElimination, m_use_shapes)
eliminations->set_name("ov::pass::CommonEliminations");
manager.register_pass<ov::pass::ConstantFolding>();
auto common_fusions = manager.register_pass<ov::pass::GraphRewrite>();
common_fusions->add_matcher<ngraph::pass::ConvertScatterElementsToScatter>();
common_fusions->add_matcher<ov::pass::SoftPlusFusion>();
common_fusions->add_matcher<ov::pass::SoftPlusToMishFusion>();
common_fusions->add_matcher<ov::pass::SwishFusion>();
common_fusions->add_matcher<ov::pass::HSwishFusion>();
common_fusions->add_matcher<ov::pass::HSigmoidFusion>();
common_fusions->add_matcher<ov::pass::NormalizeL2Fusion>();
common_fusions->add_matcher<ov::pass::ClampFusion>();
common_fusions->add_matcher<ov::pass::PadFusion>();
common_fusions->add_matcher<ov::pass::SoftmaxFusion>();
common_fusions->add_matcher<ov::pass::ReduceReshapeFusion>();
common_fusions->add_matcher<ov::pass::MVNFusion>();
common_fusions->add_matcher<ov::pass::DilatedConvolutionConverter>();
common_fusions->add_matcher<ov::pass::GeluFusion>();
common_fusions->add_matcher<ov::pass::LeakyReluFusion>();
common_fusions->add_matcher<ov::pass::RandomUniformFusion>();
common_fusions->add_matcher<ov::pass::EliminateDuplicateTIInputs>();
common_fusions->add_matcher<ov::pass::GRUCellFusion>();
common_fusions->add_matcher<ov::pass::SequenceFusion>();
common_fusions->add_matcher<ngraph::pass::ConvertTensorIteratorToSequence>();
common_fusions->add_matcher<ngraph::pass::SplitConcatPairToInterpolateFusion>(m_use_shapes);
ADD_MATCHER(common_fusions, ConvertScatterElementsToScatter)
ADD_MATCHER(common_fusions, SoftPlusFusion)
ADD_MATCHER(common_fusions, SoftPlusToMishFusion)
ADD_MATCHER(common_fusions, SwishFusion)
ADD_MATCHER(common_fusions, HSwishFusion)
ADD_MATCHER(common_fusions, HSigmoidFusion)
ADD_MATCHER(common_fusions, NormalizeL2Fusion)
ADD_MATCHER(common_fusions, ClampFusion)
ADD_MATCHER(common_fusions, PadFusion)
ADD_MATCHER(common_fusions, SoftmaxFusion)
ADD_MATCHER(common_fusions, ReduceReshapeFusion)
ADD_MATCHER(common_fusions, MVNFusion)
ADD_MATCHER(common_fusions, DilatedConvolutionConverter)
ADD_MATCHER(common_fusions, GeluFusion)
ADD_MATCHER(common_fusions, LeakyReluFusion)
ADD_MATCHER(common_fusions, RandomUniformFusion)
ADD_MATCHER(common_fusions, EliminateDuplicateTIInputs)
ADD_MATCHER(common_fusions, GRUCellFusion)
ADD_MATCHER(common_fusions, SequenceFusion)
ADD_MATCHER(common_fusions, ConvertTensorIteratorToSequence)
ADD_MATCHER(common_fusions, SplitConcatPairToInterpolateFusion, m_use_shapes)
if (m_use_shapes) {
common_fusions->add_matcher<ov::pass::NearestNeighborUpsamplingFusion>();
ADD_MATCHER(common_fusions, NearestNeighborUpsamplingFusion)
}
common_fusions->add_matcher<ov::pass::DivideFusion>();
common_fusions->add_matcher<ov::pass::SubtractFusion>();
common_fusions->add_matcher<ov::pass::TransposeToReshape>();
common_fusions->add_matcher<ov::pass::ReshapeSequenceFusion>(m_use_shapes);
common_fusions->add_matcher<ov::pass::MatMulConstTransposesExtraction>();
common_fusions->add_matcher<ov::pass::PReluFusion>();
common_fusions->add_matcher<ov::pass::DepthToSpaceFusion>();
common_fusions->add_matcher<ov::pass::ShuffleChannelsFusion>(!m_use_shapes);
ADD_MATCHER(common_fusions, DivideFusion)
ADD_MATCHER(common_fusions, SubtractFusion)
ADD_MATCHER(common_fusions, TransposeToReshape)
ADD_MATCHER(common_fusions, ReshapeSequenceFusion, m_use_shapes)
ADD_MATCHER(common_fusions, MatMulConstTransposesExtraction)
ADD_MATCHER(common_fusions, PReluFusion)
ADD_MATCHER(common_fusions, DepthToSpaceFusion)
ADD_MATCHER(common_fusions, ShuffleChannelsFusion, !m_use_shapes)
common_fusions->set_name("ov::pass::CommonFusions");
manager.register_pass<ov::pass::BinarizeWeights>();
manager.register_pass<ov::pass::ConvToBinaryConv>();
REGISTER_PASS(manager, BinarizeWeights)
REGISTER_PASS(manager, ConvToBinaryConv)
auto decomp = manager.register_pass<ov::pass::GraphRewrite>();
decomp->add_matcher<ngraph::pass::BatchNormDecomposition>();
decomp->add_matcher<ngraph::pass::ConvertDivideWithConstant>();
decomp->add_matcher<ngraph::pass::ConvertNegative>();
ADD_MATCHER(decomp, BatchNormDecomposition)
ADD_MATCHER(decomp, ConvertDivideWithConstant)
ADD_MATCHER(decomp, ConvertNegative)
manager.register_pass<ov::pass::LinOpSequenceFusion>();
auto multiply_fusions = manager.register_pass<ov::pass::GraphRewrite>();
multiply_fusions->add_matcher<ov::pass::ConvolutionMultiplyFusion>();
multiply_fusions->add_matcher<ov::pass::GroupConvolutionMultiplyFusion>();
multiply_fusions->add_matcher<ov::pass::ConvolutionBackpropDataMultiplyFusion>();
multiply_fusions->add_matcher<ov::pass::GroupConvolutionBackpropDataMultiplyFusion>();
multiply_fusions->add_matcher<ov::pass::MultiplyConvolutionFusion>();
multiply_fusions->add_matcher<ov::pass::MultiplyGroupConvolutionFusion>();
multiply_fusions->add_matcher<ov::pass::MultiplyConvolutionBackpropDataFusion>();
multiply_fusions->add_matcher<ov::pass::MultiplyGroupConvolutionBackpropDataFusion>();
multiply_fusions->add_matcher<ov::pass::MatMulMultiplyFusion>();
ADD_MATCHER(multiply_fusions, ConvolutionMultiplyFusion)
ADD_MATCHER(multiply_fusions, GroupConvolutionMultiplyFusion)
ADD_MATCHER(multiply_fusions, ConvolutionBackpropDataMultiplyFusion)
ADD_MATCHER(multiply_fusions, GroupConvolutionBackpropDataMultiplyFusion)
ADD_MATCHER(multiply_fusions, MultiplyConvolutionFusion)
ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionFusion)
ADD_MATCHER(multiply_fusions, MultiplyConvolutionBackpropDataFusion)
ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionBackpropDataFusion)
ADD_MATCHER(multiply_fusions, MatMulMultiplyFusion)
multiply_fusions->set_name("ov::pass::MultiplyFusions");
manager.register_pass<ov::pass::ConstantFolding>();
REGISTER_PASS(manager, ConstantFolding)
auto fq_fusions = manager.register_pass<ov::pass::GraphRewrite>();
fq_fusions->add_matcher<ov::pass::FakeQuantizeMulFusion>();
fq_fusions->add_matcher<ov::pass::FakeQuantizeReshapeFusion>();
fq_fusions->add_matcher<ov::pass::PullTransposeThroughFQUp>();
fq_fusions->add_matcher<ov::pass::ReluFakeQuantizeFusion>();
fq_fusions->add_matcher<ov::pass::AddFakeQuantizeFusion>();
fq_fusions->add_matcher<ov::pass::MulFakeQuantizeFusion>();
ADD_MATCHER(fq_fusions, FakeQuantizeMulFusion)
ADD_MATCHER(fq_fusions, FakeQuantizeReshapeFusion)
ADD_MATCHER(fq_fusions, PullTransposeThroughFQUp)
ADD_MATCHER(fq_fusions, ReluFakeQuantizeFusion)
ADD_MATCHER(fq_fusions, AddFakeQuantizeFusion)
ADD_MATCHER(fq_fusions, MulFakeQuantizeFusion)
fq_fusions->set_name("ov::pass::FakeQuantizeFusions");
manager.register_pass<ov::pass::ReverseInputChannelsFusion>();
manager.register_pass<ov::pass::AlignEltwiseInputRanks>();
manager.register_pass<ov::pass::ConstantFolding>();
REGISTER_PASS(manager, ReverseInputChannelsFusion)
REGISTER_PASS(manager, AlignEltwiseInputRanks)
REGISTER_PASS(manager, ConstantFolding)
manager.run_passes(f);

28
src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp
View File

@@ -720,20 +720,22 @@ pass::EliminateEltwise::EliminateEltwise() {
ngraph::pass::NopElimination::NopElimination(bool use_shape_for_elimination) {
// shape-agnostic transformations
add_matcher<EliminatePad>();
add_matcher<EliminateConvert>();
add_matcher<EliminateConvertNonZero>();
add_matcher<EliminateConcat>();
add_matcher<EliminateSplit>();
add_matcher<EliminateTranspose>();
add_matcher<EliminateEltwise>();
add_matcher<ov::pass::EliminateSplitConcat>();
ADD_MATCHER_FOR_THIS(EliminatePad)
ADD_MATCHER_FOR_THIS(EliminateConvert)
ADD_MATCHER_FOR_THIS(EliminateConvertNonZero)
ADD_MATCHER_FOR_THIS(EliminateConcat)
ADD_MATCHER_FOR_THIS(EliminateSplit)
ADD_MATCHER_FOR_THIS(EliminateTranspose)
ADD_MATCHER_FOR_THIS(EliminateEltwise)
using namespace ov::pass;
ADD_MATCHER_FOR_THIS(EliminateSplitConcat)
// shape-dependent transformations
if (use_shape_for_elimination) {
add_matcher<EliminateReshape>();
add_matcher<EliminateSqueeze>();
add_matcher<EliminateUnsqueeze>();
add_matcher<EliminateBroadcast>();
add_matcher<EliminateGather>();
ADD_MATCHER_FOR_THIS(EliminateReshape)
ADD_MATCHER_FOR_THIS(EliminateSqueeze)
ADD_MATCHER_FOR_THIS(EliminateUnsqueeze)
ADD_MATCHER_FOR_THIS(EliminateBroadcast)
ADD_MATCHER_FOR_THIS(EliminateGather)
}
}

4
src/common/transformations/src/transformations/common_optimizations/optimize_strided_slice.cpp
View File

@@ -257,8 +257,10 @@ ov::pass::StridedSliceOptimization::StridedSliceOptimization(bool use_shapes) {
bool ov::pass::StridedSliceOptimization::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
RUN_ON_FUNCTION_SCOPE(StridedSliceOptimization);
ov::pass::Manager manager(get_pass_config());
manager.register_pass<ngraph::pass::SliceToStridedSlice>(m_use_shapes);
using namespace ngraph::pass;
REGISTER_PASS(manager, SliceToStridedSlice, m_use_shapes)
manager.run_passes(f);
bool rewritten = false;

4
src/common/transformations/src/transformations/common_optimizations/remove_filtering_boxes_by_size.cpp
View File

@@ -14,8 +14,8 @@
#include "transformations/common_optimizations/subtract_fusion.hpp"
ov::pass::FuseFilteringBoxesBySize::FuseFilteringBoxesBySize() {
add_matcher<SubtractFusion>();
add_matcher<RemoveFilteringBoxesBySize>();
ADD_MATCHER_FOR_THIS(SubtractFusion);
ADD_MATCHER_FOR_THIS(RemoveFilteringBoxesBySize);
}
ov::pass::RemoveFilteringBoxesBySize::RemoveFilteringBoxesBySize() {

43
src/common/transformations/src/transformations/common_optimizations/ric_fusion.cpp
View File

@@ -823,28 +823,41 @@ bool ov::pass::ReverseInputChannelsFusion::run_on_model(const std::shared_ptr<ov
NodeVector nodes_to_fuse;
// First we need to initialize and propagate RIC attributes through entire graph
auto ric_prop = m.register_pass<GraphRewrite>();
ric_prop->add_matcher<init::SplitConcat>(nodes_to_fuse);
ric_prop->add_matcher<init::Gather>(nodes_to_fuse);
ric_prop->add_matcher<prop::Convolution>();
ric_prop->add_matcher<prop::GroupConvolution>();
ric_prop->add_matcher<prop::Binary>();
ric_prop->add_matcher<prop::ShapeOf>();
ric_prop->add_matcher<prop::Transpose>();
ric_prop->add_matcher<prop::PassThrough>();
ric_prop->add_matcher<prop::Unsupported>();
{
using namespace init;
ADD_MATCHER(ric_prop, SplitConcat, nodes_to_fuse)
ADD_MATCHER(ric_prop, Gather, nodes_to_fuse)
}
{
using namespace prop;
ADD_MATCHER(ric_prop, Convolution)
ADD_MATCHER(ric_prop, GroupConvolution)
ADD_MATCHER(ric_prop, Binary)
ADD_MATCHER(ric_prop, ShapeOf)
ADD_MATCHER(ric_prop, Transpose)
ADD_MATCHER(ric_prop, PassThrough)
ADD_MATCHER(ric_prop, Unsupported)
}
// Handle quantized weights case (dequantize sub-graph is on the weights path)
auto ric_back_prop = m.register_pass<ov::pass::BackwardGraphRewrite>();
ric_back_prop->add_matcher<back_prop::Binary>();
ric_back_prop->add_matcher<back_prop::ConvertPassThrough>();
m.register_pass<back_prop::Constant>();
{
using namespace back_prop;
ADD_MATCHER(ric_back_prop, Binary)
ADD_MATCHER(ric_back_prop, ConvertPassThrough)
REGISTER_PASS(m, Constant)
}
// TODO: validate attributes by request
// Second we fuse available RIC into nodes and remove original nodes related to fused RIC
auto ric_fuse = m.register_pass<GraphRewrite>();
ric_fuse->add_matcher<fuse::InsertReverseInputChannel>(nodes_to_fuse);
ric_fuse->add_matcher<fuse::EraseSplitConcat>();
ric_fuse->add_matcher<fuse::EraseGather>();
{
using namespace fuse;
ADD_MATCHER(ric_fuse, InsertReverseInputChannel, nodes_to_fuse)
ADD_MATCHER(ric_fuse, EraseSplitConcat)
ADD_MATCHER(ric_fuse, EraseGather)
}
m.run_passes(model);
return false;

20
src/common/transformations/src/transformations/common_optimizations/simplify_shape_of_sub_graph.cpp
View File

@@ -325,17 +325,21 @@ bool ov::pass::SimplifyShapeOfSubGraph::run_on_model(const std::shared_ptr<ngrap
RUN_ON_FUNCTION_SCOPE(SimplifyShapeOfSubGraph);
ov::pass::Manager manager;
manager.set_per_pass_validation(false);
manager.register_pass<ov::pass::EliminateGatherUnsqueeze>();
manager.register_pass<ov::pass::SharedShapeOf>();
manager.register_pass<ov::pass::GroupedGatherElimination>();
using namespace ov::pass;
REGISTER_PASS(manager, EliminateGatherUnsqueeze)
REGISTER_PASS(manager, SharedShapeOf)
REGISTER_PASS(manager, GroupedGatherElimination)
// GatherNopElimination depends on shape, so it requires shape propagation
// if previous transformations has resolved some dynamic shapes.
manager.register_pass<ov::pass::Validate>();
manager.register_pass<ov::pass::GatherNopElimination>();
manager.register_pass<ov::pass::SimplifyGatherShapeOf>();
manager.register_pass<ov::pass::SimplifySecondInputOfReshape>();
REGISTER_PASS(manager, Validate)
REGISTER_PASS(manager, GatherNopElimination)
REGISTER_PASS(manager, SimplifyGatherShapeOf)
REGISTER_PASS(manager, SimplifySecondInputOfReshape)
// TODO: potentially this Validate is not needed but it requires additional validation
manager.register_pass<ov::pass::Validate>();
REGISTER_PASS(manager, Validate)
manager.run_passes(f);
return false;
}

7
src/common/transformations/src/transformations/common_optimizations/strides_optimization.cpp
View File

@@ -207,3 +207,10 @@ ov::pass::UnsupportedNodesStridesPropagation::UnsupportedNodesStridesPropagation
auto m = std::make_shared<pattern::Matcher>(root, matcher_name);
this->register_matcher(m, callback);
}
ov::pass::StridesOptimization::StridesOptimization() {
using namespace ov::pass;
ADD_MATCHER_FOR_THIS(ConvStridesPropagation);
ADD_MATCHER_FOR_THIS(SupportedNodesStridesPropagation);
ADD_MATCHER_FOR_THIS(UnsupportedNodesStridesPropagation);
}

51
src/inference/src/cnn_network_ngraph_impl.cpp
View File

@@ -32,6 +32,7 @@
// TODO: remove this pass usage
#include <legacy/transformations/convert_opset1_to_legacy/convert_nms_5_to_legacy.hpp>
#include <legacy/transformations/convert_opset1_to_legacy/convert_one_hot_to_one_hot_ie.hpp>
#include <openvino/cc/pass/itt.hpp>
#include <transformations/common_optimizations/dimension_tracking.hpp>
#include <transformations/common_optimizations/fold_subgraph_empty_inputs.hpp>
#include <transformations/common_optimizations/remove_concat_zero_dim_input.hpp>
@@ -146,10 +147,12 @@ CNNNetworkNGraphImpl::CNNNetworkNGraphImpl(const std::shared_ptr<Function>& nGra
_new_api(newAPI) {
{
ov::pass::Manager m;
m.register_pass<ngraph::pass::FixRtInfo>();
m.register_pass<ov::pass::RemoveConcatZeroDimInput>();
m.register_pass<ov::pass::RemoveMultiSubGraphOpDanglingParams>();
m.register_pass<ov::pass::FoldSubgraphEmptyInputs>();
using namespace ngraph::pass;
REGISTER_PASS(m, FixRtInfo)
using namespace ov::pass;
REGISTER_PASS(m, RemoveConcatZeroDimInput)
REGISTER_PASS(m, RemoveMultiSubGraphOpDanglingParams)
REGISTER_PASS(m, FoldSubgraphEmptyInputs)
m.run_passes(_ngraph_function);
}
// Restore usual attributes for CNNNetwork
@@ -210,7 +213,8 @@ CNNNetworkNGraphImpl::CNNNetworkNGraphImpl(const CNNNetwork& network) {
_ngraph_function = ngraph::clone_function(*network.getFunction());
{
ov::pass::Manager m;
m.register_pass<ngraph::pass::FixRtInfo>();
using namespace ngraph::pass;
REGISTER_PASS(m, FixRtInfo)
m.run_passes(_ngraph_function);
}
validateFunctionNames();
@@ -393,7 +397,8 @@ StatusCode CNNNetworkNGraphImpl::reshape(const std::map<std::string, ngraph::Par
try {
ngraph::pass::Manager ssr_manager;
ssr_manager.register_pass<ngraph::pass::SmartReshape>();
using namespace ngraph::pass;
REGISTER_PASS(ssr_manager, SmartReshape)
ssr_manager.run_passes(_ngraph_function);
reshape(inputShapes);
@@ -455,14 +460,17 @@ void CNNNetworkNGraphImpl::reshape(const std::map<std::string, ngraph::PartialSh
OV_ITT_SCOPED_TASK(ov::itt::domains::IE, "CNNNetworkNGraphImpl::ConvertToLegacy");
::ngraph::pass::Manager manager;
// resolves dynamism by replacing dynamic operation with static version
manager.register_pass<::ngraph::pass::ConvertNMS5ToLegacyMatcher>(false);
manager.register_pass<ngraph::pass::ConvertMulticlassNmsToMulticlassNmsIE>(false);
manager.register_pass<::ngraph::pass::ConvertMatrixNmsToMatrixNmsIE>(false);
manager.register_pass<::ngraph::pass::ConvertNMS9ToNMSIEInternal>();
manager.register_pass<::ngraph::pass::ConvertGP9ToGPIEInternal>();
manager.register_pass<::ov::pass::MarkDequantizationSubgraph>();
manager.register_pass<::ov::pass::DisableDecompressionConvertConstantFolding>();
manager.register_pass<::ngraph::pass::ConstantFolding>();
using namespace ngraph::pass;
REGISTER_PASS(manager, ConvertNMS5ToLegacyMatcher, false)
REGISTER_PASS(manager, ConvertMulticlassNmsToMulticlassNmsIE, false)
REGISTER_PASS(manager, ConvertMatrixNmsToMatrixNmsIE, false)
REGISTER_PASS(manager, ConvertNMS9ToNMSIEInternal)
REGISTER_PASS(manager, ConvertGP9ToGPIEInternal)
using namespace ov::pass;
REGISTER_PASS(manager, MarkDequantizationSubgraph)
REGISTER_PASS(manager, DisableDecompressionConvertConstantFolding)
REGISTER_PASS(manager, ConstantFolding)
// OneHotToLegacy changes output precision
manager.register_pass<::ngraph::pass::ConvertOneHotToOneHotIEMatcher>()->detect_output_type(
specialized_ngraph_function);
@@ -542,10 +550,8 @@ StatusCode CNNNetworkNGraphImpl::serialize(const std::string& xmlPath,
custom_opsets.insert(begin(opset), end(opset));
}
ngraph::pass::Manager manager;
manager.register_pass<ov::pass::Serialize>(xmlPath,
binPath,
custom_opsets,
ov::pass::Serialize::Version::IR_V10);
using namespace ov::pass;
REGISTER_PASS(manager, Serialize, xmlPath, binPath, custom_opsets, ov::pass::Serialize::Version::IR_V10)
manager.run_passes(_ngraph_function);
} catch (const Exception& e) {
return DescriptionBuffer(GENERAL_ERROR, resp) << e.what();
@@ -566,7 +572,8 @@ StatusCode CNNNetworkNGraphImpl::serialize(std::ostream& xmlBuf, std::ostream& b
custom_opsets.insert(begin(opset), end(opset));
}
ngraph::pass::Manager manager;
manager.register_pass<ov::pass::Serialize>(xmlBuf, binBuf, custom_opsets, ov::pass::Serialize::Version::IR_V10);
using namespace ov::pass;
REGISTER_PASS(manager, Serialize, xmlBuf, binBuf, custom_opsets, ov::pass::Serialize::Version::IR_V10)
manager.run_passes(_ngraph_function);
} catch (const Exception& e) {
return DescriptionBuffer(GENERAL_ERROR, resp) << e.what();
@@ -589,7 +596,8 @@ StatusCode CNNNetworkNGraphImpl::serialize(std::ostream& xmlBuf, Blob::Ptr& binB
std::stringstream binBuf;
ngraph::pass::Manager manager;
manager.register_pass<ov::pass::Serialize>(xmlBuf, binBuf, custom_opsets, ov::pass::Serialize::Version::IR_V10);
using namespace ov::pass;
REGISTER_PASS(manager, Serialize, xmlBuf, binBuf, custom_opsets, ov::pass::Serialize::Version::IR_V10)
manager.run_passes(_ngraph_function);
std::streambuf* pbuf = binBuf.rdbuf();
@@ -672,7 +680,8 @@ StatusCode CNNNetworkNGraphImpl::setBatchSize(size_t size, ResponseDesc* respons
inShapes[parameter->get_friendly_name()] = shape;
}
ngraph::pass::Manager ssr_manager;
ssr_manager.register_pass<ngraph::pass::SetBatchSize>();
using namespace ngraph::pass;
REGISTER_PASS(ssr_manager, SetBatchSize)
ssr_manager.run_passes(_ngraph_function);
return reshape(inShapes, responseDesc);

6
src/plugins/intel_cpu/src/ngraph_transformations/rnn_sequences_optimization.cpp
View File

@@ -147,7 +147,7 @@ ov::intel_cpu::OptimizeLSTMSequenceTransposes::OptimizeLSTMSequenceTransposes()
}
ov::intel_cpu::OptimizeSequenceTransposes::OptimizeSequenceTransposes() {
add_matcher<OptimizeLSTMSequenceTransposes>();
add_matcher<OptimizeRNNSequenceTransposes>();
add_matcher<OptimizeGRUSequenceTransposes>();
ADD_MATCHER_FOR_THIS(OptimizeLSTMSequenceTransposes)
ADD_MATCHER_FOR_THIS(OptimizeRNNSequenceTransposes)
ADD_MATCHER_FOR_THIS(OptimizeGRUSequenceTransposes)
}

5
src/plugins/template/src/transformations/template_pattern_transformation.cpp
View File

@@ -112,8 +112,9 @@ void run_matcher_with_manager2(std::shared_ptr<ov::Model> f) {
// Register anchor GraphRewrite pass inside manager that will execute two matchers simultaneously
ov::pass::Manager manager;
auto anchor = manager.register_pass<ov::pass::GraphRewrite>();
anchor->add_matcher<ov::pass::DecomposeDivideMatcher>();
anchor->add_matcher<ov::pass::ReluReluFusionMatcher>();
using namespace ov::pass;
ADD_MATCHER(anchor, DecomposeDivideMatcher)
ADD_MATCHER(anchor, ReluReluFusionMatcher)
manager.run_passes(f);
// ! [matcher_pass:manager2]
}