onnx 1.17.0__cp312-cp312-win_amd64.whl → 1.19.0__cp312-cp312-win_amd64.whl

onnx/defs/parser.h

@@ -7,10 +7,7 @@
 
 #pragma once
 
-#include <ctype.h>
-
-#include <iostream>
-#include <stdexcept>
+#include <cctype>
 #include <string>
 #include <unordered_map>
 
@@ -44,6 +41,7 @@ using StringStringList = google::protobuf::RepeatedPtrField<StringStringEntryPro
   }
 
 template <typename Map>
+// NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility)
 class StringIntMap {
  public:
   static const std::unordered_map<std::string, int32_t>& Instance() {
@@ -94,8 +92,10 @@ class PrimitiveTypeNameMap : public StringIntMap<PrimitiveTypeNameMap> {
     map_["float8e4m3fnuz"] = TensorProto_DataType_FLOAT8E4M3FNUZ;
     map_["float8e5m2"] = TensorProto_DataType_FLOAT8E5M2;
     map_["float8e5m2fnuz"] = TensorProto_DataType_FLOAT8E5M2FNUZ;
+    map_["float8e8m0"] = TensorProto_DataType_FLOAT8E8M0;
     map_["uint4"] = TensorProto_DataType_UINT4;
     map_["int4"] = TensorProto_DataType_INT4;
+    map_["float4e2m1"] = TensorProto_DataType_FLOAT4E2M1;
   }
 
   static bool IsTypeName(const std::string& dtype) {
@@ -125,7 +125,7 @@ class AttributeTypeNameMap : public StringIntMap<AttributeTypeNameMap> {
 
 class KeyWordMap {
  public:
-  enum class KeyWord {
+  enum class KeyWord : std::uint8_t {
     NONE,
     IR_VERSION,
     OPSET_IMPORT,
@@ -158,10 +158,7 @@ class KeyWordMap {
     map_["overload"] = KeyWord::OVERLOAD_KW;
   }
 
-  static const std::unordered_map<std::string, KeyWord>& Instance() {
-    static KeyWordMap instance;
-    return instance.map_;
-  }
+  static const std::unordered_map<std::string, KeyWord>& Instance();
 
   static KeyWord Lookup(const std::string& id) {
     auto it = Instance().find(id);
@@ -170,14 +167,7 @@ class KeyWordMap {
     return KeyWord::NONE;
   }
 
-  static const std::string& ToString(KeyWord kw) {
-    static std::string undefined("undefined");
-    for (const auto& pair : Instance()) {
-      if (pair.second == kw)
-        return pair.first;
-    }
-    return undefined;
-  }
+  static const std::string& ToString(KeyWord kw);
 
  private:
   std::unordered_map<std::string, KeyWord> map_;
@@ -185,10 +175,10 @@ class KeyWordMap {
 
 class ParserBase {
  public:
-  ParserBase(const std::string& str)
+  explicit ParserBase(const std::string& str)
       : start_(str.data()), next_(str.data()), end_(str.data() + str.length()), saved_pos_(next_) {}
 
-  ParserBase(const char* cstr) : start_(cstr), next_(cstr), end_(cstr + strlen(cstr)), saved_pos_(next_) {}
+  explicit ParserBase(const char* cstr) : start_(cstr), next_(cstr), end_(cstr + strlen(cstr)), saved_pos_(next_) {}
 
   void SavePos() {
     saved_pos_ = next_;
@@ -230,8 +220,8 @@ class ParserBase {
   template <typename... Args>
   Status ParseError(const Args&... args) {
     return Status(
-        NONE,
-        FAIL,
+        StatusCategory::NONE,
+        StatusCode::FAIL,
         ONNX_NAMESPACE::MakeString(
             "[ParseError at position ", GetCurrentPos(), "]\n", "Error context: ", GetErrorContext(), "\n", args...));
   }
@@ -275,10 +265,10 @@ class ParserBase {
     return (next_ >= end_);
   }
 
-  enum class LiteralType { INT_LITERAL, FLOAT_LITERAL, STRING_LITERAL };
+  enum class LiteralType : std::uint8_t { UNDEFINED, INT_LITERAL, FLOAT_LITERAL, STRING_LITERAL };
 
   struct Literal {
-    LiteralType type;
+    LiteralType type{LiteralType::UNDEFINED};
     std::string value;
   };
 
@@ -286,7 +276,7 @@ class ParserBase {
 
   Status Parse(int64_t& val) {
     Literal literal;
-    CHECK_PARSER_STATUS(Parse(literal));
+    CHECK_PARSER_STATUS(Parse(literal))
     if (literal.type != LiteralType::INT_LITERAL)
       return ParseError("Integer value expected, but not found.");
     std::string s = literal.value;
@@ -296,7 +286,7 @@ class ParserBase {
 
   Status Parse(uint64_t& val) {
     Literal literal;
-    CHECK_PARSER_STATUS(Parse(literal));
+    CHECK_PARSER_STATUS(Parse(literal))
     if (literal.type != LiteralType::INT_LITERAL)
       return ParseError("Integer value expected, but not found.");
     std::string s = literal.value;
@@ -306,7 +296,7 @@ class ParserBase {
 
   Status Parse(float& val) {
     Literal literal;
-    CHECK_PARSER_STATUS(Parse(literal));
+    CHECK_PARSER_STATUS(Parse(literal))
     switch (literal.type) {
       case LiteralType::INT_LITERAL:
       case LiteralType::FLOAT_LITERAL:
@@ -320,7 +310,7 @@ class ParserBase {
 
   Status Parse(double& val) {
     Literal literal;
-    CHECK_PARSER_STATUS(Parse(literal));
+    CHECK_PARSER_STATUS(Parse(literal))
     switch (literal.type) {
       case LiteralType::INT_LITERAL:
       case LiteralType::FLOAT_LITERAL:
@@ -332,10 +322,10 @@ class ParserBase {
     return Status::OK();
   }
 
-  // Parse a string-literal enclosed within doube-quotes.
+  // Parse a string-literal enclosed within double-quotes.
   Status Parse(std::string& val) {
     Literal literal;
-    CHECK_PARSER_STATUS(Parse(literal));
+    CHECK_PARSER_STATUS(Parse(literal))
     if (literal.type != LiteralType::STRING_LITERAL)
       return ParseError("String value expected, but not found.");
     val = literal.value;
@@ -344,7 +334,7 @@ class ParserBase {
 
   // Parse an identifier, including keywords. If none found, this will
   // return an empty-string identifier.
-  Status ParseOptionalIdentifier(std::string& id) {
+  std::string ParseOptionalIdentifier() {
     SkipWhiteSpace();
     auto from = next_;
     if ((next_ < end_) && (isalpha(*next_) || (*next_ == '_'))) {
@@ -352,27 +342,64 @@ class ParserBase {
       while ((next_ < end_) && (isalnum(*next_) || (*next_ == '_')))
         ++next_;
     }
-    id = std::string(from, next_ - from);
-    return Status::OK();
+    return std::string(from, next_ - from);
   }
 
   Status ParseIdentifier(std::string& id) {
-    ParseOptionalIdentifier(id);
+    id = ParseOptionalIdentifier();
     if (id.empty())
       return ParseError("Identifier expected but not found.");
     return Status::OK();
   }
 
-  Status PeekIdentifier(std::string& id) {
+  Status ParseQuotableIdentifier(std::string& id) {
+    if (NextChar() == '"') {
+      return Parse(id);
+    }
+    return ParseIdentifier(id);
+  }
+
+  Status ParseOptionalQuotableIdentifier(std::string& id) {
+    if (NextChar() == '"') {
+      return Parse(id);
+    }
+    id = ParseOptionalIdentifier();
+    return Status::OK();
+  }
+
+  // Parse an optional quotable identifier, and return whether an identifier was found
+  // in the output parameter 'id_found'.
+  // A empty string followed by a comma is considered to be a valid, but empty, identifier.
+  // This helps handle the following different cases:
+  // "Op()" has no operands
+  // "Op(,x)" has two operands, the first being empty.
+  // 'Op("")' has one operand, which is an empty string.
+  // 'Op(,)' has one operand, which is an empty string.
+  // Thus, this will also allow a trailing comma after a non-empty identifier with no effect.
+  // 'Op(x,)' has one operand, which is 'x'.
+  //
+  // This is mostly for some backward compatibility. "" is a simpler way to represent an
+  // empty identifier that is less confusing and is recommended.
+  Status ParseOptionalQuotableIdentifier(std::string& id, bool& id_found) {
+    if (NextChar() == '"') {
+      id_found = true;
+      return Parse(id);
+    }
+    id = ParseOptionalIdentifier();
+    id_found = !id.empty() || NextChar() == ',';
+    return Status::OK();
+  }
+
+  std::string PeekIdentifier() {
     SavePos();
-    ParseOptionalIdentifier(id);
+    auto id = ParseOptionalIdentifier();
     RestorePos();
-    return Status::OK();
+    return id;
   }
 
   Status Parse(KeyWordMap::KeyWord& keyword) {
     std::string id;
-    CHECK_PARSER_STATUS(ParseIdentifier(id));
+    CHECK_PARSER_STATUS(ParseIdentifier(id))
     keyword = KeyWordMap::Lookup(id);
     return Status::OK();
   }
@@ -388,31 +415,31 @@ class ParserBase {
 
 class OnnxParser : public ParserBase {
  public:
-  OnnxParser(const char* cstr) : ParserBase(cstr) {}
+  explicit OnnxParser(const char* cstr) : ParserBase(cstr) {}
 
-  Status Parse(TensorShapeProto& shape);
+  ONNX_API Status Parse(TensorShapeProto& shape);
 
-  Status Parse(TypeProto& typeProto);
+  ONNX_API Status Parse(TypeProto& typeProto);
 
-  Status Parse(StringStringList& stringStringList);
+  ONNX_API Status Parse(StringStringList& stringStringList);
 
-  Status Parse(TensorProto& tensorProto);
+  ONNX_API Status Parse(TensorProto& tensorProto);
 
-  Status Parse(AttributeProto& attr);
+  ONNX_API Status Parse(AttributeProto& attr);
 
-  Status Parse(AttributeProto& attr, std::string& name);
+  ONNX_API Status Parse(AttributeProto& attr, std::string& name);
 
-  Status Parse(AttrList& attrlist);
+  ONNX_API Status Parse(AttrList& attrlist);
 
-  Status Parse(NodeProto& node);
+  ONNX_API Status Parse(NodeProto& node);
 
-  Status Parse(NodeList& nodelist);
+  ONNX_API Status Parse(NodeList& nodelist);
 
-  Status Parse(GraphProto& graph);
+  ONNX_API Status Parse(GraphProto& graph);
 
-  Status Parse(FunctionProto& fn);
+  ONNX_API Status Parse(FunctionProto& fn);
 
-  Status Parse(ModelProto& model);
+  ONNX_API Status Parse(ModelProto& model);
 
   template <typename T>
   static Status Parse(T& parsedData, const char* input) {

onnx/defs/printer.cc

@@ -5,7 +5,6 @@
 #include "onnx/defs/printer.h"
 
 #include <iomanip>
-#include <vector>
 
 #include "onnx/defs/tensor_proto_util.h"
 
@@ -13,9 +12,23 @@ namespace ONNX_NAMESPACE {
 
 using StringStringEntryProtos = google::protobuf::RepeatedPtrField<StringStringEntryProto>;
 
+static bool IsValidIdentifier(const std::string& str) {
+  // Check if str is a valid identifier
+  const char* next_ = str.c_str();
+  const char* end_ = next_ + str.size();
+  if (next_ == end_)
+    return false; // empty string is not a valid identifier
+  if (!isalpha(*next_) && (*next_ != '_'))
+    return false; // first character must be a letter or '_'
+  ++next_;
+  while ((next_ < end_) && (isalnum(*next_) || (*next_ == '_')))
+    ++next_;
+  return next_ == end_;
+}
+
 class ProtoPrinter {
  public:
-  ProtoPrinter(std::ostream& os) : output_(os) {}
+  explicit ProtoPrinter(std::ostream& os) : output_(os) {}
 
   void print(const TensorShapeProto_Dimension& dim);
 
@@ -68,8 +81,15 @@ class ProtoPrinter {
   }
 
  private:
+  void printId(const std::string& str) {
+    if (IsValidIdentifier(str))
+      output_ << str;
+    else
+      printQuoted(str);
+  }
+
   template <typename T>
-  inline void print(T prim) {
+  inline void print(const T& prim) {
     output_ << prim;
   }
 
@@ -86,19 +106,19 @@ class ProtoPrinter {
   template <typename T>
   inline void printKeyValuePair(KeyWordMap::KeyWord key, const T& val, bool addsep = true) {
     if (addsep)
-      output_ << "," << std::endl;
+      output_ << "," << '\n';
     output_ << std::setw(indent_level) << ' ' << KeyWordMap::ToString(key) << ": ";
     print(val);
   }
 
   inline void printKeyValuePair(KeyWordMap::KeyWord key, const std::string& val) {
-    output_ << "," << std::endl;
+    output_ << "," << '\n';
     output_ << std::setw(indent_level) << ' ' << KeyWordMap::ToString(key) << ": ";
     printQuoted(val);
   }
 
   template <typename Collection>
-  inline void printSet(const char* open, const char* separator, const char* close, Collection coll) {
+  inline void printSet(const char* open, const char* separator, const char* close, const Collection& coll) {
     const char* sep = "";
     output_ << open;
     for (auto& elt : coll) {
@@ -109,6 +129,18 @@ class ProtoPrinter {
     output_ << close;
   }
 
+  template <typename Collection>
+  inline void printIdSet(const char* open, const char* separator, const char* close, const Collection& coll) {
+    const char* sep = "";
+    output_ << open;
+    for (auto& elt : coll) {
+      output_ << sep;
+      printId(elt);
+      sep = separator;
+    }
+    output_ << close;
+  }
+
   std::ostream& output_;
   int indent_level = 3;
 
@@ -191,7 +223,8 @@ void ProtoPrinter::print(const TensorProto& tensor, bool is_initializer) {
     printSet("[", ",", "]", tensor.dims());
 
   if (!tensor.name().empty()) {
-    output_ << " " << tensor.name();
+    output_ << " ";
+    printId(tensor.name());
   }
   if (is_initializer) {
     output_ << " = ";
@@ -258,7 +291,8 @@ void ProtoPrinter::print(const TensorProto& tensor, bool is_initializer) {
 
 void ProtoPrinter::print(const ValueInfoProto& value_info) {
   print(value_info.type());
-  output_ << " " << value_info.name();
+  output_ << " ";
+  printId(value_info.name());
 }
 
 void ProtoPrinter::print(const ValueInfoList& vilist) {
@@ -331,20 +365,25 @@ void ProtoPrinter::print(const AttrList& attrlist) {
 
 void ProtoPrinter::print(const NodeProto& node) {
   output_ << std::setw(indent_level) << ' ';
-  printSet("", ", ", "", node.output());
+  if (node.has_name()) {
+    output_ << "[";
+    printId(node.name());
+    output_ << "] ";
+  }
+  printIdSet("", ", ", "", node.output());
   output_ << " = ";
-  if (node.domain() != "")
+  if (!node.domain().empty())
     output_ << node.domain() << ".";
   output_ << node.op_type();
-  if (node.overload() != "")
+  if (!node.overload().empty())
     output_ << ":" << node.overload();
   bool has_subgraph = false;
-  for (auto attr : node.attribute())
+  for (const auto& attr : node.attribute())
     if (attr.has_g() || (attr.graphs_size() > 0))
       has_subgraph = true;
   if ((!has_subgraph) && (node.attribute_size() > 0))
     print(node.attribute());
-  printSet(" (", ", ", ")", node.input());
+  printIdSet(" (", ", ", ")", node.input());
   if ((has_subgraph) && (node.attribute_size() > 0))
     print(node.attribute());
   output_ << "\n";
@@ -361,9 +400,10 @@ void ProtoPrinter::print(const NodeList& nodelist) {
 }
 
 void ProtoPrinter::print(const GraphProto& graph) {
-  output_ << graph.name() << " " << graph.input() << " => " << graph.output() << " ";
+  printId(graph.name());
+  output_ << " " << graph.input() << " => " << graph.output() << " ";
   if ((graph.initializer_size() > 0) || (graph.value_info_size() > 0)) {
-    output_ << std::endl << std::setw(indent_level) << ' ' << '<';
+    output_ << '\n' << std::setw(indent_level) << ' ' << '<';
     const char* sep = "";
     for (auto& init : graph.initializer()) {
       output_ << sep;
@@ -375,7 +415,7 @@ void ProtoPrinter::print(const GraphProto& graph) {
       print(vi);
       sep = ", ";
     }
-    output_ << ">" << std::endl;
+    output_ << ">" << '\n';
   }
   print(graph.node());
 }
@@ -396,11 +436,11 @@ void ProtoPrinter::print(const ModelProto& model) {
     printKeyValuePair(KeyWordMap::KeyWord::DOC_STRING, model.doc_string());
   if (model.metadata_props_size() > 0)
     printKeyValuePair(KeyWordMap::KeyWord::METADATA_PROPS, model.metadata_props());
-  output_ << std::endl << ">" << std::endl;
+  output_ << '\n' << ">" << '\n';
 
   print(model.graph());
   for (const auto& fn : model.functions()) {
-    output_ << std::endl;
+    output_ << '\n';
     print(fn);
   }
 }
@@ -425,12 +465,13 @@ void ProtoPrinter::print(const FunctionProto& fn) {
           << "opset_import: ";
   printSet("[", ",", "]", fn.opset_import());
   output_ << "\n>\n";
-  output_ << fn.name() << " ";
+  printId(fn.name());
+  output_ << " ";
   if (fn.attribute_size() > 0)
     printSet("<", ",", ">", fn.attribute());
-  printSet("(", ", ", ")", fn.input());
+  printIdSet("(", ", ", ")", fn.input());
   output_ << " => ";
-  printSet("(", ", ", ")", fn.output());
+  printIdSet("(", ", ", ")", fn.output());
   output_ << "\n";
   print(fn.node());
 }

onnx/defs/quantization/defs.cc

@@ -7,7 +7,7 @@
 
 namespace ONNX_NAMESPACE {
 
-static const char* QuantizeLinear_ver21_doc = R"DOC(
+static const char* QuantizeLinear_ver24_doc = R"DOC(
 The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
 low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
 granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
@@ -22,8 +22,10 @@ Saturation is done according to:
 
 For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
 
-`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 types, but the quantization
+`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
 formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+`x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+`y_scale`, unless the `precision` attribute is specified.
 
 There are three supported quantization granularities, determined by the shape of `y_scale`.
 In all cases, `y_zero_point` must have the same shape as `y_scale`.
@@ -37,7 +39,7 @@ In all cases, `y_zero_point` must have the same shape as `y_scale`.
 
 ONNX_OPERATOR_SET_SCHEMA(
     QuantizeLinear,
-    21,
+    24,
     OpSchema()
         .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
         .Input(
@@ -46,15 +48,15 @@ ONNX_OPERATOR_SET_SCHEMA(
             "Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for "
             "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
             "input, except for one dimension in which blocking is performed.",
-            "T1")
+            "T2")
         .Input(
             2,
             "y_zero_point",
-            "Zero point for doing quantization to get `y`. Shape must match `y_scale`."
+            "Zero point for doing quantization to get `y`. Shape must match `y_scale`. "
             "Default is uint8 with zero point of 0 if it's not specified.",
-            "T2",
+            "T3",
             OpSchema::Optional)
-        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T2")
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T3")
         .Attr(
             "axis",
             "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked "
@@ -81,9 +83,15 @@ ONNX_OPERATOR_SET_SCHEMA(
             static_cast<int64_t>(0))
         .Attr(
             "output_dtype",
-            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T2`). "
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). "
             "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
-            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T2`.",
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "precision",
+            "(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, "
+            "it will be the same as the type of `y_scale`.",
             AttributeProto::INT,
             static_cast<int64_t>(0))
         .TypeConstraint(
@@ -92,6 +100,10 @@ ONNX_OPERATOR_SET_SCHEMA(
             "The type of the input 'x'.")
         .TypeConstraint(
             "T2",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(int32)", "tensor(float8e8m0)"},
+            "The type of the input 'y_scale'.")
+        .TypeConstraint(
+            "T3",
             {"tensor(int8)",
              "tensor(uint8)",
              "tensor(int16)",
@@ -101,9 +113,10 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(float8e5m2)",
              "tensor(float8e5m2fnuz)",
              "tensor(uint4)",
-             "tensor(int4)"},
+             "tensor(int4)",
+             "tensor(float4e2m1)"},
             "The type of the input `y_zero_point` and the output `y`.")
-        .SetDoc(QuantizeLinear_ver21_doc)
+        .SetDoc(QuantizeLinear_ver24_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
           auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
           auto const output_dtype =
@@ -132,7 +145,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           updateOutputShape(ctx, 0, input_shape);
         }));
 
-static const char* DequantizeLinear_ver21_doc = R"DOC(
+static const char* DequantizeLinear_ver24_doc = R"DOC(
 The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
 full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
 must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
@@ -141,13 +154,15 @@ See QuantizeLinear for details on quantization granularity.
 
 `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
 `int32`, there's no zero point (zero point is supposed to be 0).
-`zero-point` is usually not used in the case of float8 types quantization, but the dequantization formula remains the same
-for consistency, and `x_scale` still determines the output type.
+`zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
 )DOC";
 
 ONNX_OPERATOR_SET_SCHEMA(
     DequantizeLinear,
-    21,
+    24,
     OpSchema()
         .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
         .Input(
@@ -164,7 +179,12 @@ ONNX_OPERATOR_SET_SCHEMA(
             "It's optional. Zero point is 0 when it's not specified.",
             "T1",
             OpSchema::Optional)
-        .Output(0, "y", "N-D full precision output tensor. It has same shape as input `x`.", "T2")
+        .Output(
+            0,
+            "y",
+            "N-D full precision output tensor. It has the same shape as input `x`. The data type is specified "
+            "by the `output_dtype` attribute or, in its absence, the type of `x_scale`.",
+            "T3")
         .Attr(
             "axis",
             "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
@@ -180,6 +200,11 @@ ONNX_OPERATOR_SET_SCHEMA(
             "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
             AttributeProto::INT,
             static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
         .TypeConstraint(
             "T1",
             {"tensor(int8)",
@@ -192,15 +217,23 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(float8e5m2)",
              "tensor(float8e5m2fnuz)",
              "tensor(uint4)",
-             "tensor(int4)"},
+             "tensor(int4)",
+             "tensor(float4e2m1)"},
             "The type of the inputs 'x_zero_point' and 'x'.")
         .TypeConstraint(
             "T2",
-            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"},
-            "'x_scale' determines the output type.")
-        .SetDoc(DequantizeLinear_ver21_doc)
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(float8e8m0)"},
+            "The type of the input 'x_scale'.")
+        .TypeConstraint("T3", {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"}, "The type of the output 'y'.")
+        .SetDoc(DequantizeLinear_ver24_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
-          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          }
           if (!hasInputShape(ctx, 0)) {
             return;
           }