diff --git a/src/common/transformations/include/transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp b/src/common/transformations/include/transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp
deleted file mode 100644
index b8d0e40ce79..00000000000
--- a/src/common/transformations/include/transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (C) 2018-2023 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#pragma once
-
-#include "openvino/pass/pass.hpp"
-#include "transformations_visibility.hpp"
-
-namespace ov {
-namespace pass {
-
-class TRANSFORMATIONS_API ConvertCompressedToMixedPrecision;
-
-}  // namespace pass
-}  // namespace ov
-
-/**
- * @ingroup ie_transformation_common_api
- * @brief ConvertCompressedToMixedPrecision converts fp16 compressed ov::Model to mixed precision ov::Model.
- * In mixed precision ov::Models precision sensitive nodes are kept in fp32 while most of the model is in fp16.
- */
-class ov::pass::ConvertCompressedToMixedPrecision : public ov::pass::ModelPass {
-public:
-    OPENVINO_RTTI("ConvertCompressedToMixedPrecision", "0");
-    bool run_on_model(const std::shared_ptr<Model>& f) override;
-};
diff --git a/src/common/transformations/include/transformations/common_optimizations/convert_compression_only_to_legacy.hpp b/src/common/transformations/include/transformations/common_optimizations/convert_compression_only_to_legacy.hpp
index 43be3fb5ed9..10e75d93292 100644
--- a/src/common/transformations/include/transformations/common_optimizations/convert_compression_only_to_legacy.hpp
+++ b/src/common/transformations/include/transformations/common_optimizations/convert_compression_only_to_legacy.hpp
@@ -11,22 +11,11 @@
 namespace ov {
 namespace pass {
 
-class TRANSFORMATIONS_API EnableDecompressionConvertConstantFolding;
 class TRANSFORMATIONS_API ConvertCompressedOnlyToLegacy;
 
 }  // namespace pass
 }  // namespace ov
 
-/**
- * @ingroup ie_transformation_common_api
- * @brief Enables ConstantFolding for Convert operation in compressed function.
- */
-class ov::pass::EnableDecompressionConvertConstantFolding : public ov::pass::MatcherPass {
-public:
-    OPENVINO_RTTI("EnableDecompressionConvertConstantFolding", "0");
-    EnableDecompressionConvertConstantFolding();
-};
-
 /**
  * @ingroup ie_transformation_common_api
  * @brief ConvertCompressedOnlyToLegacy transformation converts compression only FP16 format to legacy FP16 format.
diff --git a/src/common/transformations/include/transformations/enable_decompression_convert_constant_folding.hpp b/src/common/transformations/include/transformations/enable_decompression_convert_constant_folding.hpp
new file mode 100644
index 00000000000..59471f9ba61
--- /dev/null
+++ b/src/common/transformations/include/transformations/enable_decompression_convert_constant_folding.hpp
@@ -0,0 +1,27 @@
+// Copyright (C) 2018-2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/pass/graph_rewrite.hpp"
+#include "transformations/enable_decompression_convert_constant_folding.hpp"
+#include "transformations_visibility.hpp"
+
+namespace ov {
+namespace pass {
+
+class TRANSFORMATIONS_API EnableDecompressionConvertConstantFolding;
+
+}  // namespace pass
+}  // namespace ov
+
+/**
+ * @ingroup ie_transformation_common_api
+ * @brief Disables ConstantFolding for Convert operation in compressed function.
+ */
+class ov::pass::EnableDecompressionConvertConstantFolding : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("EnableDecompressionConvertConstantFolding", "0");
+    EnableDecompressionConvertConstantFolding();
+};
diff --git a/src/common/transformations/src/transformations/common_optimizations/align_mixed_fp32_fp16_types.cpp b/src/common/transformations/src/transformations/common_optimizations/align_mixed_fp32_fp16_types.cpp
index 11d039047a2..5b92fd649ad 100644
--- a/src/common/transformations/src/transformations/common_optimizations/align_mixed_fp32_fp16_types.cpp
+++ b/src/common/transformations/src/transformations/common_optimizations/align_mixed_fp32_fp16_types.cpp
@@ -8,8 +8,7 @@
 #include "openvino/core/rt_info.hpp"
 #include "openvino/op/util/precision_sensitive_attribute.hpp"
 #include "openvino/opsets/opset10.hpp"
-#include "transformations/convert_precision.hpp"
-#include "transformations/rt_info/decompression.hpp"
+#include "openvino/pass/constant_folding.hpp"
 #include "transformations/rt_info/disable_fp16_compression.hpp"
 
 using namespace ov;
@@ -35,6 +34,7 @@ bool ov::pass::AlignMixedFP32FP16Types::run_on_model(const std::shared_ptr<ov::M
                 copy_runtime_info(incoming_node, convert);
                 input.replace_source_output(convert);
                 disable_fp16_compression(convert);
+                pass::disable_constant_folding(convert);
                 is_changed = true;
             }
             return is_changed;
@@ -61,6 +61,7 @@ bool ov::pass::AlignMixedFP32FP16Types::run_on_model(const std::shared_ptr<ov::M
                     copy_runtime_info(node, convert);
                     convert->set_friendly_name(node->get_friendly_name() + "_compressed_to_f16");
                     out_inputs.replace_source_output(convert);
+                    pass::disable_constant_folding(convert);
                     is_changed = true;
                 }
             }
diff --git a/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp b/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp
index d431f5bdbc8..5c4f5894e64 100644
--- a/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp
+++ b/src/common/transformations/src/transformations/common_optimizations/common_optimizations.cpp
@@ -25,7 +25,6 @@
 #include "transformations/common_optimizations/concat_reduce_fusion.hpp"
 #include "transformations/common_optimizations/conv_mul_fusion.hpp"
 #include "transformations/common_optimizations/conv_to_binary_conv.hpp"
-#include "transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp"
 #include "transformations/common_optimizations/convert_compression_only_to_legacy.hpp"
 #include "transformations/common_optimizations/convert_nms_gather_path_to_unsigned.hpp"
 #include "transformations/common_optimizations/convert_quantize_dequantize.hpp"
@@ -125,8 +124,6 @@ bool ov::pass::CommonOptimizations::run_on_model(const std::shared_ptr<ov::Model
     // Enabling conversion of FP16 IR to legacy representation, each plugin have to disable it
     // after support for FP16 IR is implemented
     REGISTER_PASS(manager, ConvertCompressedOnlyToLegacy)
-    // should be enabled manually only on plugins supporting mixed precision inference
-    REGISTER_DISABLED_PASS(manager, ConvertCompressedToMixedPrecision);
 
     REGISTER_PASS(manager, MarkDividesInShapeSubgraphs)
     REGISTER_PASS(manager, WeightsDequantizeToFakeQuantize)
diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_compressed_to_mixed_precision.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_compressed_to_mixed_precision.cpp
deleted file mode 100644
index aefe31a3ece..00000000000
--- a/src/common/transformations/src/transformations/common_optimizations/convert_compressed_to_mixed_precision.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (C) 2018-2023 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#include "transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp"
-
-#include "itt.hpp"
-#include "openvino/opsets/opset8.hpp"
-#include "openvino/pass/manager.hpp"
-#include "transformations/common_optimizations/align_mixed_fp32_fp16_types.hpp"
-#include "transformations/common_optimizations/convert_compression_only_to_legacy.hpp"
-#include "transformations/common_optimizations/mark_subgraphs_to_keep_in_mixed_precision.hpp"
-#include "transformations/convert_precision.hpp"
-#include "transformations/utils/utils.hpp"
-
-bool ov::pass::ConvertCompressedToMixedPrecision::run_on_model(const std::shared_ptr<ov::Model>& f) {
-    RUN_ON_MODEL_SCOPE(ConvertCompressedToMixedPrecision);
-
-    // pass is triggered only for fp16 compressed Models
-    if (!ov::op::util::has_decompression_converts(f))
-        return false;
-
-    Manager manager(get_pass_config());
-    REGISTER_PASS(manager, MarkSugraphsToKeepInMixedPrecision)
-    REGISTER_PASS(manager, AlignMixedFP32FP16Types)
-
-    const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-    type_to_fuse_map additional_fuse_map = {};
-    //  call ConvertPrecision with keep_precision_sensitive_in_fp32 = true
-    REGISTER_PASS(manager, ConvertPrecision, convert_precision_list, additional_fuse_map, true)
-
-    REGISTER_PASS(manager, EnableDecompressionConvertConstantFolding)
-    REGISTER_PASS(manager, ConstantFolding)
-    manager.run_passes(f);
-
-    return false;
-}
diff --git a/src/common/transformations/src/transformations/common_optimizations/convert_compression_only_to_legacy.cpp b/src/common/transformations/src/transformations/common_optimizations/convert_compression_only_to_legacy.cpp
index 73c283d9a5e..ae712e10ead 100644
--- a/src/common/transformations/src/transformations/common_optimizations/convert_compression_only_to_legacy.cpp
+++ b/src/common/transformations/src/transformations/common_optimizations/convert_compression_only_to_legacy.cpp
@@ -9,27 +9,12 @@
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "transformations/convert_precision.hpp"
+#include "transformations/enable_decompression_convert_constant_folding.hpp"
 #include "transformations/rt_info/disable_fp16_compression.hpp"
 #include "transformations/utils/utils.hpp"
 
 using namespace ov;
 
-ov::pass::EnableDecompressionConvertConstantFolding::EnableDecompressionConvertConstantFolding() {
-    MATCHER_SCOPE(EnableDecompressionConvertConstantFolding);
-    auto convert = pattern::wrap_type<opset8::Convert>();
-
-    ov::matcher_pass_callback callback = [=](pattern::Matcher& m) {
-        const auto& node = m.get_match_root();
-        if (!ov::is_decompression(node))
-            return false;
-        enable_constant_folding(node);
-        return true;
-    };
-
-    auto m = std::make_shared<ov::pass::pattern::Matcher>(convert, matcher_name);
-    this->register_matcher(m, callback);
-}
-
 bool ov::pass::ConvertCompressedOnlyToLegacy::run_on_model(const std::shared_ptr<ov::Model>& f) {
     RUN_ON_MODEL_SCOPE(ConvertCompressedOnlyToLegacy);
     if (ov::op::util::has_decompression_converts(f)) {
diff --git a/src/common/transformations/src/transformations/convert_precision.cpp b/src/common/transformations/src/transformations/convert_precision.cpp
index c466a4b9df6..f762e1c1028 100644
--- a/src/common/transformations/src/transformations/convert_precision.cpp
+++ b/src/common/transformations/src/transformations/convert_precision.cpp
@@ -17,7 +17,12 @@
 #include <vector>
 
 #include "itt.hpp"
+#include "openvino/pass/constant_folding.hpp"
+#include "openvino/pass/manager.hpp"
 #include "ov_ops/type_relaxed.hpp"
+#include "transformations/common_optimizations/align_mixed_fp32_fp16_types.hpp"
+#include "transformations/common_optimizations/mark_subgraphs_to_keep_in_mixed_precision.hpp"
+#include "transformations/enable_decompression_convert_constant_folding.hpp"
 #include "transformations/rt_info/disable_fp16_compression.hpp"
 
 using namespace ov;
@@ -175,7 +180,7 @@ bool convert_precision(ov::pass::PassBase& pass,
             // If output type mismatch given type we try to fuse type into this operation
             // otherwise we insert Convert operation.
             for (auto& node : ops) {
-                if (skip_precision_sensitive && fp16_compression_is_disabled(node))
+                if (skip_precision_sensitive && fp16_compression_is_disabled(node) && to == element::f16)
                     continue;
 
                 // Recursively apply transformation for sub-graph based operations
@@ -201,7 +206,7 @@ bool convert_precision(ov::pass::PassBase& pass,
 
             for (auto& node : ops) {
                 // skip precision sensitive nodes
-                if (skip_precision_sensitive && fp16_compression_is_disabled(node))
+                if (skip_precision_sensitive && fp16_compression_is_disabled(node) && to == element::f16)
                     continue;
                 is_output_precision_changed |= convert_node_output_precision(node);
             }
@@ -219,6 +224,8 @@ bool convert_precision(ov::pass::PassBase& pass,
                 // Convert elimination here
                 for (auto& node : ops) {
                     if (auto convert = std::dynamic_pointer_cast<opset4::Convert>(node)) {
+                        if (pass::constant_folding_is_disabled(node))
+                            continue;
                         // WA for topK, dont remove fake convert
                         if (convert->input(0).get_element_type() == convert->get_convert_element_type() &&
                             convert->input_value(0).get_node_shared_ptr()->get_output_size() == 1) {
@@ -301,6 +308,17 @@ bool ov::pass::ConvertPrecision::run_on_model(const std::shared_ptr<ngraph::Func
         {opset10::Unique::get_type_info_static(), fuse_type_to_unique_v10},
         {opset8::RandomUniform::get_type_info_static(), fuse_type_to_random_uniform_v8}};
 
+    std::pair<ov::element::Type, ov::element::Type> compress_f16_pair = {ov::element::f32, ov::element::f16};
+    bool has_compress_f16 = std::count(m_precisions.begin(), m_precisions.end(), compress_f16_pair) > 0;
+
+    if (m_keep_precision_sensitive_in_fp32 && has_compress_f16) {
+        pass::Manager manager(get_pass_config());
+        // Mark subgraphs with disable_fp16_compression to keep them in FP32
+        manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
+        manager.register_pass<pass::AlignMixedFP32FP16Types>();
+        manager.run_passes(f);
+    }
+
     for (const auto& it : m_additional_type_to_fuse_map) {
         type_to_fuse[it.first] = it.second;
     }
@@ -327,6 +345,13 @@ bool ov::pass::ConvertPrecision::run_on_model(const std::shared_ptr<ngraph::Func
                                                         m_keep_precision_sensitive_in_fp32);
     }
 
+    // to remove extra converts
+    if (m_keep_precision_sensitive_in_fp32) {
+        pass::Manager manager(get_pass_config());
+        manager.register_pass<pass::EnableDecompressionConvertConstantFolding>();
+        manager.register_pass<pass::ConstantFolding>();
+    }
+
     (void)is_changed;  // ignored
 
     // Returning value is false because pass::Manager always apply Validation pass
diff --git a/src/common/transformations/src/transformations/enable_decompression_convert_constant_folding.cpp b/src/common/transformations/src/transformations/enable_decompression_convert_constant_folding.cpp
new file mode 100644
index 00000000000..659994a68cd
--- /dev/null
+++ b/src/common/transformations/src/transformations/enable_decompression_convert_constant_folding.cpp
@@ -0,0 +1,29 @@
+// Copyright (C) 2018-2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "transformations/enable_decompression_convert_constant_folding.hpp"
+
+#include "itt.hpp"
+#include "openvino/opsets/opset8.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/rt_info/decompression.hpp"
+#include "transformations/rt_info/disable_constant_folding.hpp"
+
+using namespace ov;
+
+pass::EnableDecompressionConvertConstantFolding::EnableDecompressionConvertConstantFolding() {
+    MATCHER_SCOPE(EnableDecompressionConvertConstantFolding);
+    auto convert = pattern::wrap_type<opset8::Convert>();
+
+    matcher_pass_callback callback = [=](pattern::Matcher& m) {
+        const auto& node = m.get_match_root();
+        if (!is_decompression(node))
+            return false;
+        enable_constant_folding(node);
+        return true;
+    };
+
+    auto m = std::make_shared<ov::pass::pattern::Matcher>(convert, matcher_name);
+    this->register_matcher(m, callback);
+}
diff --git a/src/common/transformations/tests/common_optimizations/align_mixed_fp32_fp16_types_test.cpp b/src/common/transformations/tests/common_optimizations/align_mixed_fp32_fp16_types_test.cpp
index cfe06a0800d..6127453b842 100644
--- a/src/common/transformations/tests/common_optimizations/align_mixed_fp32_fp16_types_test.cpp
+++ b/src/common/transformations/tests/common_optimizations/align_mixed_fp32_fp16_types_test.cpp
@@ -9,7 +9,6 @@
 #include <openvino/pass/manager.hpp>
 #include <transformations/common_optimizations/align_mixed_fp32_fp16_types.hpp>
 #include <transformations/common_optimizations/mark_subgraphs_to_keep_in_mixed_precision.hpp>
-#include <transformations/convert_precision.hpp>
 
 #include "common_test_utils/ngraph_test_utils.hpp"
 
@@ -36,24 +35,21 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_1) {
         pass::Manager manager;
         manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<pass::AlignMixedFP32FP16Types>();
-        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-        type_to_fuse_map empty_type_to_fuse_map = {};
-        manager.register_pass<pass::ConvertPrecision>(convert_precision_list, empty_type_to_fuse_map, true);
         manager.run_passes(model);
     }
 
     {
-        auto input_1 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto convert_to_f32_1 = make_shared<Convert>(input_1, element::f32);
         auto exp_1 = make_shared<Exp>(convert_to_f32_1);
-        auto input_2 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto reduction_axes = Constant::create(element::i64, Shape{1}, {-1});
         auto reduce_sum_1 = make_shared<ReduceSum>(exp_1, reduction_axes);
 
         auto factor_const = Constant::create(element::f16, Shape{1}, {-1});
         auto factor_const_decompressed = make_shared<Convert>(factor_const, element::f32);
         auto mul_1 = make_shared<Multiply>(reduce_sum_1, factor_const_decompressed);
-        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f16);
+        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f32);
         auto matmul_1 = make_shared<MatMul>(convert_to_f16_1, input_2);
 
         model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
@@ -81,18 +77,15 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_2) {
         pass::Manager manager;
         manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<pass::AlignMixedFP32FP16Types>();
-        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-        type_to_fuse_map empty_type_to_fuse_map = {};
-        manager.register_pass<pass::ConvertPrecision>(convert_precision_list, empty_type_to_fuse_map, true);
 
         manager.run_passes(model);
     }
 
     {
-        auto input_1 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto convert_to_f32_1 = make_shared<Convert>(input_1, element::f32);
         auto exp_1 = make_shared<Exp>(convert_to_f32_1);
-        auto input_2 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto reduction_axes = Constant::create(element::i64, Shape{1}, {-1});
 
         auto unsqueeze_axes = Constant::create(element::i64, Shape{1}, {1});
@@ -102,7 +95,7 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_2) {
         auto factor_const = Constant::create(element::f16, Shape{1}, {-1});
         auto factor_const_decompressed = make_shared<Convert>(factor_const, element::f32);
         auto mul_1 = make_shared<Multiply>(reduce_sum_1, factor_const_decompressed);
-        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f16);
+        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f32);
         auto matmul_1 = make_shared<MatMul>(convert_to_f16_1, input_2);
 
         model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
@@ -130,17 +123,14 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_3) {
         pass::Manager manager;
         manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<pass::AlignMixedFP32FP16Types>();
-        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-        type_to_fuse_map empty_type_to_fuse_map = {};
-        manager.register_pass<pass::ConvertPrecision>(convert_precision_list, empty_type_to_fuse_map, true);
         manager.run_passes(model);
     }
 
     {
-        auto input_1 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto convert_to_f32_1 = make_shared<Convert>(input_1, element::f32);
         auto exp_1 = make_shared<Exp>(convert_to_f32_1);
-        auto input_2 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto reduction_axes = Constant::create(element::i64, Shape{1}, {-1});
 
         auto reduce_sum_1 = make_shared<ReduceSum>(exp_1, reduction_axes);
@@ -150,7 +140,7 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_3) {
         auto factor_const = Constant::create(element::f16, Shape{1}, {-1});
         auto factor_const_decompressed = make_shared<Convert>(factor_const, element::f32);
         auto mul_1 = make_shared<Multiply>(add_1, factor_const_decompressed);
-        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f16);
+        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f32);
         auto matmul_1 = make_shared<MatMul>(convert_to_f16_1, input_2);
 
         model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
@@ -172,21 +162,18 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_4) {
         pass::Manager manager;
         manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<pass::AlignMixedFP32FP16Types>();
-        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-        type_to_fuse_map empty_type_to_fuse_map = {};
-        manager.register_pass<pass::ConvertPrecision>(convert_precision_list, empty_type_to_fuse_map, true);
         manager.run_passes(model);
     }
 
     {
-        auto input_1 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
-        auto input_2 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto reduction_axes = Constant::create(element::i64, Shape{1}, {-1});
         auto convert_to_f32_1 = make_shared<Convert>(input_1, element::f32);
         auto mvn_1 = make_shared<MVN>(convert_to_f32_1, reduction_axes, true, 1.0e-8f, op::MVNEpsMode::INSIDE_SQRT);
         auto addition_const = Constant::create(element::f32, Shape{1}, {0.1f});
         auto add_1 = make_shared<Add>(mvn_1, addition_const);
-        auto convert_to_f16_1 = make_shared<Convert>(add_1, element::f16);
+        auto convert_to_f16_1 = make_shared<Convert>(add_1, element::f32);
         auto matmul_1 = make_shared<MatMul>(convert_to_f16_1, input_2);
 
         model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
@@ -215,15 +202,12 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_mnv_with_split) {
         pass::Manager manager;
         manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<pass::AlignMixedFP32FP16Types>();
-        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-        type_to_fuse_map empty_type_to_fuse_map = {};
-        manager.register_pass<pass::ConvertPrecision>(convert_precision_list, empty_type_to_fuse_map, true);
         manager.run_passes(model);
     }
 
     {
-        auto input_1 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
-        auto input_2 = make_shared<Parameter>(element::f16, Shape{1, 3, 56, 224});
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1, 3, 56, 224});
 
         auto convert_to_f32_1 = make_shared<Convert>(input_1, element::f32);
 
@@ -234,7 +218,7 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_mnv_with_split) {
         auto mvn_1 = make_shared<MVN>(split->output(0), reduction_axes, true, 1.0e-8f, op::MVNEpsMode::INSIDE_SQRT);
         auto addition_const = Constant::create(element::f32, Shape{1}, {0.1f});
         auto add_1 = make_shared<Add>(mvn_1, addition_const);
-        auto convert_to_f16_1 = make_shared<Convert>(add_1, element::f16);
+        auto convert_to_f16_1 = make_shared<Convert>(add_1, element::f32);
         auto matmul_1 = make_shared<MatMul>(convert_to_f16_1, input_2);
 
         // todo: without Converts to fp16 because of GPU
@@ -271,17 +255,14 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_with_rand_uniform) {
         pass::Manager manager;
         manager.register_pass<pass::MarkSugraphsToKeepInMixedPrecision>();
         manager.register_pass<pass::AlignMixedFP32FP16Types>();
-        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
-        type_to_fuse_map empty_type_to_fuse_map = {};
-        manager.register_pass<pass::ConvertPrecision>(convert_precision_list, empty_type_to_fuse_map, true);
         manager.run_passes(model);
     }
 
     {
-        auto input_1 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto convert_to_f32_1 = make_shared<Convert>(input_1, element::f32);
         auto exp_1 = make_shared<Exp>(convert_to_f32_1);
-        auto input_2 = make_shared<Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<Parameter>(element::f32, Shape{1, 3, 224, 224});
         auto reduction_axes = Constant::create(element::i64, Shape{1}, {-1});
         auto reduce_sum_1 = make_shared<ReduceSum>(exp_1, reduction_axes);
 
@@ -289,14 +270,14 @@ TEST_F(TransformationTestsF, align_mixed_fp16_fp32_with_rand_uniform) {
         auto factor_const_decompressed = make_shared<Convert>(factor_const, element::f32);
 
         auto out_shape = Constant::create(element::i64, Shape{3}, {1, 3, 224});
-        auto minval = Constant::create(element::f16, Shape{}, {1});
-        auto maxval = Constant::create(element::f16, Shape{}, {10});
-        auto rand_uniform = make_shared<RandomUniform>(out_shape, minval, maxval, element::f16);
+        auto minval = Constant::create(element::f32, Shape{}, {1});
+        auto maxval = Constant::create(element::f32, Shape{}, {10});
+        auto rand_uniform = make_shared<RandomUniform>(out_shape, minval, maxval, element::f32);
         auto rand_uniform_decompressed = make_shared<Convert>(rand_uniform, element::f32);
         auto rand_uniform_add_factor = make_shared<Add>(rand_uniform_decompressed, factor_const_decompressed);
 
         auto mul_1 = make_shared<Multiply>(reduce_sum_1, rand_uniform_add_factor);
-        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f16);
+        auto convert_to_f16_1 = make_shared<Convert>(mul_1, element::f32);
         auto matmul_1 = make_shared<MatMul>(convert_to_f16_1, input_2);
 
         model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
diff --git a/src/common/transformations/tests/common_optimizations/convert_compressed_to_mixed_precision_test.cpp b/src/common/transformations/tests/common_optimizations/convert_compressed_to_mixed_precision_test.cpp
deleted file mode 100644
index b88c7efd593..00000000000
--- a/src/common/transformations/tests/common_optimizations/convert_compressed_to_mixed_precision_test.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright (C) 2018-2023 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#include "transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp"
-
-#include <gtest/gtest.h>
-
-#include <memory>
-#include <string>
-#include <transformations/convert_precision.hpp>
-
-#include "common_test_utils/ngraph_test_utils.hpp"
-#include "openvino/core/model.hpp"
-#include "openvino/opsets/opset10.hpp"
-#include "openvino/pass/manager.hpp"
-#include "transformations/init_node_info.hpp"
-#include "transformations/rt_info/decompression.hpp"
-
-using namespace testing;
-using namespace ov;
-
-TEST_F(TransformationTestsF, ConvertCompressedToMixedPrecision) {
-    {
-        auto input = std::make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 12, 12});
-        auto const_weights =
-            opset10::Constant::create(element::f16, Shape{1, 3, 3, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
-                                                                        6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        auto convert_ins1 = std::make_shared<opset10::Convert>(const_weights, element::f32);
-        mark_as_decompression(convert_ins1);
-        auto conv = std::make_shared<opset10::Convolution>(input,
-                                                           convert_ins1,
-                                                           Strides{1, 1},
-                                                           CoordinateDiff{0, 0},
-                                                           CoordinateDiff{0, 0},
-                                                           Strides{1, 1});
-
-        model = std::make_shared<Model>(NodeVector{conv}, ParameterVector{input});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
-        manager.register_pass<pass::ConvertCompressedToMixedPrecision>();
-        manager.run_passes(model);
-        ASSERT_NO_THROW(check_rt_info(model));
-    }
-
-    {
-        auto input = std::make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 12, 12});
-        auto const_weights =
-            opset10::Constant::create(element::f16, Shape{1, 3, 3, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
-                                                                        6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        auto conv = std::make_shared<opset10::Convolution>(input,
-                                                           const_weights,
-                                                           Strides{1, 1},
-                                                           CoordinateDiff{0, 0},
-                                                           CoordinateDiff{0, 0},
-                                                           Strides{1, 1});
-
-        model_ref = std::make_shared<Model>(NodeVector{conv}, ParameterVector{input});
-    }
-}
-
-TEST_F(TransformationTestsF, ConvertCompressedToMixedPrecissionNoConvertion) {
-    // test that pass is not triggered when there are no decompression Converts
-    {
-        auto input = std::make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 12, 12});
-        auto const_weights =
-            opset10::Constant::create(element::f32, Shape{1, 3, 3, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
-                                                                        6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        auto conv = std::make_shared<opset10::Convolution>(input,
-                                                           const_weights,
-                                                           Strides{1, 1},
-                                                           CoordinateDiff{0, 0},
-                                                           CoordinateDiff{0, 0},
-                                                           Strides{1, 1});
-
-        model = std::make_shared<Model>(NodeVector{conv}, ParameterVector{input});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
-        manager.register_pass<pass::ConvertCompressedToMixedPrecision>();
-        manager.run_passes(model);
-        ASSERT_NO_THROW(check_rt_info(model));
-    }
-
-    {
-        auto input = std::make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 12, 12});
-        auto const_weights =
-            opset10::Constant::create(element::f32, Shape{1, 3, 3, 3}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
-                                                                        6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        auto conv = std::make_shared<opset10::Convolution>(input,
-                                                           const_weights,
-                                                           Strides{1, 1},
-                                                           CoordinateDiff{0, 0},
-                                                           CoordinateDiff{0, 0},
-                                                           Strides{1, 1});
-
-        model_ref = std::make_shared<Model>(NodeVector{conv}, ParameterVector{input});
-    }
-}
-
-TEST_F(TransformationTestsF, ConvertCompressedToMixedPrecission_keep_sensitive_nodes_in_fp32) {
-    {
-        auto input_1 = std::make_shared<opset10::Parameter>(element::f32, Shape{360, 640});
-        auto input_2 = std::make_shared<opset10::Parameter>(element::f32, Shape{720, 1280});
-        auto shapeof = std::make_shared<opset10::ShapeOf>(input_2);
-
-        // decompression Converts are needed for ConvertCompressedToMixedPrecision to be triggered
-        auto compressed_const = opset10::Constant::create(element::f16, Shape{}, {2.0f});
-        auto decompress_convert = std::make_shared<opset10::Convert>(compressed_const, element::f32);
-        mark_as_decompression(decompress_convert);
-        auto add_decompressed_const = std::make_shared<opset10::Add>(input_1, decompress_convert);
-
-        auto convert_to_float = std::make_shared<opset10::Convert>(shapeof, element::f32);
-        auto const_denominator = opset10::Constant::create(element::f32, Shape{}, {2.0f});
-        auto div = std::make_shared<opset10::Divide>(convert_to_float, const_denominator);
-        auto new_shape = std::make_shared<opset10::Convert>(div, element::i64);
-
-        auto reshape = std::make_shared<opset10::Reshape>(add_decompressed_const, new_shape, false);
-        model = std::make_shared<Model>(NodeVector{reshape}, ParameterVector{input_1, input_2});
-
-        pass::Manager manager;
-        manager.register_pass<pass::ConvertCompressedToMixedPrecision>();
-        manager.run_passes(model);
-    }
-    {
-        auto input_1 = std::make_shared<opset10::Parameter>(element::f16, Shape{360, 640});
-        auto input_2 = std::make_shared<opset10::Parameter>(element::f16, Shape{720, 1280});
-
-        // after ConvertCompressedToMixedPrecision Const->Convert are constant-folded into a single f16 Const
-        auto compressed_const = opset10::Constant::create(element::f16, Shape{}, {2.0f});
-        auto add_compressed_const = std::make_shared<opset10::Add>(input_1, compressed_const);
-
-        // shape subgraph will be constant folded
-        auto new_shape_const = opset10::Constant::create(element::i64, Shape{2}, {360, 640});
-
-        auto reshape = std::make_shared<opset10::Reshape>(add_compressed_const, new_shape_const, false);
-        model_ref = std::make_shared<Model>(NodeVector{reshape}, ParameterVector{input_1, input_2});
-    }
-}
diff --git a/src/common/transformations/tests/utils/convert_precision.cpp b/src/common/transformations/tests/utils/convert_precision.cpp
index 9ba053f8b8c..11ea0cb422d 100644
--- a/src/common/transformations/tests/utils/convert_precision.cpp
+++ b/src/common/transformations/tests/utils/convert_precision.cpp
@@ -21,11 +21,11 @@
 #include <vector>
 
 #include "common_test_utils/ngraph_test_utils.hpp"
-#include "transformations/common_optimizations/mark_precision_sensitive_shapeof_subgraphs.hpp"
 #include "transformations/rt_info/disable_fp16_compression.hpp"
 
 using namespace testing;
 using namespace ov;
+using namespace std;
 
 template <element::Type_t T>
 bool has_type(std::shared_ptr<Model> f) {
@@ -776,7 +776,6 @@ TEST(TransformationTests, ConvertPrecision_skip_precision_sensitive) {
         model = std::make_shared<Model>(NodeVector{interpolate}, ParameterVector{input});
 
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = true;
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -811,7 +810,6 @@ TEST(TransformationTests, ConvertPrecision_without_keep_precision_sensitive_in_f
         interpolate = std::make_shared<opset10::Interpolate>(input, sizes, scales, attrs);
         model = std::make_shared<Model>(NodeVector{interpolate}, ParameterVector{input});
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = false;
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -834,7 +832,6 @@ TEST(TransformationTests, ConvertPrecision_check_marking_does_not_leak_in_trivia
         model = std::make_shared<Model>(NodeVector{reshape}, ParameterVector{input_1, input_2});
 
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = true;
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -874,7 +871,6 @@ TEST(TransformationTests, ConvertPrecision_whole_shape_subgraph_is_marked_1) {
         model = std::make_shared<Model>(NodeVector{reshape}, ParameterVector{input_1, input_2});
 
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = true;
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -928,7 +924,6 @@ TEST(TransformationTests, ConvertPrecision_whole_shape_subgraph_is_marked_2) {
         model = std::make_shared<Model>(NodeVector{result}, ParameterVector{input_1});
 
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = true;
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -1008,7 +1003,6 @@ TEST(TransformationTests, ConvertPrecision_whole_shape_subgraph_is_marked_3) {
         model = std::make_shared<Model>(NodeVector{result_1, result_2}, ParameterVector{input_1, input_2});
 
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = true;
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -1087,7 +1081,6 @@ TEST(TransformationTests, ConvertCompressedToMixedPrecission_do_not_keep_in_fp32
         model = std::make_shared<Model>(NodeVector{interpolate}, ParameterVector{input});
 
         pass::Manager manager;
-        manager.register_pass<pass::MarkPrecisionSensitiveShapeOfSubgraphs>();
         type_to_fuse_map empty_type_to_fuse_map = {};
         bool keep_precision_sensitive_in_fp32 = false;  // didn't keep in FP32 intentionally
         manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
@@ -1323,3 +1316,474 @@ TEST(TransformationTests, ConvertPrecision_ConstantConversion_U1ToU4) {
                                             std::vector<uint8_t>{171},
                                             {1, 0, 1, 0, 1, 0, 1, 1});
 }
+
+TEST(TransformationTests, ConvertPrecision_keep_precission_sensitive_fp32_with_exp) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto exp_1 = make_shared<opset10::Exp>(input_1);
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(exp_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto factor_const_decompressed = make_shared<opset10::Convert>(factor_const, element::f32);
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const_decompressed);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1, input_2);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto exp_1 = make_shared<opset10::Exp>(input_1_decompressed);
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(exp_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto factor_const_decompressed = make_shared<opset10::Convert>(factor_const, element::f32);
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const_decompressed);
+        auto mul_1_compressed = make_shared<opset10::Convert>(mul_1, element::f16);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1_compressed, input_2);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_keep_precission_sensitive_fp32_with_reducemean) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto exp_1 = make_shared<opset10::Exp>(input_1);
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(exp_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto factor_const_decompressed = make_shared<opset10::Convert>(factor_const, element::f32);
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const_decompressed);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1, input_2);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto exp_1 = make_shared<opset10::Exp>(input_1_decompressed);
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_mean_1 = make_shared<opset10::ReduceMean>(exp_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto factor_const_decompressed = make_shared<opset10::Convert>(factor_const, element::f32);
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_mean_1, factor_const_decompressed);
+        auto mul_1_compressed = make_shared<opset10::Convert>(mul_1, element::f16);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1_compressed, input_2);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_reducesum_without_exp) {
+    // ReduceSum without Exp is not a precision sensitive case, the whole Model should be cast into f16,
+    // no nodes should be marked and no Converts should be added
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(input_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f32, Shape{1}, {-1});
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1, input_2);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(input_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1, input_2);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_MarkNormalizationOps_1) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto mvn_1 = make_shared<opset10::MVN>(input_1, reduction_axes, true, 1.0e-8f, op::MVNEpsMode::INSIDE_SQRT);
+        auto matmul_1 = make_shared<opset10::MatMul>(mvn_1, input_2);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto mvn_1 =
+            make_shared<opset10::MVN>(input_1_decompressed, reduction_axes, true, 1.0e-8f, op::MVNEpsMode::INSIDE_SQRT);
+        auto mvn_compressed = make_shared<opset10::Convert>(mvn_1, element::f16);
+        auto matmul_1 = make_shared<opset10::MatMul>(mvn_compressed, input_2);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_MarkNormalizationOps_2) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto normalizel2_1 = make_shared<opset10::NormalizeL2>(input_1, reduction_axes, 1.0e-8f, ov::op::EpsMode::MAX);
+        auto matmul_1 = make_shared<opset10::MatMul>(normalizel2_1, input_2);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto normalizel2_1 =
+            make_shared<opset10::NormalizeL2>(input_1_decompressed, reduction_axes, 1.0e-8f, ov::op::EpsMode::MAX);
+        auto normalizel2_compressed = make_shared<opset10::Convert>(normalizel2_1, element::f16);
+        auto matmul_1 = make_shared<opset10::MatMul>(normalizel2_compressed, input_2);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_keep_precission_sensitive_fp32_t2t_subgraph) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    // subgraph from t2t-vit-7
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3136, 32});
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3136, 32});
+        auto input_3 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3136, 64, 1});
+        auto input_4 = make_shared<opset10::Parameter>(element::f32, Shape{128, 64});
+        auto exp_1 = make_shared<opset10::Exp>(input_1);
+        auto exp_2 = make_shared<opset10::Exp>(input_2);
+
+        auto factor_1 = opset10::Constant::create(element::f32, Shape{1}, {0.5});  // add decompression
+        auto mul_1 = make_shared<opset10::Multiply>(exp_1, factor_1);
+        auto factor_2 = opset10::Constant::create(element::f32, Shape{1}, {0.5});
+        auto mul_2 = make_shared<opset10::Multiply>(exp_2, factor_2);
+
+        auto const_unsqueeze_1 = opset10::Constant::create(element::i64, Shape{4}, {1, 3136, 1, 32});
+        auto unsqueeze_1 = make_shared<opset10::Reshape>(mul_1, const_unsqueeze_1, false);
+
+        auto const_unsqueeze_2 = opset10::Constant::create(element::i64, Shape{4}, {1, 3136, 1, 32});
+        auto unsqueeze_2 = make_shared<opset10::Reshape>(mul_2, const_unsqueeze_1, false);
+        auto reduction_axes_1 = opset10::Constant::create(element::i64, Shape{1}, {1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(mul_2, reduction_axes_1, true);
+        auto mul_3 = make_shared<opset10::Multiply>(reduce_sum_1, mul_1);
+        auto mul_4 = make_shared<opset10::Multiply>(input_3, unsqueeze_2);
+
+        auto reduction_axes_2 = opset10::Constant::create(element::i64, Shape{1}, {1});
+        auto reduce_sum_2 = make_shared<opset10::ReduceSum>(mul_4, reduction_axes_2);
+        auto reduction_axes_3 = opset10::Constant::create(element::i64, Shape{1}, {2});
+        auto reduce_sum_3 = make_shared<opset10::ReduceSum>(mul_3, reduction_axes_3, true);
+
+        auto broadcast_to_shape = opset10::Constant::create(element::i64, Shape{3}, {1, 1, 1});
+        auto broadcast =
+            make_shared<opset10::Broadcast>(reduce_sum_3, broadcast_to_shape, ov::op::BroadcastType::BIDIRECTIONAL);
+        auto tile_shape = opset10::Constant::create(element::i64, Shape{3}, {1, 1, 64});
+        auto tile = make_shared<opset10::Tile>(broadcast, tile_shape);
+        auto eps_const = opset10::Constant::create(element::f32, Shape{1}, {1.e-10});
+        auto add_1 = make_shared<opset10::Add>(tile, eps_const);
+
+        auto const_unsqueeze_3 = opset10::Constant::create(element::i64, Shape{4}, {1, 1, 64, 32});
+        auto unsqueeze_3 = make_shared<opset10::Reshape>(reduce_sum_2, const_unsqueeze_3, false);
+        auto mul_5 = make_shared<opset10::Multiply>(unsqueeze_1, unsqueeze_3);
+
+        auto reduction_axes_4 = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_4 = make_shared<opset10::ReduceSum>(mul_5, reduction_axes_4);
+
+        auto div_1 = make_shared<opset10::Divide>(reduce_sum_4, add_1);
+        auto matmul_1 = make_shared<opset10::MatMul>(div_1, input_4, false, true);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2, input_3, input_4});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3136, 32});
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3136, 32});
+        auto input_3 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3136, 64, 1});
+        auto input_4 = make_shared<opset10::Parameter>(element::f16, Shape{128, 64});
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto input_2_decompressed = make_shared<opset10::Convert>(input_2, element::f32);
+        auto input_3_decompressed = make_shared<opset10::Convert>(input_3, element::f32);
+
+        auto exp_1 = make_shared<opset10::Exp>(input_1_decompressed);
+        auto exp_2 = make_shared<opset10::Exp>(input_2_decompressed);
+
+        auto factor_1 = opset10::Constant::create(element::f32, Shape{1}, {0.5});
+        auto mul_1 = make_shared<opset10::Multiply>(exp_1, factor_1);
+        auto factor_2 = opset10::Constant::create(element::f32, Shape{1}, {0.5});
+        auto mul_2 = make_shared<opset10::Multiply>(exp_2, factor_2);
+
+        auto const_unsqueeze_1 = opset10::Constant::create(element::i64, Shape{4}, {1, 3136, 1, 32});
+        auto unsqueeze_1 = make_shared<opset10::Reshape>(mul_1, const_unsqueeze_1, false);
+
+        auto const_unsqueeze_2 = opset10::Constant::create(element::i64, Shape{4}, {1, 3136, 1, 32});
+        auto unsqueeze_2 = make_shared<opset10::Reshape>(mul_2, const_unsqueeze_2, false);
+        auto reduction_axes_1 = opset10::Constant::create(element::i64, Shape{1}, {1});
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(mul_2, reduction_axes_1, true);
+        auto mul_3 = make_shared<opset10::Multiply>(reduce_sum_1, mul_1);
+        auto mul_4 = make_shared<opset10::Multiply>(input_3_decompressed, unsqueeze_2);
+
+        auto reduction_axes_2 = opset10::Constant::create(element::i64, Shape{1}, {1});
+        auto reduce_sum_2 = make_shared<opset10::ReduceSum>(mul_4, reduction_axes_2);
+        auto reduction_axes_3 = opset10::Constant::create(element::i64, Shape{1}, {2});
+        auto reduce_sum_3 = make_shared<opset10::ReduceSum>(mul_3, reduction_axes_3, true);
+
+        auto broadcast_to_shape = opset10::Constant::create(element::i64, Shape{3}, {1, 1, 1});
+        auto broadcast =
+            make_shared<opset10::Broadcast>(reduce_sum_3, broadcast_to_shape, ov::op::BroadcastType::BIDIRECTIONAL);
+        auto tile_shape = opset10::Constant::create(element::i64, Shape{3}, {1, 1, 64});
+        auto tile = make_shared<opset10::Tile>(broadcast, tile_shape);
+        auto eps_const = opset10::Constant::create(element::f32, Shape{1}, {1.e-10});
+        auto add_1 = make_shared<opset10::Add>(tile, eps_const);
+
+        auto const_unsqueeze_3 = opset10::Constant::create(element::i64, Shape{4}, {1, 1, 64, 32});
+        auto unsqueeze_3 = make_shared<opset10::Reshape>(reduce_sum_2, const_unsqueeze_3, false);
+        auto mul_5 = make_shared<opset10::Multiply>(unsqueeze_1, unsqueeze_3);
+
+        auto reduction_axes_4 = opset10::Constant::create(element::i64, Shape{1}, {-1});
+        auto reduce_sum_4 = make_shared<opset10::ReduceSum>(mul_5, reduction_axes_4);
+
+        auto div_1 = make_shared<opset10::Divide>(reduce_sum_4, add_1);
+        auto div_compressed = make_shared<opset10::Convert>(div_1, element::f16);
+        auto matmul_1 = make_shared<opset10::MatMul>(div_compressed, input_4, false, true);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2, input_3, input_4});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_DivisionByZeroMinimalPattern) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+
+    const float eps_value = 1.0e-12f;
+    {
+        auto input_1 = std::make_shared<opset10::Parameter>(element::f32, PartialShape::dynamic(3));
+        auto input_2 = std::make_shared<opset10::Parameter>(element::f32, PartialShape::dynamic(3));
+        auto eps_const = opset10::Constant::create(element::f32, Shape{1}, {eps_value});
+        auto add = std::make_shared<opset10::Add>(input_2, eps_const);
+        auto divide = std::make_shared<opset10::Divide>(input_1, add);
+        model = std::make_shared<Model>(NodeVector{divide}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = std::make_shared<opset10::Parameter>(element::f16, PartialShape::dynamic(3));
+        auto input_2 = std::make_shared<opset10::Parameter>(element::f16, PartialShape::dynamic(3));
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto input_2_decompressed = make_shared<opset10::Convert>(input_2, element::f32);
+
+        auto eps_const = opset10::Constant::create(element::f32, Shape{1}, {eps_value});
+        auto add = std::make_shared<opset10::Add>(input_2_decompressed, eps_const);
+        auto divide = std::make_shared<opset10::Divide>(input_1_decompressed, add);
+
+        model_ref = std::make_shared<Model>(NodeVector{divide}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_PowWithNegativeExponent) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    const float eps_value = 1.0e-12f;
+    {
+        auto input_1 = std::make_shared<opset10::Parameter>(element::f32, PartialShape::dynamic(3));
+        auto input_2 = std::make_shared<opset10::Parameter>(element::f32, PartialShape::dynamic(3));
+        auto eps_const = opset10::Constant::create(element::f32, Shape{1}, {eps_value});
+        auto add = std::make_shared<opset10::Add>(input_2, eps_const);
+        auto pow_exp_const = opset10::Constant::create(element::f32, Shape{1}, {-1.77});
+        auto pow = std::make_shared<opset10::Power>(add, pow_exp_const);
+        auto mul = std::make_shared<opset10::Multiply>(input_1, pow);
+
+        model = std::make_shared<Model>(NodeVector{mul}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = std::make_shared<opset10::Parameter>(element::f16, PartialShape::dynamic(3));
+        auto input_2 = std::make_shared<opset10::Parameter>(element::f16, PartialShape::dynamic(3));
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto input_2_decompressed = make_shared<opset10::Convert>(input_2, element::f32);
+
+        auto eps_const = opset10::Constant::create(element::f32, Shape{1}, {eps_value});
+        auto add = std::make_shared<opset10::Add>(input_2_decompressed, eps_const);
+        auto pow_exp_const = opset10::Constant::create(element::f32, Shape{1}, {-1.77});
+        auto pow = std::make_shared<opset10::Power>(add, pow_exp_const);
+        auto mul = std::make_shared<opset10::Multiply>(input_1_decompressed, pow);
+
+        model_ref = std::make_shared<Model>(NodeVector{mul}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
+
+TEST(TransformationTests, ConvertPrecision_exp_through_unsqueeze) {
+    shared_ptr<Model> model, model_ref;
+    pass::Manager manager;
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto exp_1 = make_shared<opset10::Exp>(input_1);
+        auto input_2 = make_shared<opset10::Parameter>(element::f32, Shape{1, 3, 224, 224});
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+
+        auto unsqueeze_axes = opset10::Constant::create(element::i64, Shape{1}, {1});
+        auto unsqueeze_1 = make_shared<opset10::Unsqueeze>(exp_1, unsqueeze_axes);
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(unsqueeze_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto factor_const_decompressed = make_shared<opset10::Convert>(factor_const, element::f32);
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const_decompressed);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1, input_2);
+
+        model = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+
+        type_to_fuse_map empty_type_to_fuse_map = {};
+        bool keep_precision_sensitive_in_fp32 = true;
+        manager.register_pass<pass::ConvertPrecision>(precisions_array{{element::f32, element::f16}},
+                                                      empty_type_to_fuse_map,
+                                                      keep_precision_sensitive_in_fp32);
+        manager.run_passes(model);
+    }
+
+    {
+        auto input_1 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+        auto input_1_decompressed = make_shared<opset10::Convert>(input_1, element::f32);
+        auto exp_1 = make_shared<opset10::Exp>(input_1_decompressed);
+        auto input_2 = make_shared<opset10::Parameter>(element::f16, Shape{1, 3, 224, 224});
+
+        auto reduction_axes = opset10::Constant::create(element::i64, Shape{1}, {-1});
+
+        auto unsqueeze_axes = opset10::Constant::create(element::i64, Shape{1}, {1});
+        auto unsqueeze_1 = make_shared<opset10::Unsqueeze>(exp_1, unsqueeze_axes);
+        auto reduce_sum_1 = make_shared<opset10::ReduceSum>(unsqueeze_1, reduction_axes);
+
+        auto factor_const = opset10::Constant::create(element::f16, Shape{1}, {-1});
+        auto factor_const_decompressed = make_shared<opset10::Convert>(factor_const, element::f32);
+        auto mul_1 = make_shared<opset10::Multiply>(reduce_sum_1, factor_const_decompressed);
+        auto mul_1_compressed = make_shared<opset10::Convert>(mul_1, element::f16);
+        auto matmul_1 = make_shared<opset10::MatMul>(mul_1_compressed, input_2);
+
+        model_ref = make_shared<Model>(NodeVector{matmul_1}, ParameterVector{input_1, input_2});
+    }
+
+    const FunctionsComparator func_comparator = FunctionsComparator::with_default();
+    FunctionsComparator::Result result = func_comparator(model_ref, model);
+    ASSERT_TRUE(result.valid) << result.message;
+}
diff --git a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp
index e86b587999e..4c8f16ec07a 100644
--- a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp
@@ -41,7 +41,6 @@
 #include <transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp>
 #include "transformations/common_optimizations/convert_quantize_dequantize.hpp"
 #include "transformations/common_optimizations/convert_compression_only_to_legacy.hpp"
-#include "transformations/common_optimizations/convert_compressed_to_mixed_precision.hpp"
 #include <transformations/common_optimizations/wrap_interpolate_into_transposes.hpp>
 #include <transformations/common_optimizations/transpose_sinking.hpp>
 
@@ -140,6 +139,63 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
 
         manager.register_pass<ov::pass::InitNodeInfo>();
         manager.register_pass<EinsumDecomposition>();
+
+        precisions_array fp_convert_precision_list = {
+                {ov::element::f64, ov::element::f32}
+        };
+
+        // call conversion of float types with keep_precision_sensitive_in_fp32 = true
+        auto fp_precision_supported = [&](ov::element::Type e) -> bool {
+            switch (e) {
+                case ov::element::f16: return device_info.supports_fp16;
+                case ov::element::f32: return true; // assume that all GPUs support f32 data type
+                case ov::element::f64: return device_info.supports_fp64;
+                case ov::element::bf16: return false;
+                default: return false;
+            }
+            return false;
+        };
+
+        const auto fallback_precision = ov::element::f32;
+        std::vector<ov::element::Type> fp_element_types = {
+                ov::element::f32,
+                ov::element::f16,
+                ov::element::bf16
+        };
+
+        // Add conversion from FP data types to infer precision if it's specified
+        auto infer_precision = config.get_property(ov::hint::inference_precision);
+        if (infer_precision != ov::element::undefined) {
+            if (!fp_precision_supported(infer_precision))
+                infer_precision = fallback_precision;
+
+            for (auto& et : fp_element_types) {
+                if (et != infer_precision) {
+                    fp_convert_precision_list.push_back({et, infer_precision});
+                }
+            }
+        }
+
+        // Add conversion from unsupported FP data types to f32 if we don't have a conversion to something valid already in the list
+        for (auto& et : fp_element_types) {
+            if (!fp_precision_supported(et)) {
+                auto et_pair = std::make_pair(et, fallback_precision);
+                bool has_valid_conversion = std::find_if(fp_convert_precision_list.begin(), fp_convert_precision_list.end(),
+                    [&](std::pair<ov::element::Type, ov::element::Type> v) -> bool {
+                        return v.first == et_pair.first && fp_precision_supported(v.second);
+                }) != fp_convert_precision_list.end();
+
+                if (!has_valid_conversion) {
+                    fp_convert_precision_list.push_back(et_pair);
+                }
+            }
+        }
+
+        type_to_fuse_map empty_fuse_map = {};
+        manager.register_pass<ov::pass::Validate>();
+        //  call ConvertPrecision with keep_precision_sensitive_in_fp32 = true
+        manager.register_pass<ov::pass::ConvertPrecision>(fp_convert_precision_list, empty_fuse_map, true);
+
         manager.register_pass<ov::pass::CommonOptimizations>();
 
         manager.register_pass<ov::pass::WrapInterpolateIntoTransposes>();
@@ -176,8 +232,7 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
         manager.register_pass<ov::pass::ConvertPriorBox8To0, false>();
         manager.register_pass<ov::pass::ConvertMulticlassNmsToMulticlassNmsIE>();
 
-        precisions_array convert_precision_list {
-                {ngraph::element::f64, ngraph::element::f32},
+        precisions_array int_convert_precision_list {
                 {ngraph::element::i64, ngraph::element::i32},
                 {ngraph::element::u64, ngraph::element::i32},
                 {ngraph::element::u16, ngraph::element::i32},
@@ -187,54 +242,8 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
                 {ngraph::element::u4, ngraph::element::u8},
         };
 
-        auto fp_precision_supported = [&](ngraph::element::Type e) -> bool {
-            switch (e) {
-                case ngraph::element::f16: return device_info.supports_fp16;
-                case ngraph::element::f32: return true; // assume that all GPUs support f32 data type
-                case ngraph::element::f64: return device_info.supports_fp64;
-                case ngraph::element::bf16: return false;
-                default: return false;
-            }
-            return false;
-        };
-
-        const auto fallback_precision = ngraph::element::f32;
-        std::vector<ov::element::Type> fp_element_types = {
-            ngraph::element::f32,
-            ngraph::element::f16,
-            ngraph::element::bf16
-        };
-
-        // Add conversion from FP data types to infer precision if it's specified
-        auto infer_precision = config.get_property(ov::inference_precision);
-        if (infer_precision != ov::element::undefined) {
-            if (!fp_precision_supported(infer_precision))
-                infer_precision = fallback_precision;
-
-            for (auto& et : fp_element_types) {
-                if (et != infer_precision) {
-                    convert_precision_list.push_back({et, infer_precision});
-                }
-            }
-        }
-
-        // Add conversion from unsupported FP data types to f32 if we don't have a conversion to something valid already in the list
-        for (auto& et : fp_element_types) {
-            if (!fp_precision_supported(et)) {
-                auto et_pair = std::make_pair(et, fallback_precision);
-                bool has_valid_conversion = std::find_if(convert_precision_list.begin(), convert_precision_list.end(),
-                    [&](std::pair<ov::element::Type, ov::element::Type> v) -> bool {
-                        return v.first == et_pair.first && fp_precision_supported(v.second);
-                }) != convert_precision_list.end();
-
-                if (!has_valid_conversion) {
-                    convert_precision_list.push_back(et_pair);
-                }
-            }
-        }
-
         manager.register_pass<ngraph::pass::Validate>();
-        manager.register_pass<ov::pass::ConvertPrecision>(convert_precision_list);
+        manager.register_pass<ov::pass::ConvertPrecision>(int_convert_precision_list);
 
         auto pass_config = manager.get_pass_config();
         pass_config->disable<ov::pass::EyeDecomposition>();
@@ -242,7 +251,6 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
         // disable conversion to legacy and use the new mixed precision
         // in which precision sensitive nodes are kept in FP32
         pass_config->disable<ov::pass::ConvertCompressedOnlyToLegacy>();
-        pass_config->enable<ov::pass::ConvertCompressedToMixedPrecision>();
 
         // SpaceToDepth/DepthToSpace node implementation supports only equal input/output tensors with rank <= 5
         pass_config->set_callback<ov::pass::ConvertSpaceToDepth,