diff --git a/docs/snippets/lpt_mkldnn_plugin.cpp b/docs/snippets/lpt_mkldnn_plugin.cpp index 1808b011c37..db5f5a9fe71 100644 --- a/docs/snippets/lpt_mkldnn_plugin.cpp +++ b/docs/snippets/lpt_mkldnn_plugin.cpp @@ -35,32 +35,31 @@ auto pass_config = manager.get_pass_config(); //! [lpt_common] // check if the function is quantized to ignore LPT transformations for not quantized function to speed up model loading const bool useLpt = ngraph::pass::low_precision::LowPrecision::isFunctionQuantized(nGraphFunc); +auto defaultPrecisions = + useLpt ? ngraph::pass::low_precision::precision_set::int8_support : std::vector{}; if (useLpt) { // disable constant folding on constant subgraph to use the subgraph for LPT - manager.register_pass(std::vector{ - ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4 - }); + manager.register_pass(defaultPrecisions); } // nGraph common transformations happen here if (useLpt) { // convert subtract constant to INT8 to prevent unnecessary FP16 to FP32 conversion - manager.register_pass(std::vector{ - ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4 }); + manager.register_pass(defaultPrecisions); } // nGraph common transformations happen here if (useLpt) { // convert not supported cases FakeQuantize -> Convert -> Convert -> Subtract -> Multiply to a single FakeQuantize - pass_config->set_callback([](const std::shared_ptr &node) -> bool { - return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node); + pass_config->set_callback([&defaultPrecisions](const std::shared_ptr &node) -> bool { + return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node, defaultPrecisions); }); // convert not supported cases FakeQuantize -> Convert -> Convert -> Subtract -> Multiply to a single FakeQuantize - pass_config->set_callback([](const std::shared_ptr &node) -> bool { - return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node); + pass_config->set_callback([&defaultPrecisions](const std::shared_ptr &node) -> bool { + return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node, defaultPrecisions); }); } @@ -107,8 +106,8 @@ if (useLpt) { } return false; }); - lptManager.get_pass_config()->set_callback([](const std::shared_ptr& node) -> bool { - return LayerTransformation::isAsymmetricQuantization(node) || WeightableLayerTransformation::isAsymmetricOnWeights(node); + lptManager.get_pass_config()->set_callback([&defaultPrecisions](const std::shared_ptr& node) -> bool { + return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || WeightableLayerTransformation::isAsymmetricOnWeights(node); }); lptManager.get_pass_config()->set_callback([](const std::shared_ptr& node) -> bool { return MultiplyToGroupConvolutionTransformation::isDynamicOrScalar(node); @@ -172,7 +171,7 @@ lptManager.run_passes(nGraphFunc); return 0; } -int asymmetric_quantization() { +int asymmetric_quantization(const std::vector& defaultPrecisions) { std::shared_ptr nGraphFunc; ngraph::pass::Manager manager; auto pass_config = manager.get_pass_config(); @@ -181,9 +180,10 @@ auto pass_config = manager.get_pass_config(); //! [asymmetric_quantization] using namespace ngraph::pass::low_precision; ngraph::pass::Manager lptManager; + lptManager.register_pass(); -lptManager.get_pass_config()->set_callback([](const std::shared_ptr& node) -> bool { - return LayerTransformation::isAsymmetricQuantization(node) || WeightableLayerTransformation::isAsymmetricOnWeights(node); +lptManager.get_pass_config()->set_callback([&defaultPrecisions](const std::shared_ptr& node) -> bool { + return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || WeightableLayerTransformation::isAsymmetricOnWeights(node); }); lptManager.run_passes(nGraphFunc); //! [asymmetric_quantization] diff --git a/src/common/low_precision_transformations/include/low_precision/align_quantization_intervals.hpp b/src/common/low_precision_transformations/include/low_precision/align_quantization_intervals.hpp index 9a2dcf2c90c..07cb9bcf1ee 100644 --- a/src/common/low_precision_transformations/include/low_precision/align_quantization_intervals.hpp +++ b/src/common/low_precision_transformations/include/low_precision/align_quantization_intervals.hpp @@ -7,6 +7,7 @@ #include #include #include "low_precision/lpt_visibility.hpp" +#include "low_precision/layer_transformation.hpp" namespace ngraph { namespace pass { @@ -30,5 +31,8 @@ class LP_TRANSFORMATIONS_API AlignQuantizationIntervals; class ngraph::pass::low_precision::AlignQuantizationIntervals : public ngraph::pass::FunctionPass { public: NGRAPH_RTTI_DECLARATION; + AlignQuantizationIntervals(const std::vector& defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_support); bool run_on_model(const std::shared_ptr& m) override; +private: + const std::vector defaultPrecisions; }; diff --git a/src/common/low_precision_transformations/include/low_precision/align_quantization_parameters.hpp b/src/common/low_precision_transformations/include/low_precision/align_quantization_parameters.hpp index a85609b3265..affc8558f16 100644 --- a/src/common/low_precision_transformations/include/low_precision/align_quantization_parameters.hpp +++ b/src/common/low_precision_transformations/include/low_precision/align_quantization_parameters.hpp @@ -8,6 +8,7 @@ #include #include "low_precision/lpt_visibility.hpp" +#include "low_precision/layer_transformation.hpp" namespace ngraph { namespace pass { @@ -31,5 +32,8 @@ class LP_TRANSFORMATIONS_API AlignQuantizationParameters; class ngraph::pass::low_precision::AlignQuantizationParameters : public ngraph::pass::FunctionPass { public: NGRAPH_RTTI_DECLARATION; + AlignQuantizationParameters(const std::vector defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_support); bool run_on_model(const std::shared_ptr& m) override; +private: + const std::vector defaultPrecisions; }; diff --git a/src/common/low_precision_transformations/include/low_precision/convolution.hpp b/src/common/low_precision_transformations/include/low_precision/convolution.hpp index 030b3f8b77e..8e39c2c8d0e 100644 --- a/src/common/low_precision_transformations/include/low_precision/convolution.hpp +++ b/src/common/low_precision_transformations/include/low_precision/convolution.hpp @@ -24,8 +24,10 @@ public: NGRAPH_RTTI_DECLARATION; ConvolutionTransformation(const Params& params = Params()); bool transform(TransformationContext& context, ngraph::pattern::Matcher &m) override; - bool isQuantized(const std::shared_ptr& layer) const override; - static bool isQuantizedStatic(const std::shared_ptr& layer); + bool isQuantized(const std::shared_ptr& layer, + const std::vector&defaultPrecisions) const override; + static bool isQuantizedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions); protected: size_t getInputChannels(const std::shared_ptr conv) const override; diff --git a/src/common/low_precision_transformations/include/low_precision/convolution_backprop_data.hpp b/src/common/low_precision_transformations/include/low_precision/convolution_backprop_data.hpp index 3b3881aab28..4ec04ebb0c3 100644 --- a/src/common/low_precision_transformations/include/low_precision/convolution_backprop_data.hpp +++ b/src/common/low_precision_transformations/include/low_precision/convolution_backprop_data.hpp @@ -24,8 +24,10 @@ public: ConvolutionBackpropDataTransformation(const Params& params = Params()); bool transform(TransformationContext& context, ngraph::pattern::Matcher &m) override; bool canBeTransformed(const TransformationContext& context, std::shared_ptr op) const override; - bool isQuantized(const std::shared_ptr& layer) const override; - static bool isQuantizedStatic(const std::shared_ptr& layer); + bool isQuantized(const std::shared_ptr& layer, + const std::vector&defaultPrecisions) const override; + static bool isQuantizedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions); protected: size_t getInputChannels(const std::shared_ptr conv) const override; diff --git a/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp b/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp index 6e00baa9812..00623cc11c0 100644 --- a/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp +++ b/src/common/low_precision_transformations/include/low_precision/create_attribute.hpp @@ -41,7 +41,7 @@ enum class AttributeSource { template class ngraph::pass::low_precision::CreateAttribute : public ngraph::pass::low_precision::BaseMatcherPass { public: - CreateAttribute(const AttributeSource source = AttributeSource::Node) { + CreateAttribute(const AttributeParameters& params = AttributeParameters(), const AttributeSource source = AttributeSource::Node) : BaseMatcherPass(params) { assert((source == AttributeSource::Node) || (source == AttributeSource::OutputPort)); auto operation = std::is_same::value ? pattern::any_input() : @@ -54,7 +54,7 @@ public: } { OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::LPT_LT, "CreateAttribute"); - const auto attribute = AttributeType::create(op, params); + const auto attribute = AttributeType::create(op, this->params); if (attribute.empty()) { return false; } diff --git a/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp b/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp index 51037b81ddc..604b9eb2f93 100644 --- a/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp +++ b/src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp @@ -50,6 +50,8 @@ public: return false; } + std::cout << "CreatePrecisionsDependentAttribute: " << node->get_type_name() << "." << node->get_friendly_name() << std::endl; + { OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::LPT_LT, "CreatePrecisionsDependentAttribute"); auto &rt = node->get_rt_info(); diff --git a/src/common/low_precision_transformations/include/low_precision/group_convolution.hpp b/src/common/low_precision_transformations/include/low_precision/group_convolution.hpp index 215808e735e..9d0e7952009 100644 --- a/src/common/low_precision_transformations/include/low_precision/group_convolution.hpp +++ b/src/common/low_precision_transformations/include/low_precision/group_convolution.hpp @@ -24,8 +24,10 @@ public: NGRAPH_RTTI_DECLARATION; GroupConvolutionTransformation(const Params& params = Params()); bool transform(TransformationContext& context, ngraph::pattern::Matcher &m) override; - bool isQuantized(const std::shared_ptr& layer) const override; - static bool isQuantizedStatic(const std::shared_ptr& layer); + bool isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const override; + static bool isQuantizedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions); protected: size_t getInputChannels(const std::shared_ptr conv) const override; diff --git a/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp b/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp index 3a9e27e3358..45b2784b8f8 100644 --- a/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp +++ b/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp @@ -235,18 +235,18 @@ inline std::ostream &operator << (std::ostream &os, const DataPrecision& value) * @brief Base class for low precision transformation. */ class LP_TRANSFORMATIONS_API LayerTransformation : public ngraph::pass::MatcherPass { - static std::vector defaultPrecisions; - static std::mutex defaultPrecisionsMutex; - public: class Params { public: Params( const bool updatePrecisions = true, element::Type deqPrecision = element::f32, + const std::vector defaultPrecisions = + { ngraph::element::u8, ngraph::element::i8 }, const bool reshapeIgnorePerTensorQuantizationCheck = false) : updatePrecisions(updatePrecisions), deqPrecision(deqPrecision), + defaultPrecisions(defaultPrecisions), reshapeIgnorePerTensorQuantizationCheck(reshapeIgnorePerTensorQuantizationCheck) {} Params& setUpdatePrecisions(const bool updatePrecisions) { @@ -259,8 +259,14 @@ public: return *this; } + Params& setDefaultPrecisions(const std::vector& defaultPrecisions) { + this->defaultPrecisions = defaultPrecisions; + return *this; + } + bool updatePrecisions; element::Type deqPrecision; + std::vector defaultPrecisions; // to support GPU workarround to keep Reshape and MatMul in FP32 bool reshapeIgnorePerTensorQuantizationCheck; }; @@ -285,8 +291,11 @@ public: void setUpdatePrecisions(const bool updatePrecisions); + void setDefaultPrecisions(const std::vector& defaultPrecisions); + virtual bool canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const; - static bool canBeTransformedStatic(const std::shared_ptr& layer); + static bool canBeTransformedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions = precision_set::int8_support); bool canSubtractBeHandled(const std::shared_ptr& op, const FakeQuantizeDequantization& dequantization) const; @@ -299,12 +308,14 @@ public: const std::vector& outputHighValues); static PrecisionDetails getPrecisionDetails(const QuantizationDetails& quantizationDetails); - static bool isAsymmetricQuantization(const std::shared_ptr& node); + static bool isAsymmetricQuantization(const std::shared_ptr& node, + const std::vector& defaultPrecisions = precision_set::int8_support); // return true if operation can be quantized and false otherwise // for example: if convolution operation weights are not quantized, then isQuantize returns false and true otherwise // note: dequantization operations on activations are absent during method execution - virtual bool isQuantized(const std::shared_ptr& layer) const; + virtual bool isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const; // return true if operation can be preserved for precision // note: dequantization operations on activations are absent during method execution @@ -316,9 +327,6 @@ public: const QuantizationDetails& quantizationDetails, const std::vector& requiredPrecisions); - static void setDefaultPrecisions(const std::vector& precisions); - static std::vector getDefaultPrecisions(); - protected: #ifdef LPT_PRINT_DEQUANTIZATION_INFO static void printDequantizationInfo(const std::shared_ptr& layer); @@ -330,6 +338,7 @@ protected: bool updatePrecisions; element::Type deqPrecision; + std::vector defaultPrecisions; bool reshapeIgnorePerTensorQuantizationCheck; static constexpr char originalLayerPostfix[] = "_original"; diff --git a/src/common/low_precision_transformations/include/low_precision/low_precision.hpp b/src/common/low_precision_transformations/include/low_precision/low_precision.hpp index 3a98f3ba35d..0720f90b0c7 100644 --- a/src/common/low_precision_transformations/include/low_precision/low_precision.hpp +++ b/src/common/low_precision_transformations/include/low_precision/low_precision.hpp @@ -42,11 +42,13 @@ public: NGRAPH_RTTI_DECLARATION; MarkupOptimizations( const std::vector& precisionRestrictions, - const std::vector& quantizationRestrictions); + const std::vector& quantizationRestrictions, + const AttributeParameters& params); bool run_on_model(const std::shared_ptr& m) override; private: const std::vector& precisionRestrictions; const std::vector& quantizationRestrictions; + const AttributeParameters& params; }; class LP_TRANSFORMATIONS_API ngraph::pass::low_precision::TypeRelaxedReplacer : public ngraph::pass::GraphRewrite { @@ -66,7 +68,6 @@ public: static bool isFunctionQuantized(const std::shared_ptr& function); static bool isFQLevelsPresent(const std::shared_ptr& function, const std::set& levels); - static void setDefaultPrecisions(const std::vector& precisions); protected: std::vector precisionRestrictions; diff --git a/src/common/low_precision_transformations/include/low_precision/markup_avg_pool_precision_preserved.hpp b/src/common/low_precision_transformations/include/low_precision/markup_avg_pool_precision_preserved.hpp index 5b9c3147642..417c6c3b5fd 100644 --- a/src/common/low_precision_transformations/include/low_precision/markup_avg_pool_precision_preserved.hpp +++ b/src/common/low_precision_transformations/include/low_precision/markup_avg_pool_precision_preserved.hpp @@ -7,6 +7,7 @@ #include #include #include +#include "low_precision/layer_transformation.hpp" namespace ngraph { namespace pass { @@ -29,5 +30,8 @@ class LP_TRANSFORMATIONS_API MarkupAvgPoolPrecisionPreserved; class ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved : public ngraph::pass::FunctionPass { public: NGRAPH_RTTI_DECLARATION; + MarkupAvgPoolPrecisionPreserved(const std::vector defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_support); bool run_on_model(const std::shared_ptr& m) override; +private: + const std::vector defaultPrecisions; }; diff --git a/src/common/low_precision_transformations/include/low_precision/markup_can_be_quantized.hpp b/src/common/low_precision_transformations/include/low_precision/markup_can_be_quantized.hpp index a4b508de924..4b98e110268 100644 --- a/src/common/low_precision_transformations/include/low_precision/markup_can_be_quantized.hpp +++ b/src/common/low_precision_transformations/include/low_precision/markup_can_be_quantized.hpp @@ -31,5 +31,8 @@ class LP_TRANSFORMATIONS_API MarkupCanBeQuantized; class ngraph::pass::low_precision::MarkupCanBeQuantized : public ngraph::pass::FunctionPass { public: NGRAPH_RTTI_DECLARATION; + MarkupCanBeQuantized(const std::vector defaultPrecisions = { ngraph::element::u8, ngraph::element::i8 }); bool run_on_model(const std::shared_ptr& m) override; +private: + const std::vector defaultPrecisions; }; diff --git a/src/common/low_precision_transformations/include/low_precision/markup_precisions.hpp b/src/common/low_precision_transformations/include/low_precision/markup_precisions.hpp index c2533516bc5..e31e8ac731c 100644 --- a/src/common/low_precision_transformations/include/low_precision/markup_precisions.hpp +++ b/src/common/low_precision_transformations/include/low_precision/markup_precisions.hpp @@ -48,11 +48,13 @@ public: }; NGRAPH_RTTI_DECLARATION; - explicit MarkupPrecisions(const std::vector& restrictions = {}); + explicit MarkupPrecisions(const std::vector& restrictions = {}, + const std::vector& defaultPrecisions = { ngraph::element::u8, ngraph::element::i8 }); bool run_on_model(const std::shared_ptr& m) override; private: static bool isPrecisionPreserved(const std::shared_ptr& node); static bool isSupported(const std::shared_ptr& node); std::unordered_map restrictionsByOperation; + std::vector defaultPrecisions; }; diff --git a/src/common/low_precision_transformations/include/low_precision/multiply_to_group_convolution.hpp b/src/common/low_precision_transformations/include/low_precision/multiply_to_group_convolution.hpp index 9df09d0fccf..cd090851380 100644 --- a/src/common/low_precision_transformations/include/low_precision/multiply_to_group_convolution.hpp +++ b/src/common/low_precision_transformations/include/low_precision/multiply_to_group_convolution.hpp @@ -31,7 +31,8 @@ public: bool transform(TransformationContext& context, ngraph::pattern::Matcher &m) override; bool canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const override; bool isPrecisionPreserved(std::shared_ptr layer) const noexcept override; - bool isQuantized(const std::shared_ptr& layer) const override; + bool isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const override; static bool canBeTransformedToGroupConvolution(const std::shared_ptr& layer); static bool isDynamicOrScalar(const std::shared_ptr& node); diff --git a/src/common/low_precision_transformations/include/low_precision/network_helper.hpp b/src/common/low_precision_transformations/include/low_precision/network_helper.hpp index b8adb428efa..a6ff09eecea 100644 --- a/src/common/low_precision_transformations/include/low_precision/network_helper.hpp +++ b/src/common/low_precision_transformations/include/low_precision/network_helper.hpp @@ -99,7 +99,8 @@ public: static std::shared_ptr round(std::shared_ptr node, element::Type target_type); - static std::shared_ptr composeFakeQuantize(const std::shared_ptr& fq); + static std::shared_ptr composeFakeQuantize(const std::shared_ptr& fq, + const std::vector& defaultPrecisions = precision_set::int8_support); static std::tuple, std::shared_ptr> decomposeFakeQuantize( std::shared_ptr fq, @@ -136,13 +137,18 @@ public: const bool updatePrecision, const element::Type deqPrecision = element::f32); - static bool areQuantizeAndDequantizeSupportedForSubtract(const std::shared_ptr& node); + static bool areQuantizeAndDequantizeSupportedForSubtract(const std::shared_ptr& node, + const std::vector& defaultPrecisions = precision_set::int8_support); - static bool areQuantizeAndDequantizeSupportedForMultiply(const std::shared_ptr& node); + static bool areQuantizeAndDequantizeSupportedForMultiply(const std::shared_ptr& node, + const std::vector& _defaultPrecisions = precision_set::int8_support); static bool isQuantizeSupported(const std::shared_ptr& fakeQuantize); - static FakeQuantizeDequantization getDequantization(const std::shared_ptr& node, const size_t parentIndex = 0ul, const bool inPlace = false); + static FakeQuantizeDequantization getDequantization(const std::shared_ptr& node, + const std::vector _defaultPrecisions = precision_set::int8_support, + const size_t parentIndex = 0ul, + const bool inPlace = false); static FakeQuantizeDequantization getDequantizationBelow(const std::shared_ptr& node, const bool convertIsMandatory = false); @@ -171,7 +177,8 @@ public: const std::shared_ptr& operation, const FakeQuantizeDequantization& dequantization, const bool updatePrecision, - const bool moveSubtract); + const bool moveSubtract, + const std::vector& defaultPrecisions = precision_set::int8_support); static InsertDequantizationResult moveDequantizationBefore( const std::shared_ptr& operation, @@ -199,9 +206,13 @@ public: static std::shared_ptr fold_fake_quantize(const std::shared_ptr& fq); static std::shared_ptr fold_fake_quantize(const std::shared_ptr& fq, const bool roundValues, int outChannelsShapeIndex = 0); - static FakeQuantizeDequantization foldDequantization(const std::shared_ptr& node, const size_t branchIndex, const bool inPlace = false); + static FakeQuantizeDequantization foldDequantization(const std::shared_ptr& node, + const size_t branchIndex, + const std::vector& defaultPrecisions = precision_set::int8_support, + const bool inPlace = false); - static std::shared_ptr separateInStandaloneBranch(std::shared_ptr node); + static std::shared_ptr separateInStandaloneBranch(std::shared_ptr node, + const std::vector& defaultPrecisions = precision_set::int8_support); static std::shared_ptr fuseConvert(const std::shared_ptr& fakeQuantize); diff --git a/src/common/low_precision_transformations/include/low_precision/propagate_precisions.hpp b/src/common/low_precision_transformations/include/low_precision/propagate_precisions.hpp index f1927224c4a..18b1522733b 100644 --- a/src/common/low_precision_transformations/include/low_precision/propagate_precisions.hpp +++ b/src/common/low_precision_transformations/include/low_precision/propagate_precisions.hpp @@ -11,6 +11,7 @@ #include #include #include +#include "low_precision/rt_info/attribute_parameters.hpp" namespace ngraph { namespace pass { @@ -33,5 +34,9 @@ class LP_TRANSFORMATIONS_API PropagatePrecisions; class ngraph::pass::low_precision::PropagatePrecisions : public ngraph::pass::FunctionPass { public: NGRAPH_RTTI_DECLARATION; + PropagatePrecisions(const AttributeParameters& params = AttributeParameters()); bool run_on_model(const std::shared_ptr& m) override; + +private: + const AttributeParameters params; }; diff --git a/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp b/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp index 37bf8c0ab35..965505c4fdb 100644 --- a/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp +++ b/src/common/low_precision_transformations/include/low_precision/propagate_through_precision_preserved.hpp @@ -39,7 +39,7 @@ class PropagateThroughPrecisionPreserved; template class ngraph::pass::low_precision::PropagateThroughPrecisionPreserved : public ngraph::pass::MatcherPass { public: - PropagateThroughPrecisionPreserved() { + PropagateThroughPrecisionPreserved(const std::vector& defaultPrecisions = precision_set::int8_support) { ngraph::graph_rewrite_callback callback = [&](pattern::Matcher& m) { auto node = m.get_match_root(); if (transformation_callback(node)) { @@ -53,7 +53,7 @@ public: return false; } - const auto parentRestrictions = getParentInputRestrictions(node); + const auto parentRestrictions = getParentInputRestrictions(node, defaultPrecisions); if (parentRestrictions.empty()) { return false; } @@ -99,11 +99,11 @@ private: } // TODO: possible duplicate: PropagateToInput::getSourceOutputAttribute - std::vector getParentInputRestrictions( - const std::shared_ptr node) { + std::vector getParentInputRestrictions(const std::shared_ptr node, + const std::vector& defaultPrecisions) { std::vector parentAttributes; - auto getInput = [](const std::shared_ptr& node, const size_t index) -> Input { - const auto dequantization = NetworkHelper::getDequantization(node, index); + auto getInput = [&defaultPrecisions](const std::shared_ptr& node, const size_t index) -> Input { + const auto dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, index); if (!dequantization.empty() && ov::is_type(dequantization.data.get_node()) && (dequantization.data.get_node()->get_input_size() == 1ul) && diff --git a/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp b/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp index 34a67687add..a3120f89ce4 100644 --- a/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp +++ b/src/common/low_precision_transformations/include/low_precision/propagate_to_input.hpp @@ -38,7 +38,7 @@ class PropagateToInput; template class ngraph::pass::low_precision::PropagateToInput : public ngraph::pass::MatcherPass { public: - PropagateToInput() { + PropagateToInput(const std::vector& defaultPrecisions = { ngraph::element::u8, ngraph::element::i8 }) { ngraph::graph_rewrite_callback callback = [&](pattern::Matcher& m) { auto node = m.get_match_root(); if (transformation_callback(node)) { @@ -49,7 +49,7 @@ public: OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::LPT_LT, "PropagateToInput"); for (auto input : node->inputs()) { - auto parentAttribute = getSourceOutputAttribute(input); + auto parentAttribute = getSourceOutputAttribute(input, defaultPrecisions); if (parentAttribute == nullptr) { continue; } @@ -78,9 +78,9 @@ public: private: // TODO: possible duplicate: PropagateThroughPrecisionPreserved::getParentInputRestrictions - ov::Any getSourceOutputAttribute(const Input& input) { - auto getInput = [](const Input& input) { - const auto dequantization = NetworkHelper::getDequantization(input.get_node()->shared_from_this(), input.get_index()); + ov::Any getSourceOutputAttribute(const Input& input, const std::vector& defaultPrecisions) { + auto getInput = [&defaultPrecisions](const Input& input) { + const auto dequantization = NetworkHelper::getDequantization(input.get_node()->shared_from_this(), defaultPrecisions, input.get_index()); if (!dequantization.empty() && ov::is_type(dequantization.data.get_node()) && (dequantization.data.get_node()->get_input_size() == 1ul) && diff --git a/src/common/low_precision_transformations/include/low_precision/rt_info/attribute_parameters.hpp b/src/common/low_precision_transformations/include/low_precision/rt_info/attribute_parameters.hpp index 077d4ca8562..0714bc315aa 100644 --- a/src/common/low_precision_transformations/include/low_precision/rt_info/attribute_parameters.hpp +++ b/src/common/low_precision_transformations/include/low_precision/rt_info/attribute_parameters.hpp @@ -9,6 +9,10 @@ class LP_TRANSFORMATIONS_API AttributeParameters { public: - AttributeParameters(const ngraph::element::Type deqPrecision = ngraph::element::f32) : deqPrecision(deqPrecision) {} + AttributeParameters( + const ngraph::element::Type deqPrecision = ngraph::element::f32, + const std::vector defaultPrecisions = { ngraph::element::u8, ngraph::element::i8 }) + : deqPrecision(deqPrecision), defaultPrecisions(defaultPrecisions) {} ngraph::element::Type deqPrecision; + std::vector defaultPrecisions; }; diff --git a/src/common/low_precision_transformations/include/low_precision/rt_info/intervals_alignment_attribute.hpp b/src/common/low_precision_transformations/include/low_precision/rt_info/intervals_alignment_attribute.hpp index 9c0a5b587a7..183ee888af8 100644 --- a/src/common/low_precision_transformations/include/low_precision/rt_info/intervals_alignment_attribute.hpp +++ b/src/common/low_precision_transformations/include/low_precision/rt_info/intervals_alignment_attribute.hpp @@ -70,7 +70,7 @@ public: static ov::Any create( const std::shared_ptr& node, - const AttributeParameters& params); + const AttributeParameters& params = AttributeParameters()); void merge(std::vector& attributes); std::string to_string() const override; diff --git a/src/common/low_precision_transformations/include/low_precision/rt_info/quantization_alignment_attribute.hpp b/src/common/low_precision_transformations/include/low_precision/rt_info/quantization_alignment_attribute.hpp index ba6a422263f..16b92cc8e46 100644 --- a/src/common/low_precision_transformations/include/low_precision/rt_info/quantization_alignment_attribute.hpp +++ b/src/common/low_precision_transformations/include/low_precision/rt_info/quantization_alignment_attribute.hpp @@ -33,7 +33,7 @@ public: static ov::Any create( const std::shared_ptr& node, - const AttributeParameters& params); + const AttributeParameters& params = AttributeParameters()); void merge(std::vector& attributes); std::string to_string() const override; }; diff --git a/src/common/low_precision_transformations/include/low_precision/update_shared_precision_preserved.hpp b/src/common/low_precision_transformations/include/low_precision/update_shared_precision_preserved.hpp index 97c4b950a07..1664571dc2f 100644 --- a/src/common/low_precision_transformations/include/low_precision/update_shared_precision_preserved.hpp +++ b/src/common/low_precision_transformations/include/low_precision/update_shared_precision_preserved.hpp @@ -37,7 +37,7 @@ class UpdateSharedPrecisionPreserved; template class ngraph::pass::low_precision::UpdateSharedPrecisionPreserved : public ngraph::pass::MatcherPass { public: - UpdateSharedPrecisionPreserved() { + UpdateSharedPrecisionPreserved(const std::vector& defaultPrecisions = precision_set::int8_support) { ngraph::graph_rewrite_callback callback = [&](pattern::Matcher& m) { auto node = m.get_match_root(); @@ -74,7 +74,7 @@ public: return false; } } - auto parentAttribute = getSourceAttribute(input); + auto parentAttribute = getSourceAttribute(input, defaultPrecisions); if (parentAttribute.empty()) { continue; } @@ -90,8 +90,8 @@ public: } private: - Input getDequantizationInput(const Input& input) { - const auto dequantization = NetworkHelper::getDequantization(input.get_node()->shared_from_this(), input.get_index()); + Input getDequantizationInput(const Input& input, const std::vector& defaultPrecisions) { + const auto dequantization = NetworkHelper::getDequantization(input.get_node()->shared_from_this(), defaultPrecisions, input.get_index()); if (!dequantization.empty() && (ov::is_type(dequantization.data.get_node())) && ov::is_type(dequantization.data.get_node()->get_input_node_ptr(0))) { @@ -101,8 +101,8 @@ private: return input; } - ov::Any getSourceAttribute(const Input& input) { - const auto dequantizationInput = getDequantizationInput(input); + ov::Any getSourceAttribute(const Input& input, const std::vector& defaultPrecisions) { + const auto dequantizationInput = getDequantizationInput(input, defaultPrecisions); const auto output = dequantizationInput.get_source_output(); auto attribute = ngraph::pass::low_precision::getAttribute(output.get_node()->shared_from_this()); if (attribute.empty()) { diff --git a/src/common/low_precision_transformations/include/low_precision/weightable_layer_transformation.hpp b/src/common/low_precision_transformations/include/low_precision/weightable_layer_transformation.hpp index a5678a9b641..1ab82758ec3 100644 --- a/src/common/low_precision_transformations/include/low_precision/weightable_layer_transformation.hpp +++ b/src/common/low_precision_transformations/include/low_precision/weightable_layer_transformation.hpp @@ -21,7 +21,8 @@ class LP_TRANSFORMATIONS_API WeightableLayerTransformation : public LayerTransfo public: WeightableLayerTransformation(const Params& params); bool canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const override; - bool canConvolutionBeTransformed(const TransformationContext& context, std::shared_ptr layer) const; + bool canConvolutionBeTransformed(const TransformationContext& context, std::shared_ptr layer, + const std::vector& defaultPrecisions) const; bool isPrecisionPreserved(std::shared_ptr layer) const noexcept override; static bool checkPrecisionOnActivation( @@ -30,7 +31,9 @@ public: return true; } - static bool isQuantizedStatic(const std::shared_ptr& layer, const bool reshapeIsRequired); + static bool isQuantizedStatic(const std::shared_ptr& layer, + const bool reshapeIsRequired, + const std::vector& defaultPrecisions = precision_set::int8_support); protected: bool decomposeFakeQuantizeForWeightsPath(const std::shared_ptr& weightableLayer, size_t outChannelsShapeIndex = 0ul) const; @@ -40,8 +43,9 @@ protected: public: static std::shared_ptr getFakeQuantizeOnWeights(const std::shared_ptr& node); - static DataPrecision getDataPrecisionOnWeights(const std::shared_ptr& node); - static bool isAsymmetricOnWeights(const std::shared_ptr& node); + static DataPrecision getDataPrecisionOnWeights(const std::shared_ptr& node, const std::vector& defaultPrecisions); + static bool isAsymmetricOnWeights(const std::shared_ptr& node, + const std::vector& defaultPrecisions = precision_set::int8_support); }; } // namespace low_precision diff --git a/src/common/low_precision_transformations/src/add.cpp b/src/common/low_precision_transformations/src/add.cpp index f14281e5e44..3170d1be79e 100644 --- a/src/common/low_precision_transformations/src/add.cpp +++ b/src/common/low_precision_transformations/src/add.cpp @@ -115,10 +115,10 @@ bool AddTransformation::transform(TransformationContext& context, ngraph::patter return false; } - NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(op, 0)); - NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(op, 1)); + NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(op, defaultPrecisions, 0)); + NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(op, defaultPrecisions, 1)); - std::shared_ptr addNode = NetworkHelper::separateInStandaloneBranch(op); + std::shared_ptr addNode = NetworkHelper::separateInStandaloneBranch(op, defaultPrecisions); std::shared_ptr add = ov::as_type_ptr(addNode); const int fullPathIndex = getNotEmpty(add); @@ -129,11 +129,11 @@ bool AddTransformation::transform(TransformationContext& context, ngraph::patter // swap constant multiply and add and possibly fuse to subtract const auto multiplyBranch = getMultiplyConstBranch(add); if (multiplyBranch.first != -1) { - NetworkHelper::foldDequantization(add, multiplyBranch.first == 0 ? 1 : 0); + NetworkHelper::foldDequantization(add, multiplyBranch.first == 0 ? 1 : 0, defaultPrecisions); } else { // constant folding on dequantization ops (for example: Convert on Subtract) - NetworkHelper::foldDequantization(addNode, 0); - NetworkHelper::foldDequantization(addNode, 1); + NetworkHelper::foldDequantization(addNode, 0, defaultPrecisions); + NetworkHelper::foldDequantization(addNode, 1, defaultPrecisions); return false; } @@ -159,18 +159,18 @@ bool AddTransformation::transform(TransformationContext& context, ngraph::patter const int emptyPathIndex = fullPathIndex == 0 ? 1 : 0; if (updatePrecisions) { - const FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::getDequantization(add, emptyPathIndex); + const FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::getDequantization(add, defaultPrecisions, emptyPathIndex); if (!dequantizationEmptyPath.empty() && !dequantizationEmptyPath.isLowPrecision()) { return false; } } - const FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::foldDequantization(addNode, emptyPathIndex); + const FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::foldDequantization(addNode, emptyPathIndex, defaultPrecisions); std::shared_ptr subtractEmptyPathValues; std::shared_ptr multiplyEmptyPathValues; std::tie(subtractEmptyPathValues, multiplyEmptyPathValues) = NetworkHelper::createEmptyValues(dequantizationEmptyPath, deqPrecision); - const FakeQuantizeDequantization dequantizationFullPath = NetworkHelper::foldDequantization(addNode, fullPathIndex); + const FakeQuantizeDequantization dequantizationFullPath = NetworkHelper::foldDequantization(addNode, fullPathIndex, defaultPrecisions); std::shared_ptr subtractFullPathValues; std::shared_ptr multiplyFullPathValues; std::tie(subtractFullPathValues, multiplyFullPathValues) = NetworkHelper::createEmptyValues(dequantizationFullPath, deqPrecision); @@ -236,19 +236,19 @@ bool AddTransformation::transform(TransformationContext& context, ngraph::patter if (fullPathIndex != -1) { std::shared_ptr node = add; - NetworkHelper::foldDequantization(node, fullPathIndex); + NetworkHelper::foldDequantization(node, fullPathIndex, defaultPrecisions); } return true; } bool AddTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { - const FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(layer, 0ul); + const FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(layer, defaultPrecisions, 0ul); if (dequantization1.multiplyHasZeroOrDenormal()) { return false; } - const FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(layer, 1ul); + const FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(layer, defaultPrecisions, 1ul); if (dequantization2.multiplyHasZeroOrDenormal()) { return false; } diff --git a/src/common/low_precision_transformations/src/align_quantization_intervals.cpp b/src/common/low_precision_transformations/src/align_quantization_intervals.cpp index 6d84cd7936b..cf14f1569d7 100644 --- a/src/common/low_precision_transformations/src/align_quantization_intervals.cpp +++ b/src/common/low_precision_transformations/src/align_quantization_intervals.cpp @@ -8,18 +8,23 @@ #include "low_precision/create_attribute.hpp" #include "low_precision/propagate_through_precision_preserved.hpp" #include "low_precision/rt_info/intervals_alignment_attribute.hpp" +#include "low_precision/rt_info/attribute_parameters.hpp" using namespace ngraph; using namespace ngraph::pass::low_precision; NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::AlignQuantizationIntervals, "AlignQuantizationIntervals", 0); +ngraph::pass::low_precision::AlignQuantizationIntervals::AlignQuantizationIntervals(const std::vector& defaultPrecisions) + : defaultPrecisions(defaultPrecisions) {} + bool ngraph::pass::low_precision::AlignQuantizationIntervals::run_on_model(const std::shared_ptr& f) { ngraph::pass::Manager manager; manager.set_per_pass_validation(false); std::shared_ptr intervalsAlignment = manager.register_pass(); - intervalsAlignment->add_matcher>(); - intervalsAlignment->add_matcher>(); + intervalsAlignment->add_matcher>( + AttributeParameters(ngraph::element::f32, defaultPrecisions)); + intervalsAlignment->add_matcher>(defaultPrecisions); manager.run_passes(f); return false; } diff --git a/src/common/low_precision_transformations/src/align_quantization_parameters.cpp b/src/common/low_precision_transformations/src/align_quantization_parameters.cpp index ea3ff150c51..b846283c552 100644 --- a/src/common/low_precision_transformations/src/align_quantization_parameters.cpp +++ b/src/common/low_precision_transformations/src/align_quantization_parameters.cpp @@ -9,12 +9,16 @@ #include "low_precision/rt_info/quantization_alignment_attribute.hpp" #include "low_precision/rt_info/per_tensor_quantization_attribute.hpp" #include "low_precision/update_shared_precision_preserved.hpp" +#include "low_precision/rt_info/attribute_parameters.hpp" using namespace ngraph; using namespace ngraph::pass::low_precision; NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::AlignQuantizationParameters, "AlignQuantizationParameters", 0); +ngraph::pass::low_precision::AlignQuantizationParameters::AlignQuantizationParameters(const std::vector defaultPrecisions) + : defaultPrecisions(defaultPrecisions) {} + bool ngraph::pass::low_precision::AlignQuantizationParameters::run_on_model(const std::shared_ptr& f) { ngraph::pass::Manager manager; manager.set_per_pass_validation(false); diff --git a/src/common/low_precision_transformations/src/assign_and_read_value.cpp b/src/common/low_precision_transformations/src/assign_and_read_value.cpp index e89e558f2f0..2fb03a41bdc 100644 --- a/src/common/low_precision_transformations/src/assign_and_read_value.cpp +++ b/src/common/low_precision_transformations/src/assign_and_read_value.cpp @@ -57,8 +57,8 @@ bool AssignAndReadValueTransformation::transform(TransformationContext& context, const auto readValue = oldAssign->get_control_dependencies()[0]; oldAssign->remove_control_dependency(readValue); - const auto assign = NetworkHelper::separateInStandaloneBranch(oldAssign); - const auto dequantization = NetworkHelper::getDequantization(assign); + const auto assign = NetworkHelper::separateInStandaloneBranch(oldAssign, defaultPrecisions); + const auto dequantization = NetworkHelper::getDequantization(assign, defaultPrecisions); auto oldVar = ov::as_type_ptr(readValue)->get_variable(); auto variableInfo = oldVar->get_info(); @@ -119,7 +119,7 @@ bool AssignAndReadValueTransformation::canBeTransformed(const TransformationCont return false; } - const auto dequantization = NetworkHelper::getDequantization(op); + const auto dequantization = NetworkHelper::getDequantization(op, defaultPrecisions); return dequantization.subtract == nullptr && dequantization.multiply != nullptr; } diff --git a/src/common/low_precision_transformations/src/avg_pool.cpp b/src/common/low_precision_transformations/src/avg_pool.cpp index b1709a3d5ce..851025e4e16 100644 --- a/src/common/low_precision_transformations/src/avg_pool.cpp +++ b/src/common/low_precision_transformations/src/avg_pool.cpp @@ -38,9 +38,9 @@ bool AvgPoolTransformation::transform(TransformationContext& context, ngraph::pa return false; } - const std::shared_ptr pooling = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); + const std::shared_ptr pooling = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); const bool updatePrecision = isPrecisionPreserved(pooling); - moveDequantizationAfter(context, pooling, NetworkHelper::getDequantization(pooling), updatePrecision); + moveDequantizationAfter(context, pooling, NetworkHelper::getDequantization(pooling, defaultPrecisions), updatePrecision); return true; } @@ -49,7 +49,7 @@ bool AvgPoolTransformation::canBeTransformed(const TransformationContext& contex return false; } - auto dequantization = NetworkHelper::getDequantization(operation); + auto dequantization = NetworkHelper::getDequantization(operation, defaultPrecisions); return !dequantization.empty(); } diff --git a/src/common/low_precision_transformations/src/clamp.cpp b/src/common/low_precision_transformations/src/clamp.cpp index e79627a4b45..b6ae0403207 100644 --- a/src/common/low_precision_transformations/src/clamp.cpp +++ b/src/common/low_precision_transformations/src/clamp.cpp @@ -36,8 +36,8 @@ bool ClampTransformation::transform(TransformationContext& context, ngraph::patt return false; } - const std::shared_ptr clamp = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(clamp); + const std::shared_ptr clamp = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(clamp, defaultPrecisions); const bool moveSubtract = dequantization.subtract == nullptr ? false : NetworkHelper::isScalarLike(dequantization.subtractConstant); // issue #43136 @@ -84,7 +84,7 @@ bool ClampTransformation::canBeTransformed(const TransformationContext& context, return false; } - const auto dequantization = NetworkHelper::getDequantization(op); + const auto dequantization = NetworkHelper::getDequantization(op, defaultPrecisions); if (dequantization.multiply == nullptr) { return false; } diff --git a/src/common/low_precision_transformations/src/concat.cpp b/src/common/low_precision_transformations/src/concat.cpp index 498bf65bfec..188385fe633 100644 --- a/src/common/low_precision_transformations/src/concat.cpp +++ b/src/common/low_precision_transformations/src/concat.cpp @@ -47,7 +47,7 @@ bool ConcatTransformation::transform(TransformationContext& context, ngraph::pat std::vector layerDequantizations; layerDequantizations.reserve(concat->get_input_size()); for (size_t parentIndex = 0ul; parentIndex < concat->get_input_size(); parentIndex++) { - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(concat, parentIndex); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(concat, defaultPrecisions, parentIndex); if (dequantization.empty()) { return false; } @@ -237,7 +237,7 @@ bool ConcatTransformation::canBeTransformed(const TransformationContext& context element::Type precision; for (size_t i = 0ul; i < concat->get_input_size(); i++) { - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(concat, i); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(concat, defaultPrecisions, i); if (dequantization.empty() || (updatePrecisions && !dequantization.isLowPrecision())) { return false; } diff --git a/src/common/low_precision_transformations/src/convolution.cpp b/src/common/low_precision_transformations/src/convolution.cpp index 7c8cf5ef66a..79f61a4ca65 100644 --- a/src/common/low_precision_transformations/src/convolution.cpp +++ b/src/common/low_precision_transformations/src/convolution.cpp @@ -43,12 +43,14 @@ ConvolutionTransformation::ConvolutionTransformation(const Params& params) : Wei this->register_matcher(m, callback); } -bool ConvolutionTransformation::isQuantized(const std::shared_ptr& layer) const { - return ConvolutionTransformation::isQuantizedStatic(layer); +bool ConvolutionTransformation::isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const { + return ConvolutionTransformation::isQuantizedStatic(layer, defaultPrecisions); } -bool ConvolutionTransformation::isQuantizedStatic(const std::shared_ptr& layer) { - return WeightableLayerTransformation::isQuantizedStatic(layer, false); +bool ConvolutionTransformation::isQuantizedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) { + return WeightableLayerTransformation::isQuantizedStatic(layer, false, defaultPrecisions); } size_t ConvolutionTransformation::getInputChannels(const std::shared_ptr conv) const { @@ -60,12 +62,12 @@ size_t ConvolutionTransformation::getInputChannels(const std::shared_ptrget_input_node_shared_ptr(1); const auto reshapeFromWeights = ov::as_type_ptr(weightInput); FakeQuantizeDequantization dequantization = reshapeFromWeights == nullptr ? - NetworkHelper::getDequantization(convolution, 1ul) : - NetworkHelper::getDequantization(reshapeFromWeights); + NetworkHelper::getDequantization(convolution, defaultPrecisions, 1ul) : + NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions); if (dequantization.empty()) { const auto fqOnWeights = getFakeQuantizeOnWeights(convolution); std::shared_ptr resultConstant = NetworkHelper::fold_fake_quantize(fqOnWeights); @@ -79,19 +81,19 @@ bool ConvolutionTransformation::transform(TransformationContext &context, ngraph replace_node(weightInput, resultConstant); } } else { - NetworkHelper::foldDequantization(dequantization.multiply, 0, true); + NetworkHelper::foldDequantization(dequantization.multiply, 0, defaultPrecisions, true); } return true; } - convolution = NetworkHelper::separateInStandaloneBranch(convolution); + convolution = NetworkHelper::separateInStandaloneBranch(convolution, defaultPrecisions); const bool fqOnWeightsWasDecomposed = decomposeFakeQuantizeForWeightsPath(convolution); if (updatePrecisions && !fqOnWeightsWasDecomposed) { return false; } - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(convolution); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(convolution, defaultPrecisions); std::shared_ptr newMultiplyAfter; { @@ -213,8 +215,8 @@ bool ConvolutionTransformation::transform(TransformationContext &context, ngraph std::shared_ptr reshapeFromWeights = ov::as_type_ptr(convolution->get_input_node_shared_ptr(1)); dequantization = reshapeFromWeights == nullptr ? - NetworkHelper::getDequantization(convolution, 1ul) : - NetworkHelper::getDequantization(reshapeFromWeights); + NetworkHelper::getDequantization(convolution, defaultPrecisions, 1ul) : + NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions); assert(!dequantization.empty()); if (ov::is_type(dequantization.data.get_node())) { const std::shared_ptr fq = ov::as_type_ptr(dequantization.data.get_node_shared_ptr()); diff --git a/src/common/low_precision_transformations/src/convolution_backprop_data.cpp b/src/common/low_precision_transformations/src/convolution_backprop_data.cpp index 008736d29fa..54785670e51 100644 --- a/src/common/low_precision_transformations/src/convolution_backprop_data.cpp +++ b/src/common/low_precision_transformations/src/convolution_backprop_data.cpp @@ -53,12 +53,14 @@ ConvolutionBackpropDataTransformation::ConvolutionBackpropDataTransformation(con this->register_matcher(m, callback); } -bool ConvolutionBackpropDataTransformation::isQuantized(const std::shared_ptr& layer) const { - return ConvolutionBackpropDataTransformation::isQuantizedStatic(layer); +bool ConvolutionBackpropDataTransformation::isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const { + return ConvolutionBackpropDataTransformation::isQuantizedStatic(layer, defaultPrecisions); } -bool ConvolutionBackpropDataTransformation::isQuantizedStatic(const std::shared_ptr& layer) { - return WeightableLayerTransformation::isQuantizedStatic(layer, false); +bool ConvolutionBackpropDataTransformation::isQuantizedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) { + return WeightableLayerTransformation::isQuantizedStatic(layer, false, defaultPrecisions); } size_t ConvolutionBackpropDataTransformation::getInputChannels(const std::shared_ptr conv) const { @@ -74,8 +76,8 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con auto weightsInput = convolutionBackpropData->get_input_node_shared_ptr(1); std::shared_ptr reshapeFromWeights = ov::as_type_ptr(weightsInput); FakeQuantizeDequantization dequantization = reshapeFromWeights == nullptr ? - NetworkHelper::getDequantization(convolutionBackpropData, 1ul) : - NetworkHelper::getDequantization(reshapeFromWeights); + NetworkHelper::getDequantization(convolutionBackpropData, defaultPrecisions, 1ul) : + NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions); if (dequantization.empty()) { const auto fqOnWeights = getFakeQuantizeOnWeights(convolutionBackpropData); auto constantShape = fqOnWeights->input(1).get_partial_shape(); @@ -97,13 +99,13 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con replace_node(weightsInput, resultConstant); } } else { - NetworkHelper::foldDequantization(dequantization.multiply, 0, true); + NetworkHelper::foldDequantization(dequantization.multiply, 0, defaultPrecisions, true); } return true; } - convolutionBackpropData = NetworkHelper::separateInStandaloneBranch(convolutionBackpropData); - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(convolutionBackpropData); + convolutionBackpropData = NetworkHelper::separateInStandaloneBranch(convolutionBackpropData, defaultPrecisions); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(convolutionBackpropData, defaultPrecisions); std::shared_ptr newMultiplyAfter; { if (dequantization.subtract != nullptr) { @@ -141,7 +143,7 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con { decomposeFakeQuantizeForWeightsPath(convolutionBackpropData, 1ul); - dequantization = NetworkHelper::getDequantization(convolutionBackpropData, 1ul); + dequantization = NetworkHelper::getDequantization(convolutionBackpropData, defaultPrecisions, 1ul); if (ov::is_type(dequantization.data.get_node())) { const std::shared_ptr fq = ov::as_type_ptr(dequantization.data.get_node_shared_ptr()); @@ -229,7 +231,7 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con } bool ConvolutionBackpropDataTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr op) const { - return canConvolutionBeTransformed(context, op); + return canConvolutionBeTransformed(context, op, defaultPrecisions); } } // namespace low_precision diff --git a/src/common/low_precision_transformations/src/depth_to_space.cpp b/src/common/low_precision_transformations/src/depth_to_space.cpp index 9bb7796487c..46acb833d0d 100644 --- a/src/common/low_precision_transformations/src/depth_to_space.cpp +++ b/src/common/low_precision_transformations/src/depth_to_space.cpp @@ -34,7 +34,7 @@ bool DepthToSpaceTransformation::canBeTransformed(const TransformationContext& c return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions); if (dequantization.multiply != nullptr) { if (!NetworkHelper::isScalarLike(dequantization.multiplyConstant)) { return false; diff --git a/src/common/low_precision_transformations/src/eltwise_base_transformation.cpp b/src/common/low_precision_transformations/src/eltwise_base_transformation.cpp index 327075ba5fe..ece69af9b0b 100644 --- a/src/common/low_precision_transformations/src/eltwise_base_transformation.cpp +++ b/src/common/low_precision_transformations/src/eltwise_base_transformation.cpp @@ -41,8 +41,8 @@ bool EltwiseBaseTransformation::canBeTransformed(const TransformationContext& co return false; } - FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(operation, 0ul); - FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(operation, 1ul); + FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(operation, defaultPrecisions, 0ul); + FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(operation, defaultPrecisions, 1ul); if ((dequantization1.empty() || ((dequantization1.multiply != nullptr) && !FakeQuantizeDequantization::checkElementwise(dequantization1.multiply))) && (dequantization2.empty() || ((dequantization2.multiply != nullptr) && !FakeQuantizeDequantization::checkElementwise(dequantization2.multiply)))) { return false; @@ -89,12 +89,12 @@ static bool isBranchHaveMultipleConsumers(const std::shared_ptr branchData // return branch index with FP32 precision after eltwise transformation int EltwiseBaseTransformation::getNotEmpty(const std::shared_ptr& eltwise) const { - const FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(eltwise, 0ul); + const FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(eltwise, defaultPrecisions, 0ul); if (ov::as_type(dequantization1.data.get_node())) { return -1; } - const FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(eltwise, 1ul); + const FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(eltwise, defaultPrecisions, 1ul); if (ov::as_type(dequantization2.data.get_node())) { return -1; } @@ -188,9 +188,9 @@ int EltwiseBaseTransformation::getNotEmpty(const std::shared_ptr& eltwise) std::pair EltwiseBaseTransformation::getMultiplyConstBranch(const std::shared_ptr& eltwise) const { const std::shared_ptr parent1 = eltwise->get_input_node_shared_ptr(0); - const auto dequantization1 = NetworkHelper::getDequantization(eltwise, 0); + const auto dequantization1 = NetworkHelper::getDequantization(eltwise, defaultPrecisions, 0); const std::shared_ptr parent2 = eltwise->get_input_node_shared_ptr(1); - const auto dequantization2 = NetworkHelper::getDequantization(eltwise, 1); + const auto dequantization2 = NetworkHelper::getDequantization(eltwise, defaultPrecisions, 1); std::shared_ptr constParent = dequantization1.empty() ? ov::as_type_ptr(parent1) : diff --git a/src/common/low_precision_transformations/src/fake_quantize_decomposition.cpp b/src/common/low_precision_transformations/src/fake_quantize_decomposition.cpp index e545b8e54a7..930c7fbbc23 100644 --- a/src/common/low_precision_transformations/src/fake_quantize_decomposition.cpp +++ b/src/common/low_precision_transformations/src/fake_quantize_decomposition.cpp @@ -300,7 +300,7 @@ bool FakeQuantizeDecompositionTransformation::transform(TransformationContext& c return false; } - layer = NetworkHelper::composeFakeQuantize(layer); + layer = NetworkHelper::composeFakeQuantize(layer, defaultPrecisions); if (layer == nullptr) { return false; } @@ -316,7 +316,7 @@ bool FakeQuantizeDecompositionTransformation::transform(TransformationContext& c DataPrecision dataPrecision = fq_decomposition::getDataPrecisionByOutputPort(layer); - PrecisionsAttribute precisionsAttribute(getDefaultPrecisions()); + PrecisionsAttribute precisionsAttribute(defaultPrecisions); { // TODO: LPT: return attribute (not wrapper) auto attributeWrapper = getAttributeFromOutput(layer->output(0)); diff --git a/src/common/low_precision_transformations/src/group_convolution.cpp b/src/common/low_precision_transformations/src/group_convolution.cpp index 98931d0d5e6..5460b3fdc7f 100644 --- a/src/common/low_precision_transformations/src/group_convolution.cpp +++ b/src/common/low_precision_transformations/src/group_convolution.cpp @@ -32,8 +32,9 @@ GroupConvolutionTransformation::GroupConvolutionTransformation(const Params& par this->register_matcher(m, callback); } -bool GroupConvolutionTransformation::isQuantized(const std::shared_ptr& layer) const { - return GroupConvolutionTransformation::isQuantizedStatic(layer); +bool GroupConvolutionTransformation::isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const { + return GroupConvolutionTransformation::isQuantizedStatic(layer, defaultPrecisions); } bool GroupConvolutionTransformation::transform(TransformationContext &context, ngraph::pattern::Matcher &m) { @@ -47,8 +48,9 @@ bool GroupConvolutionTransformation::transform(TransformationContext &context, n return true; } -bool GroupConvolutionTransformation::isQuantizedStatic(const std::shared_ptr& layer) { - return WeightableLayerTransformation::isQuantizedStatic(layer, true); +bool GroupConvolutionTransformation::isQuantizedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) { + return WeightableLayerTransformation::isQuantizedStatic(layer, true, defaultPrecisions); } size_t GroupConvolutionTransformation::getInputChannels(const std::shared_ptr conv) const { diff --git a/src/common/low_precision_transformations/src/interpolate.cpp b/src/common/low_precision_transformations/src/interpolate.cpp index 1dde9c92bee..1e790a91a1f 100644 --- a/src/common/low_precision_transformations/src/interpolate.cpp +++ b/src/common/low_precision_transformations/src/interpolate.cpp @@ -57,8 +57,8 @@ bool InterpolateTransformation::transform(TransformationContext &context, ngraph if (!canBeTransformed(context, m.get_match_root())) { return false; } - interpolate = NetworkHelper::separateInStandaloneBranch(interpolate); - moveDequantizationAfter(context, interpolate, NetworkHelper::getDequantization(interpolate), true); + interpolate = NetworkHelper::separateInStandaloneBranch(interpolate, defaultPrecisions); + moveDequantizationAfter(context, interpolate, NetworkHelper::getDequantization(interpolate, defaultPrecisions), true); return true; } @@ -85,7 +85,7 @@ bool InterpolateTransformation::canBeTransformed(const TransformationContext& co // TODO: expand transformation cases // just repeat CNNNetwork Resample transformation - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions); if (dequantization.empty()) { return false; } diff --git a/src/common/low_precision_transformations/src/layer_transformation.cpp b/src/common/low_precision_transformations/src/layer_transformation.cpp index d1d8f6f0c0e..54b85a93e0a 100644 --- a/src/common/low_precision_transformations/src/layer_transformation.cpp +++ b/src/common/low_precision_transformations/src/layer_transformation.cpp @@ -23,14 +23,11 @@ namespace low_precision { constexpr char LayerTransformation::originalLayerPostfix[]; -// order defines default precision -std::vector LayerTransformation::defaultPrecisions = precision_set::int8_support; -std::mutex LayerTransformation::defaultPrecisionsMutex; - LayerTransformation::LayerTransformation(const Params& params) : updatePrecisions(params.updatePrecisions), deqPrecision(params.deqPrecision), reshapeIgnorePerTensorQuantizationCheck(params.reshapeIgnorePerTensorQuantizationCheck), + defaultPrecisions(params.defaultPrecisions), context(nullptr) {} void LayerTransformation::setContext(TransformationContext* context) noexcept { @@ -41,15 +38,20 @@ void LayerTransformation::setUpdatePrecisions(const bool updatePrecisions) { this->updatePrecisions = updatePrecisions; } +void LayerTransformation::setDefaultPrecisions(const std::vector& defaultPrecisions) { + this->defaultPrecisions = defaultPrecisions; +} + bool LayerTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { - if (!isQuantized(layer)) { + if (!isQuantized(layer, defaultPrecisions)) { return false; } return canBeTransformedStatic(layer); } -bool LayerTransformation::canBeTransformedStatic(const std::shared_ptr& layer) { +bool LayerTransformation::canBeTransformedStatic(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) { for (const auto& output : layer->outputs()) { const auto rank = output.get_partial_shape().rank(); if (rank.is_dynamic() || rank.get_length() < 2) { @@ -57,7 +59,7 @@ bool LayerTransformation::canBeTransformedStatic(const std::shared_ptr& la } } - const auto dequantization = NetworkHelper::getDequantization(layer); + const auto dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions); if (!dequantization.empty()) { auto perChannelQuantization = [](const PartialShape dataPShape, Shape constShape) { if (ngraph::shape_size(constShape) == 1ul) { @@ -103,7 +105,7 @@ bool LayerTransformation::canBeTransformedStatic(const std::shared_ptr& la } bool LayerTransformation::canBeTransformedSpatialDimension(const TransformationContext& context, std::shared_ptr layer) const { - if (!isQuantized(layer)) { + if (!isQuantized(layer, defaultPrecisions)) { return false; } @@ -308,16 +310,17 @@ LayerTransformation::PrecisionDetails LayerTransformation::getPrecisionDetails(c return getPrecisionDetails(quantizationDetails.levels, quantizationDetails.outputLowValues, quantizationDetails.outputHighValues); } -bool LayerTransformation::isAsymmetricQuantization(const std::shared_ptr& layer) { +bool LayerTransformation::isAsymmetricQuantization(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) { const auto nonConstNode = const_cast(layer.get())->shared_from_this(); - const auto dequantization = NetworkHelper::getDequantization(nonConstNode); + const auto dequantization = NetworkHelper::getDequantization(nonConstNode, defaultPrecisions); if (dequantization.empty()) { return false; } return dequantization.subtract != nullptr; } -bool LayerTransformation::isQuantized(const std::shared_ptr& layer) const { +bool LayerTransformation::isQuantized(const std::shared_ptr& layer, const std::vector& defaultPrecisions) const { return true; } @@ -374,7 +377,11 @@ std::shared_ptr LayerTransformation::moveDequantizationAfter( const FakeQuantizeDequantization& dequantization, const bool updatePrecision, const bool moveSubtract) const { - const auto result = ngraph::pass::low_precision::NetworkHelper::moveDequantizationAfter(operation, dequantization, updatePrecision, moveSubtract); + const auto result = ngraph::pass::low_precision::NetworkHelper::moveDequantizationAfter(operation, + dequantization, + updatePrecision, + moveSubtract, + defaultPrecisions); updateOutput(context, result.lastDequantization, result.newOperation); return result.newOperation; } @@ -385,7 +392,10 @@ std::shared_ptr LayerTransformation::moveDequantizationBefore( const FakeQuantizeDequantization& dequantization, const bool updatePrecision, const bool moveSubtract) const { - const auto result = ngraph::pass::low_precision::NetworkHelper::moveDequantizationBefore(operation, dequantization, updatePrecision, moveSubtract); + const auto result = ngraph::pass::low_precision::NetworkHelper::moveDequantizationBefore(operation, + dequantization, + updatePrecision, + moveSubtract); updateOutput(context, result.newOperation, result.lastDequantization); return result.newOperation; } @@ -445,16 +455,6 @@ void LayerTransformation::addPattern(ngraph::pass::GraphRewrite& pass, Transform NGRAPH_SUPPRESS_DEPRECATED_END } -void LayerTransformation::setDefaultPrecisions(const std::vector& precisions) { - std::lock_guard lock(defaultPrecisionsMutex); - defaultPrecisions = precisions; -} - -std::vector LayerTransformation::getDefaultPrecisions() { - std::lock_guard lock(defaultPrecisionsMutex); - return defaultPrecisions; -} - } // namespace low_precision } // namespace pass } // namespace ngraph diff --git a/src/common/low_precision_transformations/src/low_precision.cpp b/src/common/low_precision_transformations/src/low_precision.cpp index 7b5f91352fe..08ee539c486 100644 --- a/src/common/low_precision_transformations/src/low_precision.cpp +++ b/src/common/low_precision_transformations/src/low_precision.cpp @@ -163,27 +163,29 @@ NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::MarkupOptimizations, "Markup MarkupOptimizations::MarkupOptimizations( const std::vector& precisionRestrictions, - const std::vector& quantizationRestrictions) : + const std::vector& quantizationRestrictions, + const AttributeParameters& params) : precisionRestrictions(precisionRestrictions), - quantizationRestrictions(quantizationRestrictions) {} + quantizationRestrictions(quantizationRestrictions), + params(params) {} bool ngraph::pass::low_precision::MarkupOptimizations::run_on_model(const std::shared_ptr& f) { ngraph::pass::Manager markup(get_pass_config()); markup.set_per_pass_validation(false); - markup.register_pass(); + markup.register_pass(params.defaultPrecisions); if (!precisionRestrictions.empty()) { - markup.register_pass(precisionRestrictions); + markup.register_pass(precisionRestrictions, params.defaultPrecisions); } if (!quantizationRestrictions.empty()) { markup.register_pass(quantizationRestrictions); } if (ngraph::op::util::has_op_with_type(f)) { - markup.register_pass(); + markup.register_pass(params.defaultPrecisions); } - markup.register_pass(); + markup.register_pass(params); if (ngraph::op::util::has_op_with_type(f)) { - markup.register_pass(); - markup.register_pass(); + markup.register_pass(params.defaultPrecisions); + markup.register_pass(params.defaultPrecisions); } markup.run_passes(f); return false; @@ -204,7 +206,8 @@ bool ngraph::pass::low_precision::LowPrecision::run_on_model(const std::shared_p manager.register_pass(); - manager.register_pass(precisionRestrictions, quantizationRestrictions); + AttributeParameters attributeParams(params.deqPrecision, params.defaultPrecisions); + manager.register_pass(precisionRestrictions, quantizationRestrictions, attributeParams); std::shared_ptr common = manager.register_pass(); common->add_matcher(params); @@ -301,7 +304,3 @@ bool ngraph::pass::low_precision::LowPrecision::isFQLevelsPresent( } return false; } - -void ngraph::pass::low_precision::LowPrecision::setDefaultPrecisions(const std::vector& precisions) { - LayerTransformation::setDefaultPrecisions(precisions); -} diff --git a/src/common/low_precision_transformations/src/markup_avg_pool_precision_preserved.cpp b/src/common/low_precision_transformations/src/markup_avg_pool_precision_preserved.cpp index 92d6da1072d..1aa1883f840 100644 --- a/src/common/low_precision_transformations/src/markup_avg_pool_precision_preserved.cpp +++ b/src/common/low_precision_transformations/src/markup_avg_pool_precision_preserved.cpp @@ -14,13 +14,16 @@ using namespace ngraph; NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved, "MarkupAvgPoolPrecisionPreserved", 0); +ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved::MarkupAvgPoolPrecisionPreserved(const std::vector defaultPrecisions) + : defaultPrecisions(defaultPrecisions) {} + bool ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved::run_on_model(const std::shared_ptr& f) { ngraph::pass::Manager manager; manager.set_per_pass_validation(false); std::shared_ptr markupAvgPoolPrecision = manager.register_pass(); markupAvgPoolPrecision->add_matcher>(); - markupAvgPoolPrecision->add_matcher>(); - markupAvgPoolPrecision->add_matcher>(); + markupAvgPoolPrecision->add_matcher>(defaultPrecisions); + markupAvgPoolPrecision->add_matcher>(defaultPrecisions); manager.run_passes(f); return false; } diff --git a/src/common/low_precision_transformations/src/markup_can_be_quantized.cpp b/src/common/low_precision_transformations/src/markup_can_be_quantized.cpp index 98a8941c95c..44681233bd0 100644 --- a/src/common/low_precision_transformations/src/markup_can_be_quantized.cpp +++ b/src/common/low_precision_transformations/src/markup_can_be_quantized.cpp @@ -18,6 +18,9 @@ using namespace ngraph; NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::MarkupCanBeQuantized, "MarkupCanBeQuantized", 0); +ngraph::pass::low_precision::MarkupCanBeQuantized::MarkupCanBeQuantized(const std::vector defaultPrecisions) + : defaultPrecisions(defaultPrecisions) {} + bool ngraph::pass::low_precision::MarkupCanBeQuantized::run_on_model(const std::shared_ptr& f) { auto setEmptyPrecisions = [](const std::shared_ptr& node) { for (auto& input : node->inputs()) { @@ -34,19 +37,19 @@ bool ngraph::pass::low_precision::MarkupCanBeQuantized::run_on_model(const std:: } if (const auto convolution = std::dynamic_pointer_cast(node)) { - if (!ConvolutionTransformation::isQuantizedStatic(convolution)) { + if (!ConvolutionTransformation::isQuantizedStatic(convolution, defaultPrecisions)) { setEmptyPrecisions(convolution); } continue; } if (const auto convolutionBackpropData = std::dynamic_pointer_cast(node)) { - if (!ConvolutionBackpropDataTransformation::isQuantizedStatic(convolutionBackpropData)) { + if (!ConvolutionBackpropDataTransformation::isQuantizedStatic(convolutionBackpropData, defaultPrecisions)) { setEmptyPrecisions(convolutionBackpropData); } continue; } if (const auto groupConvolution = std::dynamic_pointer_cast(node)) { - if (!GroupConvolutionTransformation::isQuantizedStatic(groupConvolution)) { + if (!GroupConvolutionTransformation::isQuantizedStatic(groupConvolution, defaultPrecisions)) { setEmptyPrecisions(groupConvolution); } continue; diff --git a/src/common/low_precision_transformations/src/markup_precisions.cpp b/src/common/low_precision_transformations/src/markup_precisions.cpp index 971188a8ec4..490b59bec18 100644 --- a/src/common/low_precision_transformations/src/markup_precisions.cpp +++ b/src/common/low_precision_transformations/src/markup_precisions.cpp @@ -21,7 +21,8 @@ using namespace ngraph; NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::MarkupPrecisions, "MarkupPrecisions", 0); -ngraph::pass::low_precision::MarkupPrecisions::MarkupPrecisions(const std::vector& restrictions) { +ngraph::pass::low_precision::MarkupPrecisions::MarkupPrecisions(const std::vector& restrictions, + const std::vector& defaultPrecisions) : defaultPrecisions(defaultPrecisions) { for (const auto& restriction : restrictions) { const auto it = restrictionsByOperation.find(restriction.operationType.name); if (it == restrictionsByOperation.end()) { @@ -75,7 +76,7 @@ bool ngraph::pass::low_precision::MarkupPrecisions::run_on_model(const std::shar // TODO: don't need to set restrictions for not supported operations // if don't set restrictions for not supported operations then accuracy drop appears, issue #59197 const bool supported = ov::is_type(node) || isSupported(node); - if (!supported || !LayerTransformation::canBeTransformedStatic(node)) { + if (!supported || !LayerTransformation::canBeTransformedStatic(node, defaultPrecisions)) { setRestriction(node, std::vector>> { {0ul, {}}}); continue; } diff --git a/src/common/low_precision_transformations/src/mat_mul.cpp b/src/common/low_precision_transformations/src/mat_mul.cpp index 0f396bf4444..041094ea853 100644 --- a/src/common/low_precision_transformations/src/mat_mul.cpp +++ b/src/common/low_precision_transformations/src/mat_mul.cpp @@ -44,9 +44,9 @@ bool MatMulTransformation::transform(TransformationContext &context, ngraph::pat return false; } - matMul = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(matMul)); - const auto dequantization1 = NetworkHelper::getDequantization(matMul, 0); - auto dequantization2 = NetworkHelper::getDequantization(matMul, 1); + matMul = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(matMul, defaultPrecisions)); + const auto dequantization1 = NetworkHelper::getDequantization(matMul, defaultPrecisions, 0); + auto dequantization2 = NetworkHelper::getDequantization(matMul, defaultPrecisions, 1); if (dequantization2.empty()) { const std::shared_ptr fakeQuantize = @@ -56,7 +56,7 @@ bool MatMulTransformation::transform(TransformationContext &context, ngraph::pat const auto precisionsAttribute = getAttributeFromOutput(fakeQuantize); const auto precisions = precisionsAttribute.empty() ? - getDefaultPrecisions() : + defaultPrecisions : precisionsAttribute.as().value(); const DataPrecision dataPrecision = getDataPrecision(fakeQuantize, quantizationDetails, precisions); if (dataPrecision.empty()) { @@ -71,13 +71,13 @@ bool MatMulTransformation::transform(TransformationContext &context, ngraph::pat dataPrecision.hasZeroPoint, updatePrecisions); - dequantization2 = NetworkHelper::getDequantization(matMul, 1); + dequantization2 = NetworkHelper::getDequantization(matMul, defaultPrecisions, 1); } } if (dequantization2.subtract != nullptr) { NetworkHelper::optimizeSubtract(dequantization2.subtract); - dequantization2 = NetworkHelper::getDequantization(matMul, 1); + dequantization2 = NetworkHelper::getDequantization(matMul, defaultPrecisions, 1); } const std::shared_ptr newMatMul = std::make_shared>( @@ -197,7 +197,7 @@ bool MatMulTransformation::canBeTransformed(const TransformationContext& context return false; } - const auto dequantization1 = NetworkHelper::getDequantization(layer, 0); + const auto dequantization1 = NetworkHelper::getDequantization(layer, defaultPrecisions, 0); if (!dequantization1.empty()) { if (updatePrecisions && !dequantization1.isLowPrecision()) { return false; @@ -223,7 +223,7 @@ bool MatMulTransformation::canBeTransformed(const TransformationContext& context return false; } - const auto dequantization2 = NetworkHelper::getDequantization(layer, 1); + const auto dequantization2 = NetworkHelper::getDequantization(layer, defaultPrecisions, 1); if (!dequantization2.empty()) { if ((updatePrecisions && !dequantization2.isLowPrecision())) { return false; @@ -260,7 +260,7 @@ bool MatMulTransformation::canBeTransformed(const TransformationContext& context const auto precisionsAttribute = getAttribute(matMul->input(1)); const auto precisions = precisionsAttribute.empty() ? - getDefaultPrecisions() : + defaultPrecisions : precisionsAttribute.as().value(); const DataPrecision dataPrecision = getDataPrecision(fakeQuantize, quantizationDetails, precisions); diff --git a/src/common/low_precision_transformations/src/max_pool.cpp b/src/common/low_precision_transformations/src/max_pool.cpp index 3795622f08b..8d73eaadc7d 100644 --- a/src/common/low_precision_transformations/src/max_pool.cpp +++ b/src/common/low_precision_transformations/src/max_pool.cpp @@ -38,7 +38,7 @@ bool MaxPoolTransformation::canBeTransformed(const TransformationContext& contex return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, defaultPrecisions); if (dequantization.empty()) { return false; } @@ -56,8 +56,8 @@ bool MaxPoolTransformation::transform(TransformationContext& context, ngraph::pa return false; } - const std::shared_ptr pooling = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - moveDequantizationAfter(context, pooling, NetworkHelper::getDequantization(pooling), false); + const std::shared_ptr pooling = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + moveDequantizationAfter(context, pooling, NetworkHelper::getDequantization(pooling, defaultPrecisions), false); return true; } diff --git a/src/common/low_precision_transformations/src/multiply.cpp b/src/common/low_precision_transformations/src/multiply.cpp index 9c9d20144f9..61b89a763be 100644 --- a/src/common/low_precision_transformations/src/multiply.cpp +++ b/src/common/low_precision_transformations/src/multiply.cpp @@ -44,10 +44,10 @@ bool MultiplyTransformation::transform(TransformationContext& context, ngraph::p return false; } - NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(multiply, 0)); - NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(multiply, 1)); + NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(multiply, defaultPrecisions, 0)); + NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(multiply, defaultPrecisions, 1)); - multiply = NetworkHelper::separateInStandaloneBranch(multiply); + multiply = NetworkHelper::separateInStandaloneBranch(multiply, defaultPrecisions); auto newMultiply = multiply; auto fold_fake_quantizes = [](std::shared_ptr& multiply, const size_t index) { @@ -67,13 +67,13 @@ bool MultiplyTransformation::transform(TransformationContext& context, ngraph::p if (fullPathIndex == -1) { const auto multiplyBranch = getMultiplyConstBranch(multiply); if (multiplyBranch.first != -1) { - NetworkHelper::foldDequantization(multiply, multiplyBranch.first == 0 ? 1 : 0); + NetworkHelper::foldDequantization(multiply, multiplyBranch.first == 0 ? 1 : 0, defaultPrecisions); } if (multiplyBranch.first == -1 || multiplyBranch.second == -1) { // constant folding on dequantization ops (for example: Convert on Subtract) - NetworkHelper::foldDequantization(multiply, 0); - NetworkHelper::foldDequantization(multiply, 1); + NetworkHelper::foldDequantization(multiply, 0, defaultPrecisions); + NetworkHelper::foldDequantization(multiply, 1, defaultPrecisions); return false; } @@ -98,13 +98,13 @@ bool MultiplyTransformation::transform(TransformationContext& context, ngraph::p const int emptyPathIndex = fullPathIndex == 0 ? 1 : 0; if (updatePrecisions) { - const FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::getDequantization(multiply, emptyPathIndex); + const FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::getDequantization(multiply, defaultPrecisions, emptyPathIndex); if (!dequantizationEmptyPath.empty() && !dequantizationEmptyPath.isLowPrecision()) { return false; } } - FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::foldDequantization(multiply, emptyPathIndex); + FakeQuantizeDequantization dequantizationEmptyPath = NetworkHelper::foldDequantization(multiply, emptyPathIndex, defaultPrecisions); std::shared_ptr subtractValuesEmptyPath; std::shared_ptr multiplyValuesEmptyPath; std::tie(subtractValuesEmptyPath, multiplyValuesEmptyPath) = NetworkHelper::createEmptyValues(dequantizationEmptyPath, deqPrecision); @@ -114,7 +114,7 @@ bool MultiplyTransformation::transform(TransformationContext& context, ngraph::p return false; } - FakeQuantizeDequantization dequantizationFullPath = NetworkHelper::foldDequantization(multiply, fullPathIndex); + FakeQuantizeDequantization dequantizationFullPath = NetworkHelper::foldDequantization(multiply, fullPathIndex, defaultPrecisions); std::shared_ptr subtractValuesFullPath; std::shared_ptr multiplyValuesFullPath; std::tie(subtractValuesFullPath, multiplyValuesFullPath) = NetworkHelper::createEmptyValues(dequantizationFullPath, deqPrecision); @@ -145,15 +145,15 @@ bool MultiplyTransformation::transform(TransformationContext& context, ngraph::p updateOutput(context, newMultiply, multiply); if (fullPathIndex != -1) { - NetworkHelper::foldDequantization(newMultiply, fullPathIndex); + NetworkHelper::foldDequantization(newMultiply, fullPathIndex, defaultPrecisions); } return true; } bool MultiplyTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { - FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(layer, 0ul); - FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(layer, 1ul); + FakeQuantizeDequantization dequantization1 = pass::low_precision::NetworkHelper::getDequantization(layer, defaultPrecisions, 0ul); + FakeQuantizeDequantization dequantization2 = pass::low_precision::NetworkHelper::getDequantization(layer, defaultPrecisions, 1ul); if (dequantization1.data.get_node() == nullptr || dequantization2.data.get_node() == nullptr) { return false; diff --git a/src/common/low_precision_transformations/src/multiply_to_group_convolution.cpp b/src/common/low_precision_transformations/src/multiply_to_group_convolution.cpp index 56acf72f216..7847122d96f 100644 --- a/src/common/low_precision_transformations/src/multiply_to_group_convolution.cpp +++ b/src/common/low_precision_transformations/src/multiply_to_group_convolution.cpp @@ -46,12 +46,12 @@ bool MultiplyToGroupConvolutionTransformation::transform(TransformationContext& inputIndex = 1; } - auto dequantization = NetworkHelper::getDequantization(multiply, inputIndex); + auto dequantization = NetworkHelper::getDequantization(multiply, defaultPrecisions, inputIndex); if (dequantization.data.get_node() == nullptr) { return false; } if (dequantization.subtractConvert != nullptr) { - dequantization = NetworkHelper::foldDequantization(multiply, inputIndex); + dequantization = NetworkHelper::foldDequantization(multiply, inputIndex, defaultPrecisions); } element::Type weightsPrecision = element::undefined; @@ -68,7 +68,7 @@ bool MultiplyToGroupConvolutionTransformation::transform(TransformationContext& if (weightsPrecision == element::undefined) { const auto precisionsAttribute = getAttribute(multiply->input(inputIndex == 0ul ? 1ul : 0ul)); const auto precisions = precisionsAttribute == nullptr ? - getDefaultPrecisions() : + defaultPrecisions : precisionsAttribute.as().value(); weightsPrecision = precisions[0]; } @@ -191,7 +191,7 @@ bool MultiplyToGroupConvolutionTransformation::canBeTransformed(const Transforma return false; } - const auto dequantization = NetworkHelper::getDequantization(operation, inputIndex); + const auto dequantization = NetworkHelper::getDequantization(operation, defaultPrecisions, inputIndex); const element::Type parentPrecision = dequantization.data.get_element_type(); if (std::find(availablePreisions.begin(), availablePreisions.end(), parentPrecision) == availablePreisions.end()) { return false; @@ -201,7 +201,8 @@ bool MultiplyToGroupConvolutionTransformation::canBeTransformed(const Transforma return true; } -bool MultiplyToGroupConvolutionTransformation::isQuantized(const std::shared_ptr& layer) const { +bool MultiplyToGroupConvolutionTransformation::isQuantized(const std::shared_ptr& layer, + const std::vector& defaultPrecisions) const { return MultiplyToGroupConvolutionTransformation::canBeTransformedToGroupConvolution(layer); } diff --git a/src/common/low_precision_transformations/src/mvn.cpp b/src/common/low_precision_transformations/src/mvn.cpp index 47fefbfe45a..d9297eb348a 100644 --- a/src/common/low_precision_transformations/src/mvn.cpp +++ b/src/common/low_precision_transformations/src/mvn.cpp @@ -65,7 +65,7 @@ bool MVNTransformation::canBeTransformed(const TransformationContext& context, s return false; } - const auto dequantization = NetworkHelper::getDequantization(operation); + const auto dequantization = NetworkHelper::getDequantization(operation, defaultPrecisions); if (dequantization.empty() || dequantization.subtract != nullptr) { return false; } @@ -124,7 +124,7 @@ bool MVNTransformation::transform(TransformationContext &context, ngraph::patter normalizeVariance = ov::as_type_ptr(mvn)->get_normalize_variance(); } - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(mvn); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(mvn, defaultPrecisions); const auto scalesConst = dequantization.multiplyConstant; const auto type = scalesConst->get_element_type(); diff --git a/src/common/low_precision_transformations/src/network_helper.cpp b/src/common/low_precision_transformations/src/network_helper.cpp index d9ab21ddf2a..2da8a5e97fa 100644 --- a/src/common/low_precision_transformations/src/network_helper.cpp +++ b/src/common/low_precision_transformations/src/network_helper.cpp @@ -509,8 +509,11 @@ std::shared_ptr NetworkHelper::fold_fake_quantize( return foldFakeQuantize(fq, roundValues, true, outChannelsShapeIndex); } -FakeQuantizeDequantization NetworkHelper::foldDequantization(const std::shared_ptr& node, const size_t branchIndex, const bool inPlace) { - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(node, branchIndex, inPlace); +FakeQuantizeDequantization NetworkHelper::foldDequantization(const std::shared_ptr& node, + const size_t branchIndex, + const std::vector& defaultPrecisions, + const bool inPlace) { + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, branchIndex, inPlace); if (dequantization.empty() || (dequantization.multiply == nullptr)) { return dequantization; } @@ -522,7 +525,7 @@ FakeQuantizeDequantization NetworkHelper::foldDequantization(const std::shared_p copyInfo(dequantization.convert, result); } replace_node(dequantization.convert, result); - dequantization = NetworkHelper::getDequantization(node, branchIndex, inPlace); + dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, branchIndex, inPlace); } } @@ -537,7 +540,7 @@ FakeQuantizeDequantization NetworkHelper::foldDequantization(const std::shared_p dequantization.subtractConvert->get_element_type()); if (ov::is_type(convertionResult)) { replace_node(dequantization.subtractConvert, convertionResult); - dequantization = NetworkHelper::getDequantization(node, branchIndex, inPlace); + dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, branchIndex, inPlace); } } @@ -549,7 +552,7 @@ FakeQuantizeDequantization NetworkHelper::foldDequantization(const std::shared_p copyInfo(dequantization.subtract, result); } replace_node(dequantization.subtract, result); - dequantization = NetworkHelper::getDequantization(node, branchIndex, inPlace); + dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, branchIndex, inPlace); } else { return dequantization; } @@ -573,15 +576,16 @@ FakeQuantizeDequantization NetworkHelper::foldDequantization(const std::shared_p copyInfo(dequantization.multiply, result); } replace_node(dequantization.multiply, result); - dequantization = NetworkHelper::getDequantization(node, branchIndex, inPlace); + dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, branchIndex, inPlace); } return dequantization; } -std::shared_ptr NetworkHelper::separateInStandaloneBranch(std::shared_ptr node) { - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(node); +std::shared_ptr NetworkHelper::separateInStandaloneBranch(std::shared_ptr node, + const std::vector& defaultPrecisions) { + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(node, defaultPrecisions); if (dequantization.isShared()) { Output parent = dequantization.data; if (dequantization.convert != nullptr) { @@ -835,7 +839,8 @@ std::shared_ptr NetworkHelper::foldFakeQuantize( return fq; } -std::shared_ptr NetworkHelper::composeFakeQuantize(const std::shared_ptr& fakeQuantize) { +std::shared_ptr NetworkHelper::composeFakeQuantize(const std::shared_ptr& fakeQuantize, + const std::vector& defaultPrecisions) { std::shared_ptr parent = fakeQuantize; auto targetInputs = parent->output(0).get_target_inputs(); if (targetInputs.size() != 1ul) { @@ -865,7 +870,7 @@ std::shared_ptr NetworkHelper::composeFakeQuantize(const s parent = parent->output(0).get_target_inputs().begin()->get_node()->shared_from_this(); const size_t index = NetworkHelper::getChildInputIndex(prev, parent); - const FakeQuantizeDequantization dequantization = getDequantization(parent, index); + const FakeQuantizeDequantization dequantization = getDequantization(parent, defaultPrecisions, index); if (dequantization.empty()) { return nullptr; } @@ -1248,7 +1253,8 @@ FakeQuantizeDequantization NetworkHelper::createDequantizationFromFakeQuantize( return FakeQuantizeDequantization(fq, convert, subtract, nullptr, shift, multiply, scale); } -bool NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(const std::shared_ptr& node) { +bool NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(const std::shared_ptr& node, + const std::vector& defaultPrecisions) { if (!ov::is_type(node)) { return false; } @@ -1259,16 +1265,17 @@ bool NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(const std::shar } const auto multiply = targetInputs.begin()->get_node()->shared_from_this(); - return areQuantizeAndDequantizeSupportedForMultiply(multiply); + return areQuantizeAndDequantizeSupportedForMultiply(multiply, defaultPrecisions); } -bool NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(const std::shared_ptr& node) { +bool NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(const std::shared_ptr& node, + const std::vector& defaultPrecisions) { if (!ov::is_type(node)) { return false; } const std::shared_ptr multiply = const_cast(node.get())->shared_from_this(); - const auto dequantization = ngraph::pass::low_precision::NetworkHelper::getDequantization(multiply, 0, true); + const auto dequantization = ngraph::pass::low_precision::NetworkHelper::getDequantization(multiply, defaultPrecisions, 0, true); if (dequantization.empty()) { return false; } @@ -1292,7 +1299,10 @@ bool NetworkHelper::isQuantizeSupported(const std::shared_ptrget_levels()); } -FakeQuantizeDequantization NetworkHelper::getDequantization(const std::shared_ptr& node, const size_t parentIndex, const bool inPlace) { +FakeQuantizeDequantization NetworkHelper::getDequantization(const std::shared_ptr& node, + const std::vector defaultPrecisions, + const size_t parentIndex, + const bool inPlace) { auto getDataIndex = [](const std::shared_ptr& node) { if (ov::is_type(node->get_input_node_ptr(1))) { return 0ul; @@ -1342,7 +1352,6 @@ FakeQuantizeDequantization NetworkHelper::getDequantization(const std::shared_pt const std::shared_ptr convert = ov::as_type_ptr(dataNode.get_node_shared_ptr()); if (convert != nullptr) { - auto defaultPrecisions = LayerTransformation::getDefaultPrecisions(); auto el_type = convert->input(0).get_element_type(); auto foundIt = std::find(defaultPrecisions.begin(), defaultPrecisions.end(), el_type); if (foundIt == defaultPrecisions.end() && @@ -1575,14 +1584,15 @@ NetworkHelper::InsertDequantizationResult NetworkHelper::moveDequantizationAfter const std::shared_ptr& operation, const FakeQuantizeDequantization& dequantization, const bool updatePrecision, - const bool moveSubtract) { + const bool moveSubtract, + const std::vector& defaultPrecisions) { assert( - (NetworkHelper::getDequantization(operation).subtractConstant == nullptr) || - (NetworkHelper::getDequantization(operation).subtractConstant.get() == dequantization.subtractConstant.get())); + (NetworkHelper::getDequantization(operation, defaultPrecisions).subtractConstant == nullptr) || + (NetworkHelper::getDequantization(operation, defaultPrecisions).subtractConstant.get() == dequantization.subtractConstant.get())); assert( - (NetworkHelper::getDequantization(operation).multiplyConstant == nullptr) || - (NetworkHelper::getDequantization(operation).multiplyConstant.get() == dequantization.multiplyConstant.get())); + (NetworkHelper::getDequantization(operation, defaultPrecisions).multiplyConstant == nullptr) || + (NetworkHelper::getDequantization(operation, defaultPrecisions).multiplyConstant.get() == dequantization.multiplyConstant.get())); assert(operation->get_output_size() == 1); diff --git a/src/common/low_precision_transformations/src/normalize_l2.cpp b/src/common/low_precision_transformations/src/normalize_l2.cpp index d0a6c2e2254..4e53f099b76 100644 --- a/src/common/low_precision_transformations/src/normalize_l2.cpp +++ b/src/common/low_precision_transformations/src/normalize_l2.cpp @@ -58,7 +58,7 @@ bool NormalizeL2Transformation::canBeTransformed(const TransformationContext& co return false; } - const auto dequantization = NetworkHelper::getDequantization(operation); + const auto dequantization = NetworkHelper::getDequantization(operation, defaultPrecisions); if (dequantization.subtract != nullptr) { return false; } @@ -100,10 +100,10 @@ bool NormalizeL2Transformation::transform(TransformationContext &context, ngraph return false; } - auto normalize = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(operation)); + auto normalize = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(operation, defaultPrecisions)); const auto axes = ov::as_type_ptr(normalize->get_input_node_shared_ptr(1)); - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(normalize); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(normalize, defaultPrecisions); auto scalesConst = ov::as_type_ptr(dequantization.multiply->get_input_node_shared_ptr(1)); if (scalesConst == nullptr) { scalesConst = ov::as_type_ptr(dequantization.multiply->get_input_node_shared_ptr(0)); diff --git a/src/common/low_precision_transformations/src/pad.cpp b/src/common/low_precision_transformations/src/pad.cpp index 3b513a8d92f..8e2577e69bd 100644 --- a/src/common/low_precision_transformations/src/pad.cpp +++ b/src/common/low_precision_transformations/src/pad.cpp @@ -40,7 +40,7 @@ bool PadTransformation::transform(TransformationContext& context, ngraph::patter return false; } - const auto pad = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(m.get_match_root())); + const auto pad = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions)); const auto padConstant = ov::as_type_ptr(pad->get_input_node_shared_ptr(3)); const auto padConstantValue = padConstant->cast_vector()[0]; @@ -48,7 +48,7 @@ bool PadTransformation::transform(TransformationContext& context, ngraph::patter const auto padsEnd = pad->get_pads_end(); const auto padMode = pad->get_pad_mode(); - auto dequantization = NetworkHelper::getDequantization(pad); + auto dequantization = NetworkHelper::getDequantization(pad, defaultPrecisions); if (padMode == op::PadMode::CONSTANT) { auto bcastConstant = [&](const std::shared_ptr &constant) { @@ -162,7 +162,7 @@ bool PadTransformation::canBeTransformed(const TransformationContext& context, s return false; } - const auto dequantization = NetworkHelper::getDequantization(op); + const auto dequantization = NetworkHelper::getDequantization(op, defaultPrecisions); if (dequantization.empty()) { return false; } diff --git a/src/common/low_precision_transformations/src/prelu.cpp b/src/common/low_precision_transformations/src/prelu.cpp index 97591bbae4b..cf59617dd0e 100644 --- a/src/common/low_precision_transformations/src/prelu.cpp +++ b/src/common/low_precision_transformations/src/prelu.cpp @@ -40,8 +40,8 @@ bool PReluTransformation::transform(TransformationContext& context, ngraph::patt return false; } - prelu = NetworkHelper::separateInStandaloneBranch(prelu); - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(prelu, 0); + prelu = NetworkHelper::separateInStandaloneBranch(prelu, defaultPrecisions); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(prelu, defaultPrecisions, 0); moveDequantizationAfter(context, prelu, dequantization, false, false); return true; } @@ -55,7 +55,7 @@ bool PReluTransformation::canBeTransformed(const TransformationContext& context, return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, 0); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, defaultPrecisions, 0); if (dequantization.empty() || (dequantization.subtract != nullptr)) { return false; } diff --git a/src/common/low_precision_transformations/src/propagate_precisions.cpp b/src/common/low_precision_transformations/src/propagate_precisions.cpp index 952f356dabd..65e53f7e265 100644 --- a/src/common/low_precision_transformations/src/propagate_precisions.cpp +++ b/src/common/low_precision_transformations/src/propagate_precisions.cpp @@ -17,13 +17,15 @@ using namespace ngraph::pass::low_precision; NGRAPH_RTTI_DEFINITION(ngraph::pass::low_precision::PropagatePrecisions, "PropagatePrecisions", 0); +ngraph::pass::low_precision::PropagatePrecisions::PropagatePrecisions(const AttributeParameters& params) : params(params) {} + bool ngraph::pass::low_precision::PropagatePrecisions::run_on_model(const std::shared_ptr& f) { ngraph::pass::Manager manager; manager.set_per_pass_validation(false); std::shared_ptr precisionsPropagation = manager.register_pass(); - precisionsPropagation->add_matcher>(AttributeSource::OutputPort); - precisionsPropagation->add_matcher>(); - precisionsPropagation->add_matcher>(); + precisionsPropagation->add_matcher>(params, AttributeSource::OutputPort); + precisionsPropagation->add_matcher>(params.defaultPrecisions); + precisionsPropagation->add_matcher>(params.defaultPrecisions); manager.run_passes(f); return false; } diff --git a/src/common/low_precision_transformations/src/reduce_base_transformation.cpp b/src/common/low_precision_transformations/src/reduce_base_transformation.cpp index 0ad6748f3df..932dc8ed42f 100644 --- a/src/common/low_precision_transformations/src/reduce_base_transformation.cpp +++ b/src/common/low_precision_transformations/src/reduce_base_transformation.cpp @@ -18,8 +18,8 @@ bool ReduceBaseTransformation::transform(TransformationContext& context, ngraph: return false; } - const auto reduce = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - auto dequantization = NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(reduce)); + const auto reduce = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + auto dequantization = NetworkHelper::normalizeDequantization(NetworkHelper::getDequantization(reduce, defaultPrecisions)); // prepare dequantization to propagate changeDequantizationValues(reduce, dequantization); @@ -31,7 +31,7 @@ bool ReduceBaseTransformation::transform(TransformationContext& context, ngraph: } bool ReduceBaseTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr reduce) const { - const auto dequantization = NetworkHelper::getDequantization(reduce); + const auto dequantization = NetworkHelper::getDequantization(reduce, defaultPrecisions); if (dequantization.empty()) { return false; } diff --git a/src/common/low_precision_transformations/src/reduce_max.cpp b/src/common/low_precision_transformations/src/reduce_max.cpp index f558a0181f9..840c6db5c17 100644 --- a/src/common/low_precision_transformations/src/reduce_max.cpp +++ b/src/common/low_precision_transformations/src/reduce_max.cpp @@ -39,7 +39,7 @@ bool ReduceMaxTransformation::canBeTransformed(const TransformationContext& cont return false; } - const auto dequantization = NetworkHelper::getDequantization(reduce); + const auto dequantization = NetworkHelper::getDequantization(reduce, defaultPrecisions); const std::vector scales = ov::as_type_ptr(dequantization.multiplyConstant)->cast_vector(); if (std::any_of(scales.begin(), scales.end(), [](const float value) { return value < 0.0; })) { return false; diff --git a/src/common/low_precision_transformations/src/reduce_min.cpp b/src/common/low_precision_transformations/src/reduce_min.cpp index 4c6a9806f6f..8c3a12880f6 100644 --- a/src/common/low_precision_transformations/src/reduce_min.cpp +++ b/src/common/low_precision_transformations/src/reduce_min.cpp @@ -39,7 +39,7 @@ bool ReduceMinTransformation::canBeTransformed(const TransformationContext& cont return false; } - const auto dequantization = NetworkHelper::getDequantization(reduce); + const auto dequantization = NetworkHelper::getDequantization(reduce, defaultPrecisions); const std::vector scales = ov::as_type_ptr(dequantization.multiplyConstant)->cast_vector(); if (std::any_of(scales.begin(), scales.end(), [](const float value) { return value < 0.0; })) { return false; diff --git a/src/common/low_precision_transformations/src/reduce_sum.cpp b/src/common/low_precision_transformations/src/reduce_sum.cpp index 1aef47ca281..aba776b96b2 100644 --- a/src/common/low_precision_transformations/src/reduce_sum.cpp +++ b/src/common/low_precision_transformations/src/reduce_sum.cpp @@ -36,7 +36,7 @@ bool ReduceSumTransformation::canBeTransformed(const TransformationContext& cont return false; } - const auto dequantization = NetworkHelper::getDequantization(reduce); + const auto dequantization = NetworkHelper::getDequantization(reduce, defaultPrecisions); if (dequantization.subtract) { const auto reductionAxes = reduceSum->get_reduction_axes(); const auto inputPShape = dequantization.data.get_partial_shape(); diff --git a/src/common/low_precision_transformations/src/relu.cpp b/src/common/low_precision_transformations/src/relu.cpp index 02c5a0bfd0d..ac84d8b5795 100644 --- a/src/common/low_precision_transformations/src/relu.cpp +++ b/src/common/low_precision_transformations/src/relu.cpp @@ -40,8 +40,8 @@ bool ReluTransformation::transform(TransformationContext& context, ngraph::patte return false; } - relu = NetworkHelper::separateInStandaloneBranch(relu); - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(relu, 0); + relu = NetworkHelper::separateInStandaloneBranch(relu, defaultPrecisions); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(relu, defaultPrecisions, 0); moveDequantizationAfter(context, relu, dequantization, false, false); return true; } @@ -55,7 +55,7 @@ bool ReluTransformation::canBeTransformed(const TransformationContext& context, return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, 0); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, defaultPrecisions, 0); if (dequantization.empty() || (dequantization.subtract != nullptr)) { return false; } diff --git a/src/common/low_precision_transformations/src/reshape.cpp b/src/common/low_precision_transformations/src/reshape.cpp index 24fb29df1bb..04ec166e93d 100644 --- a/src/common/low_precision_transformations/src/reshape.cpp +++ b/src/common/low_precision_transformations/src/reshape.cpp @@ -56,7 +56,7 @@ ReshapeTransformation::ReshapeTransformation(const Params& params) : LayerTransf namespace { -void reshapeDequantizationConstant(const std::shared_ptr& reshape) { +void reshapeDequantizationConstant(const std::shared_ptr& reshape, const std::vector& defaultPrecisions) { // Reshape dequantization operation Constant. // 1. Calculate result dequantization Constant shape for broadcast based on original dequantization Constant shape and Reshape output. // For example: dequantization shape {1, 3, 1, 1}, output Reshape shape {1, 12, 3, 3}, result for broadcast: {1, 3, 4, 1}, @@ -132,7 +132,7 @@ void reshapeDequantizationConstant(const std::shared_ptr& resha replace_node(originalConstant, resultConstant); }; - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(reshape, 0); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(reshape, defaultPrecisions, 0); if (dequantization.subtract != nullptr) { replaceConstant(reshape, dequantization.subtractConstant); @@ -155,9 +155,9 @@ bool ReshapeTransformation::transform(TransformationContext& context, ngraph::pa return false; } - reshape = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(reshape)); - reshapeDequantizationConstant(reshape); - moveDequantizationAfter(context, reshape, NetworkHelper::getDequantization(reshape, 0), false); + reshape = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(reshape, defaultPrecisions)); + reshapeDequantizationConstant(reshape, defaultPrecisions); + moveDequantizationAfter(context, reshape, NetworkHelper::getDequantization(reshape, defaultPrecisions, 0), false); return true; } @@ -190,7 +190,7 @@ bool ReshapeTransformation::canBeTransformed(const TransformationContext& contex return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, defaultPrecisions); if (dequantization.empty()) { return false; } diff --git a/src/common/low_precision_transformations/src/rt_info/precisions_attribute.cpp b/src/common/low_precision_transformations/src/rt_info/precisions_attribute.cpp index 0a06d82e47c..5601a8f1843 100644 --- a/src/common/low_precision_transformations/src/rt_info/precisions_attribute.cpp +++ b/src/common/low_precision_transformations/src/rt_info/precisions_attribute.cpp @@ -25,8 +25,7 @@ ov::Any PrecisionsAttribute::create( const std::shared_ptr& node, const AttributeParameters& params) { auto& rt = ov::is_type(node) ? node->output(0).get_rt_info() : node->get_rt_info(); - return (rt[PrecisionsAttribute::get_type_info_static()] = PrecisionsAttribute( - ngraph::pass::low_precision::LayerTransformation::getDefaultPrecisions())); + return (rt[PrecisionsAttribute::get_type_info_static()] = PrecisionsAttribute(params.defaultPrecisions)); } void PrecisionsAttribute::merge(std::vector& attributes) { diff --git a/src/common/low_precision_transformations/src/rt_info/quantization_alignment_attribute.cpp b/src/common/low_precision_transformations/src/rt_info/quantization_alignment_attribute.cpp index 585a8e1eeb7..7906d50f879 100644 --- a/src/common/low_precision_transformations/src/rt_info/quantization_alignment_attribute.cpp +++ b/src/common/low_precision_transformations/src/rt_info/quantization_alignment_attribute.cpp @@ -37,7 +37,7 @@ ov::Any QuantizationAlignmentAttribute::create( const auto& input = node->input(index); auto inputNode = input.get_source_output().get_node_shared_ptr(); - const auto dequantization = NetworkHelper::getDequantization(node, index); + const auto dequantization = NetworkHelper::getDequantization(node, params.defaultPrecisions, index); if (!dequantization.empty() && (ov::is_type(dequantization.data.get_node())) && ov::is_type(dequantization.data.get_node()->get_input_node_ptr(0))) { diff --git a/src/common/low_precision_transformations/src/shuffle_channels.cpp b/src/common/low_precision_transformations/src/shuffle_channels.cpp index 0a46f013c9c..33c9f4fbc61 100644 --- a/src/common/low_precision_transformations/src/shuffle_channels.cpp +++ b/src/common/low_precision_transformations/src/shuffle_channels.cpp @@ -38,8 +38,8 @@ bool ShuffleChannelsTransformation::transform(TransformationContext& context, ng return false; } - const auto shuffleChannels = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(m.get_match_root())); - auto dequantization = NetworkHelper::getDequantization(shuffleChannels); + const auto shuffleChannels = ov::as_type_ptr(NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions)); + auto dequantization = NetworkHelper::getDequantization(shuffleChannels, defaultPrecisions); const auto shuffleDequantizationConstant = [&](const std::shared_ptr& eltwise) { const auto normalizedConst = NetworkHelper::normalizeDequantizationShape(eltwise); @@ -87,7 +87,7 @@ bool ShuffleChannelsTransformation::canBeTransformed(const TransformationContext return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(shuffleChannels); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(shuffleChannels, defaultPrecisions); if (dequantization.empty()) { return false; } diff --git a/src/common/low_precision_transformations/src/split.cpp b/src/common/low_precision_transformations/src/split.cpp index 88825468c7e..9e4168b8753 100644 --- a/src/common/low_precision_transformations/src/split.cpp +++ b/src/common/low_precision_transformations/src/split.cpp @@ -35,8 +35,8 @@ bool SplitTransformation::transform(TransformationContext& context, ngraph::patt return false; } - const auto split = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - const auto dequantization = NetworkHelper::getDequantization(split); + const auto split = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + const auto dequantization = NetworkHelper::getDequantization(split, defaultPrecisions); OutputVector inputs = split->input_values(); inputs[0] = dequantization.data; @@ -153,7 +153,7 @@ bool SplitTransformation::isPrecisionPreserved(std::shared_ptr layer) cons } bool SplitTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { - if (!LayerTransformation::canBeTransformed(context, layer) || NetworkHelper::getDequantization(layer).empty()) { + if (!LayerTransformation::canBeTransformed(context, layer) || NetworkHelper::getDequantization(layer, defaultPrecisions).empty()) { return false; } diff --git a/src/common/low_precision_transformations/src/squeeze.cpp b/src/common/low_precision_transformations/src/squeeze.cpp index b124e90516c..ded0cf4325a 100644 --- a/src/common/low_precision_transformations/src/squeeze.cpp +++ b/src/common/low_precision_transformations/src/squeeze.cpp @@ -53,8 +53,8 @@ bool SqueezeTransformation::transform(TransformationContext& context, ngraph::pa return dequantizationOpConstant; }; - const std::shared_ptr squeeze = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(squeeze); + const std::shared_ptr squeeze = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(squeeze, defaultPrecisions); if (dequantization.multiply != nullptr) { auto newConstant = squeezeOnConstant(squeeze, dequantization.multiplyConstant, dequantization.data.get_partial_shape()); @@ -66,7 +66,7 @@ bool SqueezeTransformation::transform(TransformationContext& context, ngraph::pa replace_node(dequantization.subtractConstant, newConstant); } - moveDequantizationAfter(context, squeeze, NetworkHelper::getDequantization(squeeze), false); + moveDequantizationAfter(context, squeeze, NetworkHelper::getDequantization(squeeze, defaultPrecisions), false); return true; } @@ -75,7 +75,7 @@ bool SqueezeTransformation::isPrecisionPreserved(std::shared_ptr layer) co } bool SqueezeTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { - return (!NetworkHelper::getDequantization(layer).empty()) && LayerTransformation::canBeTransformed(context, layer); + return (!NetworkHelper::getDequantization(layer, defaultPrecisions).empty()) && LayerTransformation::canBeTransformed(context, layer); } } // namespace low_precision diff --git a/src/common/low_precision_transformations/src/strided_slice.cpp b/src/common/low_precision_transformations/src/strided_slice.cpp index e5e26823129..436fc5f8632 100644 --- a/src/common/low_precision_transformations/src/strided_slice.cpp +++ b/src/common/low_precision_transformations/src/strided_slice.cpp @@ -101,8 +101,8 @@ bool StridedSliceTransformation::transform(TransformationContext& context, ngrap return false; } - const auto stridedSlice = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - auto dequantization = NetworkHelper::getDequantization(stridedSlice); + const auto stridedSlice = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + auto dequantization = NetworkHelper::getDequantization(stridedSlice, defaultPrecisions); if (dequantization.subtract) { const auto newSubConst = stridedSliceDeqConstant(stridedSlice, dequantization.subtractConstant); @@ -114,7 +114,7 @@ bool StridedSliceTransformation::transform(TransformationContext& context, ngrap replace_node(dequantization.multiplyConstant, newMulConst); dequantization.multiplyConstant = newMulConst; - moveDequantizationAfter(context, stridedSlice, NetworkHelper::getDequantization(stridedSlice), false); + moveDequantizationAfter(context, stridedSlice, NetworkHelper::getDequantization(stridedSlice, defaultPrecisions), false); return true; } diff --git a/src/common/low_precision_transformations/src/subtract.cpp b/src/common/low_precision_transformations/src/subtract.cpp index 08590ba562a..069018ab846 100644 --- a/src/common/low_precision_transformations/src/subtract.cpp +++ b/src/common/low_precision_transformations/src/subtract.cpp @@ -49,7 +49,7 @@ bool SubtractTransformation::transform(TransformationContext& context, ngraph::p const ngraph::element::Type originalPrecision = subtract->get_output_element_type(0); - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(subtract); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(subtract, defaultPrecisions); if (dequantization.multiply != nullptr) { // before: Y = X * SC - SH, after: Y = (X - SH') * SC // X * SC - SH = X * SC - SH' * SC diff --git a/src/common/low_precision_transformations/src/transparent_base_transformation.cpp b/src/common/low_precision_transformations/src/transparent_base_transformation.cpp index 3a79aca2291..3236d841e66 100644 --- a/src/common/low_precision_transformations/src/transparent_base_transformation.cpp +++ b/src/common/low_precision_transformations/src/transparent_base_transformation.cpp @@ -19,8 +19,8 @@ bool TransparentBaseTransformation::transform(TransformationContext& context, ng return false; } - op = NetworkHelper::separateInStandaloneBranch(op); - moveDequantizationAfter(context, op, NetworkHelper::getDequantization(op), true); + op = NetworkHelper::separateInStandaloneBranch(op, defaultPrecisions); + moveDequantizationAfter(context, op, NetworkHelper::getDequantization(op, defaultPrecisions), true); return true; } diff --git a/src/common/low_precision_transformations/src/transpose.cpp b/src/common/low_precision_transformations/src/transpose.cpp index ee4cb8dfd78..80f86fa8f87 100644 --- a/src/common/low_precision_transformations/src/transpose.cpp +++ b/src/common/low_precision_transformations/src/transpose.cpp @@ -35,8 +35,8 @@ TransposeTransformation::TransposeTransformation(const Params& params) : LayerTr namespace { -void transposeDequantizationConstant(std::shared_ptr& transpose) { - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(transpose); +void transposeDequantizationConstant(std::shared_ptr& transpose, const std::vector& defaultPrecisions) { + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(transpose, defaultPrecisions); const Shape subtractShape = dequantization.subtract == nullptr ? Shape{} : dequantization.subtractConstant->get_shape(); const Shape multiplyShape = dequantization.multiply == nullptr ? Shape{} : dequantization.multiplyConstant->get_shape(); @@ -89,9 +89,9 @@ bool TransposeTransformation::transform(TransformationContext& context, ngraph:: return false; } - transpose = NetworkHelper::separateInStandaloneBranch(transpose); - transposeDequantizationConstant(transpose); - moveDequantizationAfter(context, transpose, NetworkHelper::getDequantization(transpose, 0), false); + transpose = NetworkHelper::separateInStandaloneBranch(transpose, defaultPrecisions); + transposeDequantizationConstant(transpose, defaultPrecisions); + moveDequantizationAfter(context, transpose, NetworkHelper::getDequantization(transpose, defaultPrecisions, 0), false); return true; } @@ -109,7 +109,7 @@ bool TransposeTransformation::canBeTransformed(const TransformationContext& cont return false; } - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(op, defaultPrecisions); const bool isPerTensor = [&] { if (dequantization.subtractConstant != nullptr) { if (!NetworkHelper::isScalarLike(dequantization.subtractConstant)) { diff --git a/src/common/low_precision_transformations/src/unsqueeze.cpp b/src/common/low_precision_transformations/src/unsqueeze.cpp index 0c876a74799..0a662420fc4 100644 --- a/src/common/low_precision_transformations/src/unsqueeze.cpp +++ b/src/common/low_precision_transformations/src/unsqueeze.cpp @@ -55,8 +55,8 @@ bool UnsqueezeTransformation::transform(TransformationContext& context, ngraph:: }; - const std::shared_ptr unsqueeze = NetworkHelper::separateInStandaloneBranch(m.get_match_root()); - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(unsqueeze); + const std::shared_ptr unsqueeze = NetworkHelper::separateInStandaloneBranch(m.get_match_root(), defaultPrecisions); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(unsqueeze, defaultPrecisions); if (dequantization.multiply != nullptr) { auto newConstant = unsqueezeOnConstant(unsqueeze, dequantization.multiplyConstant, dequantization.data.get_partial_shape()); @@ -68,7 +68,7 @@ bool UnsqueezeTransformation::transform(TransformationContext& context, ngraph:: replace_node(dequantization.subtractConstant, newConstant); } - moveDequantizationAfter(context, unsqueeze, NetworkHelper::getDequantization(unsqueeze), false); + moveDequantizationAfter(context, unsqueeze, NetworkHelper::getDequantization(unsqueeze, defaultPrecisions), false); return true; } @@ -77,7 +77,7 @@ bool UnsqueezeTransformation::isPrecisionPreserved(std::shared_ptr layer) } bool UnsqueezeTransformation::canBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { - return (!NetworkHelper::getDequantization(layer).empty()) && LayerTransformation::canBeTransformed(context, layer); + return (!NetworkHelper::getDequantization(layer, defaultPrecisions).empty()) && LayerTransformation::canBeTransformed(context, layer); } diff --git a/src/common/low_precision_transformations/src/weightable_layer_transformation.cpp b/src/common/low_precision_transformations/src/weightable_layer_transformation.cpp index 544dc3fc869..e94a6743ebd 100644 --- a/src/common/low_precision_transformations/src/weightable_layer_transformation.cpp +++ b/src/common/low_precision_transformations/src/weightable_layer_transformation.cpp @@ -16,12 +16,13 @@ namespace low_precision { WeightableLayerTransformation::WeightableLayerTransformation(const Params& params) : LayerTransformation(params) {} -bool WeightableLayerTransformation::canConvolutionBeTransformed(const TransformationContext& context, std::shared_ptr layer) const { +bool WeightableLayerTransformation::canConvolutionBeTransformed(const TransformationContext& context, std::shared_ptr layer, + const std::vector& defaultPrecisions) const { if (!WeightableLayerTransformation::canBeTransformed(context, layer)) { return false; } - FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer); + FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions); if (!canSubtractBeHandled(layer, dequantization)) { return false; } @@ -36,12 +37,12 @@ bool WeightableLayerTransformation::canConvolutionBeTransformed(const Transforma std::shared_ptr reshapeFromWeights = ov::as_type_ptr(layer->get_input_node_shared_ptr(1)); dequantization = reshapeFromWeights == nullptr ? - NetworkHelper::getDequantization(layer, 1ul) : - NetworkHelper::getDequantization(reshapeFromWeights); + NetworkHelper::getDequantization(layer, defaultPrecisions, 1ul) : + NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions); if (dequantization.empty()) { const auto fqOnWeights = getFakeQuantizeOnWeights(layer); - const auto dataPrecision = getDataPrecisionOnWeights(layer); + const auto dataPrecision = getDataPrecisionOnWeights(layer, defaultPrecisions); if ((dataPrecision.precision == ngraph::element::undefined) || (!NetworkHelper::checkZeroPoint(fqOnWeights, dataPrecision))) { return false; } @@ -65,7 +66,7 @@ bool WeightableLayerTransformation::canBeTransformed(const TransformationContext } if (isGroup(layer)) { - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions); if (dequantization.empty()) { return false; } @@ -101,7 +102,7 @@ bool WeightableLayerTransformation::canBeTransformed(const TransformationContext } } } else { - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions); if (dequantization.multiply == nullptr) { return false; } @@ -140,13 +141,13 @@ bool WeightableLayerTransformation::canBeTransformed(const TransformationContext if (reshapeFromWeights == nullptr) { fqFromWeights = ov::as_type_ptr(layer->get_input_node_shared_ptr(1)); if (fqFromWeights == nullptr) { - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, 1ul); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(layer, defaultPrecisions, 1ul); fqFromWeights = ov::as_type_ptr(dequantization.data.get_node_shared_ptr()); } } else { fqFromWeights = ov::as_type_ptr(reshapeFromWeights->get_input_node_shared_ptr(0)); if (fqFromWeights == nullptr) { - const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(reshapeFromWeights, 0ul); + const FakeQuantizeDequantization dequantization = NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions, 0ul); fqFromWeights = ov::as_type_ptr(dequantization.data.get_node_shared_ptr()); } } @@ -182,8 +183,8 @@ bool WeightableLayerTransformation::canBeTransformed(const TransformationContext } else { // TODO: LPT: is it possible to share with isQuantized? const FakeQuantizeDequantization dequantizationOnWeights = reshapeFromWeights == nullptr ? - NetworkHelper::getDequantization(layer, 1ul) : - NetworkHelper::getDequantization(reshapeFromWeights, 0ul); + NetworkHelper::getDequantization(layer, defaultPrecisions, 1ul) : + NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions, 0ul); if (dequantizationOnWeights.empty()) { return false; } @@ -223,7 +224,9 @@ bool WeightableLayerTransformation::canBeTransformed(const TransformationContext return true; } -bool WeightableLayerTransformation::isQuantizedStatic(const std::shared_ptr& layer, const bool reshapeIsRequired) { +bool WeightableLayerTransformation::isQuantizedStatic(const std::shared_ptr& layer, + const bool reshapeIsRequired, + const std::vector& defaultPrecisions) { FakeQuantizeDequantization dequantizationOnWeights; if (reshapeIsRequired) { const auto reshape = layer->get_input_node_shared_ptr(1); @@ -236,14 +239,14 @@ bool WeightableLayerTransformation::isQuantizedStatic(const std::shared_ptr(layer->get_input_node_shared_ptr(1))) { const std::shared_ptr fq = ov::as_type_ptr(layer->get_input_node_shared_ptr(1)); return NetworkHelper::isQuantizeSupported(fq); } else { // TODO: update NetworkHelper API later const std::shared_ptr op = const_cast(layer.get())->shared_from_this(); - dequantizationOnWeights = NetworkHelper::getDequantization(op, 1); + dequantizationOnWeights = NetworkHelper::getDequantization(op, defaultPrecisions, 1); } if (dequantizationOnWeights.empty()) { @@ -300,7 +303,7 @@ bool WeightableLayerTransformation::decomposeFakeQuantizeForWeightsPath(const st const QuantizationDetails quantizationDetails = QuantizationDetails::getDetails(fq); const auto precisionsAttribute = getAttributeFromOutput(fq); const auto precisions = precisionsAttribute.empty() ? - getDefaultPrecisions() : + defaultPrecisions : precisionsAttribute.as().value(); const DataPrecision dataPrecision = getDataPrecision(fq, quantizationDetails, precisions); @@ -361,7 +364,9 @@ std::shared_ptr WeightableLayerTransformation::getFakeQuan return fq; } -DataPrecision WeightableLayerTransformation::getDataPrecisionOnWeights(const std::shared_ptr& node) { +DataPrecision WeightableLayerTransformation::getDataPrecisionOnWeights( + const std::shared_ptr& node, + const std::vector& defaultPrecisions) { const auto fq = getFakeQuantizeOnWeights(node); const QuantizationDetails quantizationDetails = QuantizationDetails::getDetails(fq); if (quantizationDetails.empty()) { @@ -370,22 +375,24 @@ DataPrecision WeightableLayerTransformation::getDataPrecisionOnWeights(const std const auto precisionsAttribute = getAttributeFromOutput(fq); const auto precisions = precisionsAttribute.empty() ? - getDefaultPrecisions() : + defaultPrecisions : precisionsAttribute.as().value(); return getDataPrecision(fq, quantizationDetails, precisions); } -bool WeightableLayerTransformation::isAsymmetricOnWeights(const std::shared_ptr& node) { +bool WeightableLayerTransformation::isAsymmetricOnWeights( + const std::shared_ptr& node, + const std::vector& defaultPrecisions) { const auto n = const_cast(node.get())->shared_from_this(); const auto reshapeFromWeights = ngraph::as_type_ptr(n->get_input_node_shared_ptr(1)); const auto dequantization = reshapeFromWeights == nullptr ? - NetworkHelper::getDequantization(n, 1ul) : - NetworkHelper::getDequantization(reshapeFromWeights); + NetworkHelper::getDequantization(n, defaultPrecisions, 1ul) : + NetworkHelper::getDequantization(reshapeFromWeights, defaultPrecisions); if (dequantization.empty()) { - const auto dataPrecision = WeightableLayerTransformation::getDataPrecisionOnWeights(n); + const auto dataPrecision = WeightableLayerTransformation::getDataPrecisionOnWeights(n, defaultPrecisions); if (dataPrecision.empty()) { return false; } diff --git a/src/plugins/intel_cpu/src/mkldnn_plugin.cpp b/src/plugins/intel_cpu/src/mkldnn_plugin.cpp index 935b6bd4f99..ba293c95d48 100644 --- a/src/plugins/intel_cpu/src/mkldnn_plugin.cpp +++ b/src/plugins/intel_cpu/src/mkldnn_plugin.cpp @@ -174,9 +174,17 @@ static void TransformationUpToCPUSpecificOpSet(const std::shared_ptr{}; + bool hasINT16orINT32Levels = false; if (useLpt) { - manager.register_pass( - std::vector{ ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4 }); + hasINT16orINT32Levels = ngraph::pass::low_precision::LowPrecision::isFQLevelsPresent( + nGraphFunc, + {ngraph::pass::low_precision::levels::int16, ngraph::pass::low_precision::levels::int16_narrow_range, + ngraph::pass::low_precision::levels::int32, ngraph::pass::low_precision::levels::int32_narrow_range}); + if (hasINT16orINT32Levels) { + defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_int16_int32_support; + } + manager.register_pass(defaultPrecisions); } auto get_convert_precisions = []() { precisions_array array = { @@ -220,8 +228,7 @@ static void TransformationUpToCPUSpecificOpSet(const std::shared_ptr(); if (useLpt) { - manager.register_pass( - std::vector{ ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4 }); + manager.register_pass(defaultPrecisions); } manager.register_pass(); manager.register_pass(precisions); @@ -423,12 +430,12 @@ static void TransformationUpToCPUSpecificOpSet(const std::shared_ptrset_callback([](const_node_ptr &node) -> bool { - return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node); + pass_config->set_callback([&defaultPrecisions](const_node_ptr &node) -> bool { + return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node, defaultPrecisions); }); - pass_config->set_callback([](const_node_ptr &node) -> bool { - return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node); + pass_config->set_callback([&defaultPrecisions](const_node_ptr &node) -> bool { + return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node, defaultPrecisions); }); } @@ -468,28 +475,26 @@ static void TransformationUpToCPUSpecificOpSet(const std::shared_ptr({}); } ngraph::pass::Manager lptManager; - lptManager.register_pass(supportedPrecisions, perTensorQuantization, - LayerTransformation::Params(updatePrecision)); + lptManager.register_pass( + supportedPrecisions, + perTensorQuantization, + LayerTransformation::Params(updatePrecision, ngraph::element::f32, defaultPrecisions)); lptManager.get_pass_config()->set_callback([](const_node_ptr& node) -> bool { if (const auto mulitply = std::dynamic_pointer_cast(node)) { return !MultiplyToGroupConvolutionTransformation::canBeTransformedToGroupConvolution(mulitply); } return false; }); - lptManager.get_pass_config()->set_callback([](const_node_ptr& node) -> bool { - return LayerTransformation::isAsymmetricQuantization(node) || WeightableLayerTransformation::isAsymmetricOnWeights(node); + lptManager.get_pass_config()->set_callback( + [&defaultPrecisions](const_node_ptr& node) -> bool { + return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) || + WeightableLayerTransformation::isAsymmetricOnWeights(node, defaultPrecisions); }); lptManager.get_pass_config()->set_callback([](const_node_ptr& node) -> bool { return MultiplyToGroupConvolutionTransformation::isDynamicOrScalar(node); diff --git a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp index 76da6e52693..94950e2bb92 100644 --- a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp +++ b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp @@ -110,6 +110,7 @@ void TransformationsPipeline::apply(std::shared_ptr func) { using const_node_ptr = const std::shared_ptr; bool use_onednn = false; + const auto defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_support; #ifdef ENABLE_ONEDNN_FOR_GPU use_onednn = device_info.supports_immad; #endif @@ -322,12 +323,12 @@ void TransformationsPipeline::apply(std::shared_ptr func) { pass_config->enable(); if (enableInt8) { - pass_config->set_callback([](const_node_ptr &node) -> bool { - return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node); + pass_config->set_callback([&defaultPrecisions](const_node_ptr &node) -> bool { + return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node, defaultPrecisions); }); - pass_config->set_callback([](const_node_ptr &node) -> bool { - return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node); + pass_config->set_callback([&defaultPrecisions](const_node_ptr &node) -> bool { + return ngraph::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForSubtract(node, defaultPrecisions); }); } @@ -375,8 +376,8 @@ void TransformationsPipeline::apply(std::shared_ptr func) { } return false; }); - lptPassConfig->set_callback([](const_node_ptr& node) -> bool { - auto fillStaticChannel = [](const ngraph::PartialShape& shape, size_t& channel) -> bool { + lptPassConfig->set_callback([func, defaultPrecisions](const_node_ptr& node) -> bool { + auto fillStaticChannel = [func](const ngraph::PartialShape& shape, size_t& channel) -> bool { const auto rank = shape.rank(); if (rank.is_dynamic()) { return false; @@ -407,7 +408,8 @@ void TransformationsPipeline::apply(std::shared_ptr func) { return true; } - return LayerTransformation::isAsymmetricQuantization(node) || WeightableLayerTransformation::isAsymmetricOnWeights(node); + return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) + || WeightableLayerTransformation::isAsymmetricOnWeights(node, defaultPrecisions); }); if (!use_onednn) { @@ -419,7 +421,7 @@ void TransformationsPipeline::apply(std::shared_ptr func) { lptPassConfig->set_callback([&](const_node_ptr& node) -> bool { // disable MultiplyToGroupConvolution if Multiply with Constant can be fused - const auto dequantization = NetworkHelper::getDequantization(node, 0, true); + const auto dequantization = NetworkHelper::getDequantization(node, defaultPrecisions, 0, true); std::shared_ptr parent = dequantization.empty() ? nullptr : dequantization.data.get_node()->shared_from_this(); if (parent == nullptr) { const auto constantNode = NetworkHelper::getConstantInput(node); @@ -448,7 +450,7 @@ void TransformationsPipeline::apply(std::shared_ptr func) { return false; }); - auto params = LayerTransformation::Params(true, element::f32, true); + auto params = LayerTransformation::Params(true, element::f32, defaultPrecisions, true); lptManager.register_pass(supportedPrecisions, perTensorQuantization, params); lptManager.run_passes(func); } diff --git a/src/tests/functional/inference_engine/lp_transformations/assign_and_read_value_transformation.cpp b/src/tests/functional/inference_engine/lp_transformations/assign_and_read_value_transformation.cpp index 69d5ae58527..b4b53bdf9d1 100644 --- a/src/tests/functional/inference_engine/lp_transformations/assign_and_read_value_transformation.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/assign_and_read_value_transformation.cpp @@ -60,11 +60,10 @@ public: const element::Type precisionBeforeDequantization = std::get<2>(GetParam()); const size_t opsetVersion = std::get<3>(GetParam()); const AssignTransformationTestValues testValues = std::get<4>(GetParam()); - low_precision::LayerTransformation::setDefaultPrecisions({ - ngraph::element::u8, ngraph::element::i8, - ngraph::element::u16, ngraph::element::i16, - ngraph::element::u32, ngraph::element::i32 - }); + const std::vector defaultPrecisions = low_precision::precision_set::int8_int16_int32_support; + const auto params = TestTransformationParams(testValues.params) + .setDefaultPrecisions(defaultPrecisions); + actualFunction = ngraph::builder::subgraph::AssignAndReadValueFunction::getOriginal( inputShape, precision, @@ -74,8 +73,8 @@ public: testValues.actual.constantValue, testValues.actual.dequantization); - SimpleLowPrecisionTransformer transformer; - transformer.add(actualFunction, testValues.params); + SimpleLowPrecisionTransformer transformer({}, {}, { ngraph::element::f32, defaultPrecisions }); + transformer.add(actualFunction, params); transformer.transform(actualFunction); referenceFunction = ngraph::builder::subgraph::AssignAndReadValueFunction::getReference( diff --git a/src/tests/functional/inference_engine/lp_transformations/concat_with_not_quantized_parent_transformation.cpp b/src/tests/functional/inference_engine/lp_transformations/concat_with_not_quantized_parent_transformation.cpp index f51e19aa199..5efb83c36fa 100644 --- a/src/tests/functional/inference_engine/lp_transformations/concat_with_not_quantized_parent_transformation.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/concat_with_not_quantized_parent_transformation.cpp @@ -173,10 +173,10 @@ public: ngraph::pass::Manager manager; manager.register_pass(precisionsRestrictions); manager.register_pass(quantizationRestrictions); - manager.register_pass(); + manager.register_pass(params.defaultPrecisions); manager.register_pass(); - manager.register_pass(); - manager.register_pass(); + manager.register_pass(params.defaultPrecisions); + manager.register_pass(params.defaultPrecisions); std::shared_ptr common = manager.register_pass(); common->add_matcher(legacyParams); diff --git a/src/tests/functional/inference_engine/lp_transformations/convolution_backprop_data_transformation.cpp b/src/tests/functional/inference_engine/lp_transformations/convolution_backprop_data_transformation.cpp index af49f9fa82e..ea4f6edc2a1 100644 --- a/src/tests/functional/inference_engine/lp_transformations/convolution_backprop_data_transformation.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/convolution_backprop_data_transformation.cpp @@ -480,7 +480,10 @@ const std::vector testValues = {{ngraph::element::f32}, {128.f}, {0.01f}}, { 255ul, Shape({ 1, 2, 1, 1 }), { 0.f }, { 254.f }, { 0.f }, { 25.4f } }, op::Constant::create(ngraph::element::i8, ngraph::Shape{}, std::vector{ 2.f }), - low_precision::LayerTransformation::isAsymmetricQuantization + [](const_node_ptr& node) { + return low_precision::LayerTransformation::isAsymmetricQuantization(node, + { ngraph::element::u8, ngraph::element::i8 }); + } }, // ExpectedValues { diff --git a/src/tests/functional/inference_engine/lp_transformations/fake_quantize_transformation.cpp b/src/tests/functional/inference_engine/lp_transformations/fake_quantize_transformation.cpp index 204d865c382..adbae5fac71 100644 --- a/src/tests/functional/inference_engine/lp_transformations/fake_quantize_transformation.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/fake_quantize_transformation.cpp @@ -71,17 +71,16 @@ public: const ngraph::PartialShape shape = std::get<1>(GetParam()); const bool updatePrecision = std::get<2>(GetParam()); const FakeQuantizeTransformationTestValues fakeQuantizeOnData = std::get<3>(GetParam()); - - const auto params = TestTransformationParams(fakeQuantizeOnData.params).setUpdatePrecisions(updatePrecision); + std::vector defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_support; if (fakeQuantizeOnData.actual.quantizationLevel != 256) { - low_precision::LowPrecision::setDefaultPrecisions({ - ngraph::element::u8, ngraph::element::i8, - ngraph::element::u16, ngraph::element::i16, - ngraph::element::u32, ngraph::element::i32 - }); + defaultPrecisions = ngraph::pass::low_precision::precision_set::int8_int16_int32_support; } + const auto params = TestTransformationParams(fakeQuantizeOnData.params) + .setUpdatePrecisions(updatePrecision) + .setDefaultPrecisions(defaultPrecisions); + actualFunction = ngraph::builder::subgraph::FakeQuantizeFunction::getOriginal( TestTransformationParams::toParams(fakeQuantizeOnData.params), precision, @@ -93,7 +92,7 @@ public: ngraph::pass::low_precision::OperationPrecisionRestriction::create({{0, params.precisionsOnActivations}}) }); - SimpleLowPrecisionTransformer transform(supportedPrecisions); + SimpleLowPrecisionTransformer transform(supportedPrecisions, {}, { ngraph::element::f32, defaultPrecisions }); transform.add(params); transform.add(params); transform.transform(actualFunction); diff --git a/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_dequantization.cpp b/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_dequantization.cpp index 384c2874acd..d69e755ced1 100644 --- a/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_dequantization.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_dequantization.cpp @@ -79,7 +79,8 @@ TEST_P(IsAsymmetricOnWeightsDequantizationTransformation, CompareFunctions) { IsAsymmetricOnWeightsDequantizationTestValues testValues = std::get<2>(GetParam()); - const auto isAsymmetricOnWeights = ngraph::pass::low_precision::WeightableLayerTransformation::isAsymmetricOnWeights(convolutions[0]); + const auto isAsymmetricOnWeights = ngraph::pass::low_precision::WeightableLayerTransformation::isAsymmetricOnWeights(convolutions[0], + testValues.params.defaultPrecisions); ASSERT_EQ(testValues.isAsymmetricOnWeights, isAsymmetricOnWeights); } diff --git a/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_fq.cpp b/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_fq.cpp index 8a1d5561ada..1aaeb5ebf38 100644 --- a/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_fq.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/is_asymmetric_on_weights_fq.cpp @@ -89,7 +89,9 @@ TEST_P(IsAsymmetricOnWeightsFakeQuantizeTransformation, CompareFunctions) { const auto convolutions = LayerTransformation::get(actualFunction); ASSERT_TRUE(convolutions.size() == 1ul) << "convolution was not found"; - const auto isAsymmetricOnWeights = ngraph::pass::low_precision::WeightableLayerTransformation::isAsymmetricOnWeights(convolutions[0]); + auto defaultPrecisions = std::get<2>(GetParam()).params.defaultPrecisions; + const auto isAsymmetricOnWeights = ngraph::pass::low_precision::WeightableLayerTransformation::isAsymmetricOnWeights(convolutions[0], + defaultPrecisions); std::pair, bool> transposeAndIsAsymmetricOnWeights = std::get<3>(GetParam()); ASSERT_EQ(transposeAndIsAsymmetricOnWeights.second, isAsymmetricOnWeights); } diff --git a/src/tests/functional/inference_engine/lp_transformations/layer_transformation.cpp b/src/tests/functional/inference_engine/lp_transformations/layer_transformation.cpp index 0828040c5f8..06480050453 100644 --- a/src/tests/functional/inference_engine/lp_transformations/layer_transformation.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/layer_transformation.cpp @@ -18,14 +18,16 @@ TestTransformationParams::TestTransformationParams( bool supportAsymmetricQuantization, element::Type deqPrecision, bool support3DTensorOnActivations, - bool deconvolutionSpecificChannelsRatio) : + bool deconvolutionSpecificChannelsRatio, + const std::vector defaultPrecisions) : updatePrecisions(updatePrecisions), precisionsOnActivations(precisionsOnActivations), precisionsOnWeights(precisionsOnWeights), supportAsymmetricQuantization(supportAsymmetricQuantization), deqPrecision(deqPrecision), support3DTensorOnActivations(support3DTensorOnActivations), - deconvolutionSpecificChannelsRatio(deconvolutionSpecificChannelsRatio) { + deconvolutionSpecificChannelsRatio(deconvolutionSpecificChannelsRatio), + defaultPrecisions(defaultPrecisions) { if (precisionsOnActivations.size() == 0ul) { THROW_TRANSFORMATION_EXCEPTION << "precisions on activations are not specisifed"; } @@ -65,6 +67,11 @@ TestTransformationParams& TestTransformationParams::setDeconvolutionSpecificChan return *this; } +TestTransformationParams& TestTransformationParams::setDefaultPrecisions(const std::vector& defaultPrecisions) { + this->defaultPrecisions = defaultPrecisions; + return *this; +} + TestTransformationParams LayerTransformation::createParamsU8U8() { return TestTransformationParams(true, { ngraph::element::u8 }, { ngraph::element::u8 }); } @@ -84,7 +91,8 @@ TestTransformationParams LayerTransformation::createParamsU8I8AndI8() { pass::low_precision::LayerTransformation::Params TestTransformationParams::toParams(const TestTransformationParams& params) { return low_precision::LayerTransformation::Params( params.updatePrecisions, - params.deqPrecision); + params.deqPrecision, + params.defaultPrecisions); } std::string LayerTransformation::toString(const TestTransformationParams& params) { diff --git a/src/tests/functional/inference_engine/lp_transformations/layer_transformation.hpp b/src/tests/functional/inference_engine/lp_transformations/layer_transformation.hpp index fffebfc2888..ae546354a1f 100644 --- a/src/tests/functional/inference_engine/lp_transformations/layer_transformation.hpp +++ b/src/tests/functional/inference_engine/lp_transformations/layer_transformation.hpp @@ -27,7 +27,8 @@ struct TestTransformationParams { bool supportAsymmetricQuantization = true, element::Type deqPrecision = element::f32, bool support3DTensorOnActivations = true, - bool deconvolutionSpecificChannelsRatio = false); + bool deconvolutionSpecificChannelsRatio = false, + std::vector defaultPrecisions = { element::u8, element::i8 }); TestTransformationParams& setUpdatePrecisions(const bool updatePrecisions); TestTransformationParams& setSupportAsymmetricQuantization(const bool supportAsymmetricQuantization); @@ -35,6 +36,7 @@ struct TestTransformationParams { TestTransformationParams& setPrecisionsOnWeights(const std::vector& precisionsOnWeights); TestTransformationParams& setSupport3DTensorOnActivations(const bool support3DTensorOnActivations); TestTransformationParams& setDeconvolutionSpecificChannelsRatio(const bool deconvolutionSpecificChannelsRatio); + TestTransformationParams& setDefaultPrecisions(const std::vector& defaultPrecisions); static pass::low_precision::LayerTransformation::Params toParams(const TestTransformationParams& params); @@ -45,6 +47,7 @@ struct TestTransformationParams { element::Type deqPrecision; bool support3DTensorOnActivations; bool deconvolutionSpecificChannelsRatio; + std::vector defaultPrecisions; }; class LayerTransformation : public CommonTestUtils::TestsCommon { diff --git a/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.cpp b/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.cpp index 90ff741e3fd..fcb138e3b3c 100644 --- a/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.cpp +++ b/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.cpp @@ -22,18 +22,19 @@ OPENVINO_SUPPRESS_DEPRECATED_START SimpleLowPrecisionTransformer::SimpleLowPrecisionTransformer( const std::vector& precisionRestrictions, - const std::vector& quantizationRestrictions) { + const std::vector& quantizationRestrictions, + const AttributeParameters& params) { auto passConfig = get_pass_config(); // TODO: use one pass manager markup = std::make_shared(passConfig); - markup->register_pass(); - markup->register_pass(precisionRestrictions); + markup->register_pass(params.defaultPrecisions); + markup->register_pass(precisionRestrictions, params.defaultPrecisions); markup->register_pass(quantizationRestrictions); - markup->register_pass(); - markup->register_pass(); - markup->register_pass(); - markup->register_pass(); + markup->register_pass(params.defaultPrecisions); + markup->register_pass(params); + markup->register_pass(params.defaultPrecisions); + markup->register_pass(params.defaultPrecisions); common = std::make_shared(passConfig); commonGraphRewrite = common->register_pass(); diff --git a/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.hpp b/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.hpp index 621ef2462ab..e2da8ee7216 100644 --- a/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.hpp +++ b/src/tests/functional/inference_engine/lp_transformations/simple_low_precision_transformer.hpp @@ -18,7 +18,8 @@ class SimpleLowPrecisionTransformer : public ngraph::pass::FunctionPass{ public: SimpleLowPrecisionTransformer( const std::vector& precisionRestrictions = {}, - const std::vector& quantizationRestrictions = {}); + const std::vector& quantizationRestrictions = {}, + const AttributeParameters& params = AttributeParameters()); template void add(const TestTransformationParams& params) {