[GPU] Enable dynamic quantization for MXFP8 & regular FP8 dtypes

src/common/low_precision_transformations/src/low_precision.cpp

@@ -31,6 +31,7 @@
 #include "openvino/pass/constant_folding.hpp"
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "openvino/pass/pattern/op/pattern.hpp"
 #include "openvino/util/log.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "transformations/common_optimizations/lin_op_sequence_fusion.hpp"

src/common/transformations/include/openvino/decompositions/low_precision_dequantize.hpp

@@ -56,19 +56,26 @@ namespace decomposition {
 /// \param output_shape Optional shape constant. When provided a Reshape with
 ///                     special_zero=false is appended after the Multiply
 ///                     (skipped if the Multiply output already has that shape).
-ov::Output<ov::Node> TRANSFORMATIONS_API low_precision_dequantize(ov::pass::NodeRegistry& reg,
-                                                                  const ov::Output<ov::Node>& x,
-                                                                  const ov::Output<ov::Node>& scale,
-                                                                  const ov::Output<ov::Node>& zero_point = {},
-                                                                  const ov::Output<ov::Node>& output_shape = {});
+/// \param scale_decompression_precision Optional element type for the Convert node
+///                     that converts the quantized scale and zp to the output element type. If not provided, the
+///                     Convert node is omitted and the scale is used as-is.
+ov::Output<ov::Node> TRANSFORMATIONS_API
+low_precision_dequantize(ov::pass::NodeRegistry& reg,
+                         const ov::Output<ov::Node>& x,
+                         const ov::Output<ov::Node>& scale,
+                         const ov::Output<ov::Node>& zero_point = {},
+                         const ov::Output<ov::Node>& output_shape = {},
+                         const ov::element::Type& decompression_precision = ov::element::dynamic);
 
 /// \brief Convenience overload for callers that do not need access to the
 ///        intermediate nodes. Internally allocates a NodeRegistry and
 ///        forwards to the registry-based overload.
-ov::Output<ov::Node> TRANSFORMATIONS_API low_precision_dequantize(const ov::Output<ov::Node>& x,
-                                                                  const ov::Output<ov::Node>& scale,
-                                                                  const ov::Output<ov::Node>& zero_point = {},
-                                                                  const ov::Output<ov::Node>& output_shape = {});
+ov::Output<ov::Node> TRANSFORMATIONS_API
+low_precision_dequantize(const ov::Output<ov::Node>& x,
+                         const ov::Output<ov::Node>& scale,
+                         const ov::Output<ov::Node>& zero_point = {},
+                         const ov::Output<ov::Node>& output_shape = {},
+                         const ov::element::Type& decompression_precision = ov::element::dynamic);
 
 }  // namespace decomposition
 }  // namespace ov

src/common/transformations/include/ov_ops/dynamic_quantize.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "openvino/core/attribute_adapter.hpp"
 #include "openvino/op/op.hpp"
 #include "transformations_visibility.hpp"
 
@@ -56,6 +57,8 @@ class TRANSFORMATIONS_API DynamicQuantize : public ov::op::Op {
 
     std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
 
+    bool visit_attributes(AttributeVisitor& visitor) override;
+
     const Attributes& get_attrs() const {
         return m_attrs;
     }
@@ -89,4 +92,29 @@ class TRANSFORMATIONS_API DynamicQuantize : public ov::op::Op {
 
 }  // namespace internal
 }  // namespace op
+
+std::ostream& operator<<(std::ostream& s, const ov::op::internal::DynamicQuantize::QuantizationType& quantization_type);
+std::ostream& operator<<(std::ostream& s,
+                         const ov::op::internal::DynamicQuantize::OutputStorageType& output_storage_type);
+
+template <>
+class OPENVINO_API AttributeAdapter<ov::op::internal::DynamicQuantize::QuantizationType>
+    : public EnumAttributeAdapterBase<ov::op::internal::DynamicQuantize::QuantizationType> {
+public:
+    AttributeAdapter(ov::op::internal::DynamicQuantize::QuantizationType& value)
+        : EnumAttributeAdapterBase<ov::op::internal::DynamicQuantize::QuantizationType>(value) {}
+
+    OPENVINO_RTTI("AttributeAdapter<ov::op::internal::DynamicQuantize::QuantizationType>");
+};
+
+template <>
+class OPENVINO_API AttributeAdapter<ov::op::internal::DynamicQuantize::OutputStorageType>
+    : public EnumAttributeAdapterBase<ov::op::internal::DynamicQuantize::OutputStorageType> {
+public:
+    AttributeAdapter(ov::op::internal::DynamicQuantize::OutputStorageType& value)
+        : EnumAttributeAdapterBase<ov::op::internal::DynamicQuantize::OutputStorageType>(value) {}
+
+    OPENVINO_RTTI("AttributeAdapter<ov::op::internal::DynamicQuantize::OutputStorageType>");
+};
+
 }  // namespace ov

src/common/transformations/src/decompositions/low_precision_dequantize.cpp

@@ -43,12 +43,14 @@ ov::Output<ov::Node> low_precision_dequantize(ov::pass::NodeRegistry& reg,
                                               const ov::Output<ov::Node>& x,
                                               const ov::Output<ov::Node>& scale,
                                               const ov::Output<ov::Node>& zero_point,
-                                              const ov::Output<ov::Node>& output_shape) {
+                                              const ov::Output<ov::Node>& output_shape,
+                                              const ov::element::Type& decompression_precision) {
     // Decomposition shape (matches ov::pass::MarkDequantization):
     //   Multiply(Subtract(Convert(x), zp), scale) [-> Reshape]
     // or, when zero_point is empty:
     //   Multiply(Convert(x), scale) [-> Reshape]
-    const auto& dst_type = scale.get_element_type();
+    const auto& dst_type =
+        decompression_precision == ov::element::dynamic ? scale.get_element_type() : decompression_precision;
     ov::Output<ov::Node> result = reg.make<ov::op::v0::Convert>(x, dst_type);
 
     if (zero_point.get_node_shared_ptr()) {
@@ -59,7 +61,11 @@ ov::Output<ov::Node> low_precision_dequantize(ov::pass::NodeRegistry& reg,
         result = reg.make<ov::op::v1::Subtract>(result, zp);
     }
 
-    result = reg.make<ov::op::v1::Multiply>(result, scale);
+    ov::Output<ov::Node> scale_convert = scale;
+    if (scale.get_element_type() != dst_type) {
+        scale_convert = reg.make<ov::op::v0::Convert>(scale, dst_type);
+    }
+    result = reg.make<ov::op::v1::Multiply>(result, scale_convert);
 
     if (output_shape.get_node_shared_ptr() && !reshape_is_noop(result, output_shape)) {
         result = reg.make<ov::op::v1::Reshape>(result, output_shape, /*special_zero=*/false);
@@ -71,9 +77,10 @@ ov::Output<ov::Node> low_precision_dequantize(ov::pass::NodeRegistry& reg,
 ov::Output<ov::Node> low_precision_dequantize(const ov::Output<ov::Node>& x,
                                               const ov::Output<ov::Node>& scale,
                                               const ov::Output<ov::Node>& zero_point,
-                                              const ov::Output<ov::Node>& output_shape) {
+                                              const ov::Output<ov::Node>& output_shape,
+                                              const ov::element::Type& decompression_precision) {
     ov::pass::NodeRegistry reg;
-    return low_precision_dequantize(reg, x, scale, zero_point, output_shape);
+    return low_precision_dequantize(reg, x, scale, zero_point, output_shape, decompression_precision);
 }
 
 }  // namespace decomposition

src/common/transformations/src/ov_ops/dynamic_quantize.cpp

@@ -4,6 +4,7 @@
 
 #include "ov_ops/dynamic_quantize.hpp"
 
+#include "itt.hpp"
 #include "openvino/core/partial_shape.hpp"
 #include "openvino/core/validation_util.hpp"
 #include "openvino/op/variadic_split.hpp"
@@ -134,6 +135,55 @@ std::vector<ov::PartialShape> DynamicQuantize::shape_infer(const DynamicQuantize
     return out_shapes;
 }
 
+bool DynamicQuantize::visit_attributes(AttributeVisitor& visitor) {
+    INTERNAL_OP_SCOPE(internal_DynamicQuantize_visit_attributes);
+    visitor.on_attribute("quantization_type", m_attrs.quantization_type);
+    visitor.on_attribute("quantization_dt", m_attrs.quantization_dt);
+    visitor.on_attribute("scale_dt", m_attrs.scale_dt);
+    visitor.on_attribute("zp_dt", m_attrs.zp_dt);
+    visitor.on_attribute("precomputed_reduction_dt", m_attrs.precomputed_reduction_dt);
+    visitor.on_attribute("precomputed_reduction", m_attrs.precomputed_reduction);
+    visitor.on_attribute("group_sizes", m_attrs.group_sizes);
+    visitor.on_attribute("scales_zp_output_order", m_attrs.scales_zp_output_order);
+    visitor.on_attribute("output_storage_type", m_attrs.output_storage_type);
+    return true;
+}
+
 }  // namespace internal
 }  // namespace op
+
+std::ostream& operator<<(std::ostream& s,
+                         const ov::op::internal::DynamicQuantize::QuantizationType& quantization_type) {
+    return s << ov::as_string(quantization_type);
+}
+
+std::ostream& operator<<(std::ostream& s,
+                         const ov::op::internal::DynamicQuantize::OutputStorageType& output_storage_type) {
+    return s << ov::as_string(output_storage_type);
+}
+
+template <>
+OPENVINO_API EnumNames<ov::op::internal::DynamicQuantize::QuantizationType>&
+EnumNames<ov::op::internal::DynamicQuantize::QuantizationType>::get() {
+    static auto enum_names = EnumNames<ov::op::internal::DynamicQuantize::QuantizationType>(
+        "ov::op::internal::DynamicQuantize::QuantizationType",
+        {
+            {"symmetric", ov::op::internal::DynamicQuantize::QuantizationType::Symmetric},
+            {"asymmetric", ov::op::internal::DynamicQuantize::QuantizationType::Asymmetric},
+        });
+    return enum_names;
+}
+
+template <>
+OPENVINO_API EnumNames<ov::op::internal::DynamicQuantize::OutputStorageType>&
+EnumNames<ov::op::internal::DynamicQuantize::OutputStorageType>::get() {
+    static auto enum_names = EnumNames<ov::op::internal::DynamicQuantize::OutputStorageType>(
+        "ov::op::internal::DynamicQuantize::OutputStorageType",
+        {
+            {"planar", ov::op::internal::DynamicQuantize::OutputStorageType::Planar},
+            {"interleaved_scales_zp", ov::op::internal::DynamicQuantize::OutputStorageType::InterleavedScalesZP},
+        });
+    return enum_names;
+}
+
 }  // namespace ov

src/common/transformations/src/transformations/common_optimizations/moc_transformations.cpp

@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "itt.hpp"
+#include "low_precision/low_precision.hpp"
 #include "openvino/pass/constant_folding.hpp"
 #include "openvino/pass/manager.hpp"
 #include "transformations/common_optimizations/adaptive_pool_to_reduce.hpp"
@@ -146,7 +147,8 @@ bool ov::pass::MOCTransformations::run_on_model(const std::shared_ptr<ov::Model>
         // Transformation call example, to check with the real model
         manager.register_pass<MarkGatherSubgraph>(TypeVector{f8e4m3}, TypeVector{u4});
         manager.register_pass<ov::pass::MarkDequantization>(
-            TypeVector{i32, u32, i16, u16, i8, u8, u6, i4, u4, nf4, u3, u2, u1, f4e2m1, f8e4m3, f8e5m2, f8e8m0});
+            TypeVector{i32, u32, i16, u16, i8, u8, u6, i4, u4, nf4, u3, u2, u1, f8e4m3, f8e5m2, f4e2m1, f8e8m0});
+        manager.register_pass<ov::pass::MarkDequantization>(TypeVector{f8e4m3, f8e5m2, f4e2m1, f8e8m0}, false, false);
     }
     if (!m_use_shapes) {
         manager.register_pass<ov::pass::DisableShapeOfConstantFolding>();

src/common/transformations/src/transformations/common_optimizations/shared_ops_optimization.cpp

@@ -176,7 +176,7 @@ bool shared_node_optimization(const shared_ptr<Model>& model) {
 
                         if (nodes_are_equal(root_op, child_op, node_attributes_cache)) {
                             rewritten =
-                                replace_output_update_name(child_op->output(0), root_op->output(0)) || rewritten;
+                                replace_outputs_update_name(child_op->outputs(), root_op->outputs()) || rewritten;
                             visited_nodes[j] = true;
                         }
                     }

src/common/transformations/tests/decompositions/low_precision_dequantize_decomposition_mark_test.cpp

@@ -30,7 +30,14 @@ using namespace ov;
 
 namespace {
 
-const element::TypeVector kLowPrecisionTypes{element::u8, element::i8, element::u4, element::i4};
+const element::TypeVector kLowPrecisionTypes{element::u8,
+                                             element::i8,
+                                             element::u4,
+                                             element::i4,
+                                             element::f8e4m3,
+                                             element::f8e5m2,
+                                             element::f4e2m1,
+                                             element::f8e8m0};
 
 }  // namespace
 
@@ -231,3 +238,129 @@ TEST_F(TransformationTestsF, LowPrecisionDequantize_NoopReshapeSkipped) {
     comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
     comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
 }
+
+TEST_F(TransformationTestsF, LowPrecisionDequantize_f8e4m3) {
+    const Shape weights_shape{4, 16};
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e4m3, weights_shape, {-2});
+        auto scale = op::v0::Constant::create(element::f16, Shape{}, {0.2f});
+
+        auto out = decomposition::low_precision_dequantize(weights, scale);
+        model = std::make_shared<Model>(OutputVector{out}, ParameterVector{});
+    }
+
+    manager.register_pass<pass::MarkDequantization>(kLowPrecisionTypes);
+    manager.register_pass<pass::ConstantFolding>();
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e4m3, weights_shape, {-2});
+        auto convert = std::make_shared<op::v0::Convert>(weights, element::f16);
+        disable_constant_folding(convert);
+
+        auto scale = op::v0::Constant::create(element::f16, Shape{}, {0.2f});
+        auto multiply = std::make_shared<op::v1::Multiply>(convert, scale);
+        mark_as_dequantization_node(multiply);
+
+        model_ref = std::make_shared<Model>(OutputVector{multiply}, ParameterVector{});
+    }
+
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+    comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
+}
+
+TEST_F(TransformationTestsF, LowPrecisionDequantize_f8e5m2) {
+    const Shape weights_shape{4, 16};
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e5m2, weights_shape, {-2});
+        auto scale = op::v0::Constant::create(element::f16, Shape{}, {0.2f});
+
+        auto out = decomposition::low_precision_dequantize(weights, scale);
+        model = std::make_shared<Model>(OutputVector{out}, ParameterVector{});
+    }
+
+    manager.register_pass<pass::MarkDequantization>(kLowPrecisionTypes);
+    manager.register_pass<pass::ConstantFolding>();
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e5m2, weights_shape, {-2});
+        auto convert = std::make_shared<op::v0::Convert>(weights, element::f16);
+        disable_constant_folding(convert);
+
+        auto scale = op::v0::Constant::create(element::f16, Shape{}, {0.2f});
+        auto multiply = std::make_shared<op::v1::Multiply>(convert, scale);
+        mark_as_dequantization_node(multiply);
+
+        model_ref = std::make_shared<Model>(OutputVector{multiply}, ParameterVector{});
+    }
+
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+    comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
+}
+
+TEST_F(TransformationTestsF, LowPrecisionDequantize_mxf8e4m3) {
+    const Shape weights_shape{4, 32};
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e4m3, weights_shape, {-2});
+        auto scale = op::v0::Constant::create(element::f8e8m0, Shape{}, {0.2f});
+
+        auto out = decomposition::low_precision_dequantize(weights, scale, {}, {}, element::f16);
+        model = std::make_shared<Model>(OutputVector{out}, ParameterVector{});
+    }
+
+    manager.register_pass<pass::MarkDequantization>(kLowPrecisionTypes, false, false);
+    manager.register_pass<pass::ConstantFolding>();
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e4m3, weights_shape, {-2});
+        auto convert_weights = std::make_shared<op::v0::Convert>(weights, element::f16);
+        disable_constant_folding(convert_weights);
+
+        auto scale = op::v0::Constant::create(element::f8e8m0, Shape{}, {0.2f});
+        auto convert_scale = std::make_shared<op::v0::Convert>(scale, element::f16);
+        disable_constant_folding(convert_scale);
+
+        auto multiply = std::make_shared<op::v1::Multiply>(convert_weights, convert_scale);
+        mark_as_dequantization_node(multiply);
+
+        model_ref = std::make_shared<Model>(OutputVector{multiply}, ParameterVector{});
+    }
+
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+    comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
+}
+
+TEST_F(TransformationTestsF, LowPrecisionDequantize_mxf8e5m2) {
+    const Shape weights_shape{4, 32};
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e5m2, weights_shape, {-2});
+        auto scale = op::v0::Constant::create(element::f8e8m0, Shape{}, {0.2f});
+
+        auto out = decomposition::low_precision_dequantize(weights, scale, {}, {}, element::f16);
+        model = std::make_shared<Model>(OutputVector{out}, ParameterVector{});
+    }
+
+    manager.register_pass<pass::MarkDequantization>(kLowPrecisionTypes, false, false);
+    manager.register_pass<pass::ConstantFolding>();
+
+    {
+        auto weights = op::v0::Constant::create(element::f8e5m2, weights_shape, {-2});
+        auto convert_weights = std::make_shared<op::v0::Convert>(weights, element::f16);
+        disable_constant_folding(convert_weights);
+
+        auto scale = op::v0::Constant::create(element::f8e8m0, Shape{}, {0.2f});
+        auto convert_scale = std::make_shared<op::v0::Convert>(scale, element::f16);
+        disable_constant_folding(convert_scale);
+
+        auto multiply = std::make_shared<op::v1::Multiply>(convert_weights, convert_scale);
+        mark_as_dequantization_node(multiply);
+
+        model_ref = std::make_shared<Model>(OutputVector{multiply}, ParameterVector{});
+    }
+
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+    comparator.enable(FunctionsComparator::CmpValues::RUNTIME_KEYS);
+}

src/core/include/openvino/core/graph_util.hpp

@@ -292,6 +292,9 @@ bool compare_constants(const std::shared_ptr<Node>& n1, const std::shared_ptr<No
 OPENVINO_API
 bool replace_output_update_name(Output<Node> node, const Output<Node>& node_input);
 
+OPENVINO_API
+bool replace_outputs_update_name(OutputVector nodes, const OutputVector& node_inputs);
+
 OPENVINO_API
 bool replace_node_update_name(const std::shared_ptr<Node>& target, const std::shared_ptr<Node>& replacement);