Additional RTTI Fix

src/common/low_precision_transformations/include/low_precision/add.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API AddTransformation : public EltwiseBaseTransformation {
 public:
-    OPENVINO_RTTI("AddTransformation", "0");
+    OPENVINO_RTTI("AddTransformation", "0", EltwiseBaseTransformation);
     AddTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/align_quantization_intervals.hpp

@@ -30,7 +30,7 @@ class LP_TRANSFORMATIONS_API AlignQuantizationIntervals;
  */
 class ov::pass::low_precision::AlignQuantizationIntervals : public ov::pass::ModelPass {
 public:
-    OPENVINO_RTTI("AlignQuantizationIntervals", "0");
+    OPENVINO_RTTI("AlignQuantizationIntervals", "0", ov::pass::ModelPass);
     AlignQuantizationIntervals(const std::vector<ov::element::Type>& defaultPrecisions = ov::pass::low_precision::precision_set::get_int8_support());
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
 private:

src/common/low_precision_transformations/include/low_precision/align_quantization_parameters.hpp

@@ -31,7 +31,7 @@ class LP_TRANSFORMATIONS_API AlignQuantizationParameters;
  */
 class ov::pass::low_precision::AlignQuantizationParameters : public ov::pass::ModelPass {
 public:
-    OPENVINO_RTTI("AlignQuantizationParameters", "0");
+    OPENVINO_RTTI("AlignQuantizationParameters", "0", ov::pass::ModelPass);
     AlignQuantizationParameters(const std::vector<ov::element::Type> defaultPrecisions = ov::pass::low_precision::precision_set::get_int8_support());
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
 private:

src/common/low_precision_transformations/include/low_precision/assign_and_read_value.hpp

@@ -13,7 +13,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API AssignAndReadValueTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("AssignAndReadValueTransformation", "0");
+    OPENVINO_RTTI("AssignAndReadValueTransformation", "0", LayerTransformation);
     AssignAndReadValueTransformation(const std::shared_ptr<ov::Model> model, const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher& m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;

src/common/low_precision_transformations/include/low_precision/avg_pool.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API AvgPoolTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("AvgPoolTransformation", "0");
+    OPENVINO_RTTI("AvgPoolTransformation", "0", LayerTransformation);
     AvgPoolTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/base_matcher_pass.hpp

@@ -19,6 +19,7 @@ class LP_TRANSFORMATIONS_API BaseMatcherPass;
 
 class LP_TRANSFORMATIONS_API ov::pass::low_precision::BaseMatcherPass : public ov::pass::MatcherPass {
 public:
+    OPENVINO_MATCHER_PASS_RTTI("low_precision::BaseMatcherPass");
     BaseMatcherPass(const AttributeParameters& params = AttributeParameters());
     AttributeParameters params;
 };

src/common/low_precision_transformations/include/low_precision/batch_to_space.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API BatchToSpaceTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("BatchToSpaceTransformation", "0");
+    OPENVINO_RTTI("BatchToSpaceTransformation", "0", LayerTransformation);
     BatchToSpaceTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;

src/common/low_precision_transformations/include/low_precision/broadcast.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API BroadcastTransformation : public TransparentBaseTransformation {
 public:
-    OPENVINO_RTTI("BroadcastTransformation", "0");
+    OPENVINO_RTTI("BroadcastTransformation", "0", TransparentBaseTransformation);
     BroadcastTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<ov::Node> layer) const override;
 };

src/common/low_precision_transformations/include/low_precision/clamp.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ClampTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ClampTransformation", "0");
+    OPENVINO_RTTI("ClampTransformation", "0", LayerTransformation);
     ClampTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher& m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;

src/common/low_precision_transformations/include/low_precision/concat.hpp

@@ -29,7 +29,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ConcatTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ConcatTransformation", "0");
+    OPENVINO_RTTI("ConcatTransformation", "0", LayerTransformation);
     ConcatTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/convert.hpp

@@ -13,7 +13,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API ConvertTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("ConvertTransformation", "0");
+    OPENVINO_RTTI("ConvertTransformation", "0", LayerTransformation);
     ConvertTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/convert_subtract_constant.hpp

@@ -31,6 +31,6 @@ class LP_TRANSFORMATIONS_API ConvertSubtractConstant;
  */
 class ov::pass::low_precision::ConvertSubtractConstant : public ov::pass::MatcherPass {
 public:
-    OPENVINO_RTTI("ConvertSubtractConstant", "0");
+    OPENVINO_MATCHER_PASS_RTTI("ConvertSubtractConstant");
     ConvertSubtractConstant(const std::vector<ov::element::Type>& constantPrecisions = {});
 };

src/common/low_precision_transformations/include/low_precision/convolution.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API ConvolutionTransformation : public WeightableLayerTransformation {
 public:
-    OPENVINO_RTTI("ConvolutionTransformation", "0");
+    OPENVINO_RTTI("ConvolutionTransformation", "0", WeightableLayerTransformation);
     ConvolutionTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isQuantized(const std::shared_ptr<const Node>& layer,

src/common/low_precision_transformations/include/low_precision/create_precisions_dependent_attribute.hpp

@@ -40,6 +40,7 @@ class CreatePrecisionsDependentAttribute;
 template <typename AttributeType, typename OperationType>
 class ov::pass::low_precision::CreatePrecisionsDependentAttribute : public ov::pass::MatcherPass {
 public:
+    OPENVINO_MATCHER_PASS_RTTI("low_precision::CreatePrecisionsDependentAttribute");
     CreatePrecisionsDependentAttribute() {
         auto operation = pattern::wrap_type<OperationType>();
 

src/common/low_precision_transformations/include/low_precision/depth_to_space.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API DepthToSpaceTransformation : public TransparentBaseTransformation {
 public:
-    OPENVINO_RTTI("DepthToSpaceTransformation", "0");
+    OPENVINO_RTTI("DepthToSpaceTransformation", "0", TransparentBaseTransformation);
     DepthToSpaceTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<ov::Node> layer) const override;
 };

src/common/low_precision_transformations/include/low_precision/eliminate_fake_quantize.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API EliminateFakeQuantizeTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("EliminateFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("EliminateFakeQuantizeTransformation", "0", CleanupTransformation);
     EliminateFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fake_quantize.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FakeQuantizeTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("FakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FakeQuantizeTransformation", "0", LayerTransformation);
     FakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/fake_quantize_decomposition.hpp

@@ -23,7 +23,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FakeQuantizeDecompositionTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("FakeQuantizeDecompositionTransformation", "0");
+    OPENVINO_RTTI("FakeQuantizeDecompositionTransformation", "0", LayerTransformation);
     FakeQuantizeDecompositionTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/fold_convert.hpp

@@ -23,7 +23,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FoldConvertTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("FoldConvertTransformation", "0");
+    OPENVINO_RTTI("FoldConvertTransformation", "0", CleanupTransformation);
     FoldConvertTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fold_fake_quantize.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FoldFakeQuantizeTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("FoldFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FoldFakeQuantizeTransformation", "0", LayerTransformation);
     FoldFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fuse_convert.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FuseConvertTransformation : public CleanupTransformation {
 public:
-    OPENVINO_RTTI("FuseConvertTransformation", "0");
+    OPENVINO_RTTI("FuseConvertTransformation", "0", CleanupTransformation);
     FuseConvertTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/fuse_multiply_to_fake_quantize.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FuseMultiplyToFakeQuantizeTransformation : public FuseElementwiseToFakeQuantizeTransformation {
 public:
-    OPENVINO_RTTI("FuseMultiplyToFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FuseMultiplyToFakeQuantizeTransformation", "0", FuseElementwiseToFakeQuantizeTransformation);
     FuseMultiplyToFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/fuse_subtract_to_fake_quantize.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API FuseSubtractToFakeQuantizeTransformation : public FuseElementwiseToFakeQuantizeTransformation {
 public:
-    OPENVINO_RTTI("FuseSubtractToFakeQuantizeTransformation", "0");
+    OPENVINO_RTTI("FuseSubtractToFakeQuantizeTransformation", "0", FuseElementwiseToFakeQuantizeTransformation);
     FuseSubtractToFakeQuantizeTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/gather.hpp

@@ -13,7 +13,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API GatherTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("GatherTransformation", "0");
+    OPENVINO_RTTI("GatherTransformation", "0", LayerTransformation);
     GatherTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/group_convolution.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API GroupConvolutionTransformation : public ConvolutionTransformation {
 public:
-    OPENVINO_RTTI("GroupConvolutionTransformation", "0");
+    OPENVINO_RTTI("GroupConvolutionTransformation", "0", ConvolutionTransformation);
     GroupConvolutionTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool isQuantized(const std::shared_ptr<const Node>& layer,

src/common/low_precision_transformations/include/low_precision/interpolate.hpp

@@ -20,7 +20,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API InterpolateTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("InterpolateTransformation", "0");
+    OPENVINO_RTTI("InterpolateTransformation", "0", LayerTransformation);
     InterpolateTransformation(const Params& params = Params());
     bool transform(TransformationContext &context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp

@@ -244,6 +244,8 @@ inline std::ostream &operator << (std::ostream &os, const DataPrecision& value)
  */
 class LP_TRANSFORMATIONS_API LayerTransformation : public ov::pass::MatcherPass {
 public:
+    OPENVINO_MATCHER_PASS_RTTI("low_precision::LayerTransformation");
+
     class Params {
     public:
         Params(

src/common/low_precision_transformations/include/low_precision/low_precision.hpp

@@ -42,7 +42,7 @@ class LP_TRANSFORMATIONS_API LowPrecision;
 
 class ov::pass::low_precision::MarkupOptimizations : public ov::pass::ModelPass {
 public:
-    OPENVINO_RTTI("MarkupOptimizations", "0");
+    OPENVINO_RTTI("MarkupOptimizations", "0", ov::pass::ModelPass);
     MarkupOptimizations(
         const std::vector<PrecisionsRestriction>& precisionRestrictions,
         const std::vector<QuantizationGranularityRestriction>& quantizationRestrictions,
@@ -56,13 +56,13 @@ class ov::pass::low_precision::MarkupOptimizations : public ov::pass::ModelPass
 
 class ov::pass::low_precision::TypeRelaxedReplacer : public ov::pass::GraphRewrite {
 public:
-    OPENVINO_RTTI("TypeRelaxedReplacer", "0");
+    OPENVINO_RTTI("TypeRelaxedReplacer", "0", ov::pass::GraphRewrite);
     TypeRelaxedReplacer();
 };
 
 class LP_TRANSFORMATIONS_API ov::pass::low_precision::LowPrecision : public ov::pass::ModelPass {
 public:
-    OPENVINO_RTTI("LowPrecision", "0");
+    OPENVINO_RTTI("LowPrecision", "0", ov::pass::ModelPass);
     LowPrecision(
         const std::vector<PrecisionsRestriction>& precisionRestrictions = {},
         const std::vector<QuantizationGranularityRestriction>& quantizationRestrictions = {},

src/common/low_precision_transformations/include/low_precision/markup_avg_pool_precision_preserved.hpp

@@ -29,7 +29,7 @@ class LP_TRANSFORMATIONS_API MarkupAvgPoolPrecisionPreserved;
  */
 class ov::pass::low_precision::MarkupAvgPoolPrecisionPreserved : public ov::pass::ModelPass {
 public:
-    OPENVINO_RTTI("MarkupAvgPoolPrecisionPreserved", "0");
+    OPENVINO_RTTI("MarkupAvgPoolPrecisionPreserved", "0", ov::pass::ModelPass);
     MarkupAvgPoolPrecisionPreserved(const std::vector<ov::element::Type> defaultPrecisions = ov::pass::low_precision::precision_set::get_int8_support());
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
 private:

src/common/low_precision_transformations/include/low_precision/markup_bias.hpp

@@ -23,10 +23,10 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MarkupBias : public ov::pass::MatcherPass {
 public:
-    OPENVINO_RTTI("MarkupBias", "0");
+    OPENVINO_MATCHER_PASS_RTTI("MarkupBias");
     MarkupBias();
 };
 
 }  // namespace low_precision
 }  // namespace pass
-}  // namespace ov
+}  // namespace ov

src/common/low_precision_transformations/include/low_precision/markup_can_be_quantized.hpp

@@ -30,7 +30,7 @@ class LP_TRANSFORMATIONS_API MarkupCanBeQuantized;
  */
 class ov::pass::low_precision::MarkupCanBeQuantized : public ov::pass::ModelPass {
 public:
-    OPENVINO_RTTI("MarkupCanBeQuantized", "0");
+    OPENVINO_RTTI("MarkupCanBeQuantized", "0", ov::pass::ModelPass);
     MarkupCanBeQuantized(const std::vector<ov::element::Type> defaultPrecisions = { ov::element::u8, ov::element::i8 });
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
 private:

src/common/low_precision_transformations/include/low_precision/markup_precisions.hpp

@@ -65,7 +65,7 @@ class ov::pass::low_precision::MarkupPrecisions : public ov::pass::ModelPass {
         std::unordered_map<std::string, RestrictionByVersion> precisionsByVersion;
     };
 
-    OPENVINO_RTTI("MarkupPrecisions", "0");
+    OPENVINO_RTTI("MarkupPrecisions", "0", ov::pass::ModelPass);
     explicit MarkupPrecisions(const std::vector<PrecisionsRestriction>& restrictions = {},
         const std::vector<ov::element::Type>& defaultPrecisions = { ov::element::u8, ov::element::i8 });
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;

src/common/low_precision_transformations/include/low_precision/markup_quantization_granularity.hpp

@@ -45,7 +45,7 @@ class ov::pass::low_precision::MarkupQuantizationGranularity : public ov::pass::
         std::unordered_map<std::string, std::vector<PortQuantizationGranularityRestriction>> portsByVersion;
     };
 
-    OPENVINO_RTTI("MarkupPerTensorQuantization", "0");
+    OPENVINO_RTTI("MarkupPerTensorQuantization", "0", ov::pass::ModelPass);
     explicit MarkupQuantizationGranularity(const std::vector<QuantizationGranularityRestriction>& restrictions = {});
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
 

src/common/low_precision_transformations/include/low_precision/mat_mul.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MatMulTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MatMulTransformation", "0");
+    OPENVINO_RTTI("MatMulTransformation", "0", LayerTransformation);
     MatMulTransformation(const Params& params = Params());
     bool transform(TransformationContext &context, ov::pass::pattern::Matcher &m) override;
     bool isPrecisionPreserved(std::shared_ptr<Node> layer) const noexcept override;

src/common/low_precision_transformations/include/low_precision/max_pool.hpp

@@ -22,7 +22,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MaxPoolTransformation : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MaxPoolTransformation", "0");
+    OPENVINO_RTTI("MaxPoolTransformation", "0", LayerTransformation);
     MaxPoolTransformation(const Params& params = Params());
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> op) const override;
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;

src/common/low_precision_transformations/include/low_precision/move_fake_quantize.hpp

@@ -14,7 +14,7 @@ namespace low_precision {
 
 class LP_TRANSFORMATIONS_API MoveFakeQuantize : public LayerTransformation {
 public:
-    OPENVINO_RTTI("MoveFakeQuantize", "0");
+    OPENVINO_RTTI("MoveFakeQuantize", "0", LayerTransformation);
     MoveFakeQuantize(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;

src/common/low_precision_transformations/include/low_precision/multiply.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MultiplyTransformation : public WeightableLayerTransformation {
 public:
-    OPENVINO_RTTI("MultiplyTransformation", "0");
+    OPENVINO_RTTI("MultiplyTransformation", "0", WeightableLayerTransformation);
     MultiplyTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
 

src/common/low_precision_transformations/include/low_precision/multiply_partial.hpp

@@ -21,7 +21,7 @@ namespace low_precision {
  */
 class LP_TRANSFORMATIONS_API MultiplyPartialTransformation : public EltwiseBaseTransformation {
 public:
-    OPENVINO_RTTI("MultiplyPartialTransformation", "0");
+    OPENVINO_RTTI("MultiplyPartialTransformation", "0", EltwiseBaseTransformation);
     MultiplyPartialTransformation(const Params& params = Params());
     bool transform(TransformationContext& context, ov::pass::pattern::Matcher &m) override;
     bool canBeTransformed(const TransformationContext& context, std::shared_ptr<Node> layer) const override;