[GPU] activations scaling to resolve accuracy issues for infer precision of f16

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

@@ -251,11 +251,13 @@ class LP_TRANSFORMATIONS_API LayerTransformation : public ov::pass::MatcherPass
             element::Type deqPrecision = element::f32,
             const std::vector<ov::element::Type> defaultPrecisions =
             { ov::element::u8,  ov::element::i8 },
-            const bool reshapeIgnorePerTensorQuantizationCheck = false) :
+            const bool reshapeIgnorePerTensorQuantizationCheck = false,
+            const bool useDefaultTransformation = true) :
             updatePrecisions(updatePrecisions),
             deqPrecision(deqPrecision),
             defaultPrecisions(defaultPrecisions),
-            reshapeIgnorePerTensorQuantizationCheck(reshapeIgnorePerTensorQuantizationCheck) {}
+            reshapeIgnorePerTensorQuantizationCheck(reshapeIgnorePerTensorQuantizationCheck),
+            useDefaultTransformation(useDefaultTransformation) {}
 
         Params& setUpdatePrecisions(const bool updatePrecisions) {
             this->updatePrecisions = updatePrecisions;
@@ -280,6 +282,8 @@ class LP_TRANSFORMATIONS_API LayerTransformation : public ov::pass::MatcherPass
         std::vector<ov::element::Type> defaultPrecisions;
         // to support GPU workarround to keep Reshape and MatMul in FP32
         bool reshapeIgnorePerTensorQuantizationCheck;
+        // for MultiplyPartialTransformation to support Activations Scaling
+        bool useDefaultTransformation;
     };
 
     class PrecisionDetails {
@@ -351,6 +355,7 @@ class LP_TRANSFORMATIONS_API LayerTransformation : public ov::pass::MatcherPass
     element::Type deqPrecision;
     std::vector<ov::element::Type> defaultPrecisions;
     bool reshapeIgnorePerTensorQuantizationCheck;
+    bool useDefaultTransformation;
 
     static constexpr char originalLayerPostfix[] = "_original";
     TransformationContext* context;

src/common/low_precision_transformations/src/layer_transformation.cpp

@@ -45,6 +45,7 @@ LayerTransformation::LayerTransformation(const Params& params) :
     deqPrecision(params.deqPrecision),
     defaultPrecisions(params.defaultPrecisions),
     reshapeIgnorePerTensorQuantizationCheck(params.reshapeIgnorePerTensorQuantizationCheck),
+    useDefaultTransformation(params.useDefaultTransformation),
     context(nullptr) {}
 
 void LayerTransformation::setContext(TransformationContext* context) noexcept {

src/common/low_precision_transformations/src/multiply_partial.cpp

@@ -133,24 +133,30 @@ bool MultiplyPartialTransformation::transform(TransformationContext& context, ov
 
 
         // before: Y = (SC1 * (X1 - SH1)) * (SC2 * X2)
-        // after : Y = (SC1' * (X1 - SH1)) * (X2) , where :
-        //         SC1' = SC1 * SC2
+        // if useDefaultTransformation = true
+        //     after : Y = (SC1' * (X1 - SH1)) * (X2) , where :
+        //             SC1' = SC1 * SC2
+        // else
+        //     after : Y = ((X1 - SH1) * X2) * SC1' ,  where :
+        //             SC1' = SC1 * SC2
         auto newMultiplyValuesFullPath = fold<ov::opset1::Multiply>(multiplyValuesEmptyPath, multiplyValuesFullPath);
         OutputVector inputs{ {}, {} };
-        inputs[emptyPathIndex] = dequantizationEmptyPath.data;
+        inputs[emptyPathIndex] = useDefaultTransformation ? dequantizationEmptyPath.data : newMultiplyValuesFullPath;
+        auto input_for_fullPath = useDefaultTransformation ? newMultiplyValuesFullPath :
+                                                             dequantizationEmptyPath.data.get_node_shared_ptr();
 
         ov::Output<ov::Node> parent0 = dequantizationFullPath.subtract == nullptr ?
             (dequantizationFullPath.convert == nullptr ? dequantizationFullPath.data : dequantizationFullPath.convert) :
             dequantizationFullPath.subtract;
 
         inputs[fullPathIndex] =
-            parent0.get_node()->get_output_element_type(0) == newMultiplyValuesFullPath->get_output_element_type(0) ?
-                std::make_shared<ov::opset1::Multiply>(parent0, newMultiplyValuesFullPath) :
+            parent0.get_node()->get_output_element_type(0) == input_for_fullPath->get_output_element_type(0) ?
+                std::make_shared<ov::opset1::Multiply>(parent0, input_for_fullPath) :
                 std::make_shared<ov::op::TypeRelaxed<ov::opset1::Multiply>>(
                       std::vector<element::Type>{element::f32, element::f32},
                       std::vector<element::Type>{element::f32},
                       ov::op::TemporaryReplaceOutputType(parent0, element::f32).get(),
-                      ov::op::TemporaryReplaceOutputType(newMultiplyValuesFullPath, element::f32).get());
+                      ov::op::TemporaryReplaceOutputType(input_for_fullPath, element::f32).get());
 
         newMultiply = std::make_shared<ov::op::TypeRelaxed<ov::opset1::Multiply>>(
                 std::vector<element::Type>{element::f32, element::f32},

src/common/transformations/include/transformations/common_optimizations/activations_scaling.hpp

@@ -0,0 +1,75 @@
+// Copyright (C) 2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <memory>
+
+#include "openvino/pass/matcher_pass.hpp"
+#include "transformations_visibility.hpp"
+
+namespace ov {
+namespace pass {
+
+class TRANSFORMATIONS_API ActivationsScaling;
+
+namespace activations_scaling {
+
+TRANSFORMATIONS_API void mark_as_scale_down_node(const std::shared_ptr<Node>& node);
+
+TRANSFORMATIONS_API bool is_scale_down_node(const std::shared_ptr<const Node>& node);
+
+class TRANSFORMATIONS_API ScaleDownNode : public RuntimeAttribute {
+public:
+    OPENVINO_RTTI("scale_down_node", "0");
+
+    bool is_copyable() const override {
+        return false;
+    }
+};
+
+class TRANSFORMATIONS_API ScaleDownSingleLayer;
+class TRANSFORMATIONS_API ScaleDownFusion;
+class TRANSFORMATIONS_API MulGroupNormTransformation;
+class TRANSFORMATIONS_API MulMVNTransformation;
+class TRANSFORMATIONS_API MulConcatTransformation;
+
+}  // namespace activations_scaling
+}  // namespace pass
+}  // namespace ov
+
+// ActivationsScaling makes activation values smaller to prevent overflow due to the limited range of FP16
+// This feature is controlled by ov::hint::activations_scale_factor.
+// For example, when this property is set as 16, activations are divided by 16.
+// If ov::hint::activations_scale_factor is less than zero, it is disabled.
+
+class ov::pass::activations_scaling::ScaleDownSingleLayer : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("ScaleDownSingleLayer", "0");
+    ScaleDownSingleLayer(float scale_factor, ov::element::Type scaled_prec);
+};
+
+class ov::pass::activations_scaling::ScaleDownFusion : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("ScaleDownFusion", "0");
+    ScaleDownFusion(float scale_factor);
+};
+
+class ov::pass::activations_scaling::MulGroupNormTransformation : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("MulGroupNormTransformation", "0");
+    MulGroupNormTransformation();
+};
+
+class ov::pass::activations_scaling::MulMVNTransformation : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("MulMVNTransformation", "0");
+    MulMVNTransformation();
+};
+
+class ov::pass::activations_scaling::MulConcatTransformation : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("MulConcatTransformation", "0");
+    MulConcatTransformation();
+};

src/common/transformations/include/transformations/rt_info/dequantization_node.hpp

@@ -12,7 +12,7 @@ namespace ov {
 
 TRANSFORMATIONS_API void mark_as_dequantization_node(const std::shared_ptr<Node>& node);
 
-TRANSFORMATIONS_API bool is_dequantization_node(const std::shared_ptr<Node>& node);
+TRANSFORMATIONS_API bool is_dequantization_node(const std::shared_ptr<const Node>& node);
 
 /**
  * @ingroup ov_runtime_attr_api