onnx 1.18.0__cp310-cp310-win_amd64.whl → 1.19.1rc1__cp310-cp310-win_amd64.whl

onnx/defs/nn/utils.cc

@@ -0,0 +1,222 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "onnx/defs/nn/utils.h"
+
+#include <algorithm>
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace nn {
+namespace utils {
+
+void AttentionPropagateElemTypeFromInputToOutput(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  int64_t kv_sequence_length = -1;
+  ONNX_NAMESPACE::TensorShapeProto output_shape;
+  ONNX_NAMESPACE::TensorShapeProto qk_matmul_shape;
+  if (hasInputShape(ctx, 0)) {
+    auto& query_shape = getInputShape(ctx, 0);
+    auto& query_dims = query_shape.dim();
+    if ((query_dims.size() != 3) && (query_dims.size() != 4)) {
+      fail_shape_inference("Inputs 0 (query) shall be 3 or 4 dimensions");
+    }
+
+    if (query_dims.size() == 3) {
+      auto* q_num_heads_attr = ctx.getAttribute("q_num_heads");
+      if (q_num_heads_attr == nullptr) {
+        fail_type_inference("3D inputs expected to have q_num_heads attribute.");
+      }
+      auto* kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+      if (kv_num_heads_attr == nullptr) {
+        fail_type_inference("3D inputs expected to have q_num_heads attribute.");
+      }
+    }
+
+    *output_shape.add_dim() = query_dims[0]; // batch_size
+    *output_shape.add_dim() = query_dims[1]; // num_heads for 4D, sequence_length for 3D
+
+    *qk_matmul_shape.add_dim() = query_dims[0]; // batch_size
+
+    if (hasInputShape(ctx, 1)) {
+      auto& key_shape = getInputShape(ctx, 1);
+      auto& key_dims = key_shape.dim();
+      if ((key_dims.size() != 3) && (key_dims.size() != 4)) {
+        fail_shape_inference("Inputs 1 (key) shall be 3 or 4 dimensions");
+      }
+    }
+
+    if (hasInputShape(ctx, 2)) {
+      auto& value_shape = getInputShape(ctx, 2);
+      auto& value_dims = value_shape.dim();
+      if ((value_dims.size() != 3) && (value_dims.size() != 4)) {
+        fail_shape_inference("Inputs 2 (value) shall be 3 or 4 dimensions");
+      }
+
+      // Update Output Shape for 4D inputs
+      // Input 0 (query) has shape (batch_size, q_num_heads, q_sequence_length, head_size)
+      // Input 1 (key) has shape (batch_size, kv_num_heads, kv_sequence_length, head_size)
+      // Input 2 (value) has shape (batch_size, kv_num_heads, kv_sequence_length, v_head_size)
+      // Output 0 has shape (batch_size, q_num_heads, q_sequence_length, v_head_size)
+      if (value_dims.size() == 4 && query_dims.size() == 4) {
+        kv_sequence_length = value_dims[2].dim_value();
+        *output_shape.add_dim() = query_dims[2]; // sequence_length
+        *output_shape.add_dim() = value_dims[3]; // head_size
+        updateOutputShape(ctx, 0, output_shape);
+        // Update qk_matmul_shape
+        *qk_matmul_shape.add_dim() = query_dims[1]; // q_num_heads
+        *qk_matmul_shape.add_dim() = query_dims[2]; // q_sequence_length
+        qk_matmul_shape.add_dim()->set_dim_value(kv_sequence_length);
+      }
+
+      // Update Output Shape for 3D inputs
+      // Input 0 (query) has shape (batch_size, q_sequence_length, q_hidden_size),
+      // q_hidden_size = q_num_heads * head_size
+      // Input 1 (key) has shape (batch_size, kv_sequence_length, k_hidden_size),
+      // k_hidden_size = kv_num_heads * head_size
+      // Input 2 (value) has shape (batch_size, kv_sequence_length, v_hidden_size),
+      // v_hidden_size = kv_num_heads * v_head_size
+      // Output 0 has shape (batch_size, q_sequence_length, hidden_size),
+      // hidden_size = q_num_heads * v_head_size
+      if (value_dims.size() == 3 && query_dims.size() == 3) {
+        kv_sequence_length = value_dims[1].dim_value();
+        auto* q_num_heads_attr = ctx.getAttribute("q_num_heads");
+        if (q_num_heads_attr == nullptr) {
+          fail_type_inference("3D inputs expected to have q_num_heads attribute.");
+        }
+        auto* kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+        if (kv_num_heads_attr == nullptr) {
+          fail_type_inference("3D inputs expected to have kv_num_heads attribute.");
+        }
+        int64_t q_num_heads = q_num_heads_attr->i();
+        int64_t kv_num_heads = kv_num_heads_attr->i();
+        // Calculate v_head_size
+        int64_t v_head_size = value_dims[2].dim_value() / kv_num_heads;
+        output_shape.add_dim()->set_dim_value(v_head_size * q_num_heads);
+        updateOutputShape(ctx, 0, output_shape);
+        // Update qk_matmul_shape
+        qk_matmul_shape.add_dim()->set_dim_value(q_num_heads);
+        *qk_matmul_shape.add_dim() = query_dims[1];
+        qk_matmul_shape.add_dim()->set_dim_value(kv_sequence_length);
+      }
+    }
+  }
+
+  if (ctx.hasOutput(3)) { // has qk_matmul_output
+    propagateElemTypeFromInputToOutput(ctx, 0, 3);
+    updateOutputShape(ctx, 3, qk_matmul_shape);
+  }
+
+  if (ctx.hasOutput(1) && ctx.hasOutput(2)) { // has present outputs
+    if (ctx.hasInput(4) && ctx.hasInput(5)) { // has past_key
+      // copy the type from query to present key and value
+      propagateElemTypeFromInputToOutput(ctx, 4, 1);
+      propagateElemTypeFromInputToOutput(ctx, 5, 2);
+
+      if (hasInputShape(ctx, 4) && hasInputShape(ctx, 5)) {
+        auto& past_key_shape = getInputShape(ctx, 4);
+        auto& past_key_dims = past_key_shape.dim();
+        auto& past_value_shape = getInputShape(ctx, 5);
+        auto& past_value_dims = past_value_shape.dim();
+
+        // past key has shape (batch_size, kv_num_heads, past_sequence_length, head_size)
+        if (past_key_dims.size() != 4) {
+          fail_shape_inference("The past_key input shall be 4 dimensions");
+        }
+        // past value has shape (batch_size, kv_num_heads, past_sequence_length, v_head_size)
+        if (past_value_dims.size() != 4) {
+          fail_shape_inference("The past_value input shall be 4 dimensions");
+        }
+
+        if (kv_sequence_length > 0 && past_key_dims[2].has_dim_value()) {
+          int64_t total_sequence_length = kv_sequence_length + past_key_dims[2].dim_value();
+
+          ONNX_NAMESPACE::TensorShapeProto present_key_shape;
+          for (auto& dim : past_key_dims) {
+            *present_key_shape.add_dim() = dim;
+          }
+
+          ONNX_NAMESPACE::TensorShapeProto present_value_shape;
+          for (auto& dim : past_value_dims) {
+            *present_value_shape.add_dim() = dim;
+          }
+
+          if (ctx.hasOutput(3)) { // has qk_matmul_output with bias
+            qk_matmul_shape.mutable_dim(3)->set_dim_value(total_sequence_length);
+            updateOutputShape(ctx, 3, qk_matmul_shape);
+          }
+
+          // shape of present key/value is (batch_size, kv_num_heads, total_sequence_length, head_size)
+          present_key_shape.mutable_dim(2)->set_dim_value(total_sequence_length);
+          present_value_shape.mutable_dim(2)->set_dim_value(total_sequence_length);
+
+          updateOutputShape(ctx, 1, present_key_shape);
+          updateOutputShape(ctx, 2, present_value_shape);
+        }
+      }
+    }
+  }
+}
+
+bool AttentionAppendFunctionCausalMask(const FunctionBodyBuildContext& ctx, FunctionBuilder& builder, bool padding) {
+  builder.Add("NewKVSeqLen =  Shape <start = -2, end = -1> (PresentKey)")
+      .Add("AttnBiasShape = Concat <axis = 0> (QSeqLen, NewKVSeqLen)");
+  float neg_inf = -std::numeric_limits<float>::infinity();
+  builder.Const1D("FloatNegInf", neg_inf);
+  builder.Const1D("ScalarZero", 0.f);
+
+  // If attn_mask is provided
+  if (ctx.hasInput(3)) {
+    auto* up = ctx.getInputType(3);
+    if ((up == nullptr) || (!up->has_tensor_type()))
+      return false;
+    int64_t U = up->tensor_type().elem_type();
+    builder.Add(
+        U == ONNX_NAMESPACE::TensorProto_DataType_BOOL ? "AttnBiasShort = Where(attn_mask, ScalarZero, FloatNegInf)"
+                                                       : "AttnBiasShort = Identity(attn_mask)");
+    // If attn_mask has a shorter kv sequence length, we pad it to NewKVSeqLen with FloatNegInf
+    if (padding) {
+      builder.Add("MaskKVSeqLen = Shape <start = -1> (attn_mask)")
+          .Add("PaddingKVSeqLen = Sub(NewKVSeqLen, MaskKVSeqLen)")
+          .Add("Pads = Concat <axis = 0> (Zero1D, PaddingKVSeqLen)")
+          .Add("FloatNegInfCast = CastLike(FloatNegInf, AttnBiasShort)")
+          .Add("AttnBias = Pad(AttnBiasShort, Pads, FloatNegInfCast, NegOne1D)");
+    } else {
+      builder.Add("AttnBias = Identity(AttnBiasShort)");
+    }
+  } else {
+    builder.Add("AttnBias = ConstantOfShape(AttnBiasShape)");
+  }
+
+  // If is_causal set to true, the attention masking is a lower triangular matrix when the mask
+  // is a square matrix. The attention masking has the form of the upper left causal bias due to
+  // the alignment when the mask is a non-square matrix.
+  // An error is thrown if both attn_mask and is_causal are set.
+  auto* is_causal_attr = ctx.getAttribute("is_causal");
+  int64_t is_causal = (is_causal_attr != nullptr) ? is_causal_attr->i() : 0;
+  if (is_causal == 1) {
+    builder.Const1D("Zero", static_cast<int64_t>(0))
+        .Const1D("One", static_cast<int64_t>(1))
+        .Add("ZeroNoDim = Squeeze(Zero, Zero)")
+        .Add("OneNoDim = Squeeze(One, Zero)")
+        .Add("SequenceLength = Gather(AttnBiasShape, ZeroNoDim)")
+        .Add("TotalSequenceLength = Gather(AttnBiasShape, OneNoDim)")
+        .Add("RangeRow = Range(ZeroNoDim, SequenceLength, OneNoDim)")
+        .Add("RangeRow2D = Unsqueeze(RangeRow, One)")
+        .Add("RangeCol = Range(ZeroNoDim, TotalSequenceLength, OneNoDim)")
+        .Add("RangeCol2D = Unsqueeze(RangeCol, Zero)")
+        .Add("RangeRow2DPast = Add(RangeRow2D, PastKVSeqLen)")
+        .Add("BoolMaskTri = Less(RangeRow2DPast, RangeCol2D)")
+        .Add("MaskTri = Where(BoolMaskTri, FloatNegInf, ScalarZero)")
+        .Add("AttnBiasCausalOrNot = Add(AttnBias, MaskTri)");
+  } else {
+    builder.Add("AttnBiasCausalOrNot = Identity(AttnBias)");
+  }
+  return true;
+}
+
+} // namespace utils
+} // namespace nn
+} // namespace defs
+} // namespace ONNX_NAMESPACE

onnx/defs/nn/utils.h

@@ -0,0 +1,25 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "onnx/common/assertions.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace nn {
+namespace utils {
+
+/** Implements shape and type propagation for Attention (23-). */
+void AttentionPropagateElemTypeFromInputToOutput(InferenceContext& ctx);
+
+/** Implements CausalMask for Attention. */
+bool AttentionAppendFunctionCausalMask(const FunctionBodyBuildContext& ctx, FunctionBuilder& builder, bool padding);
+
+} // namespace utils
+} // namespace nn
+} // namespace defs
+} // namespace ONNX_NAMESPACE

onnx/defs/operator_sets.h

@@ -1341,6 +1341,61 @@ class OpSet_Onnx_ver23 {
   }
 };
 
+// Forward declarations for ai.onnx version 24
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Attention);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Swish);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, SplitToSequence);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TopK);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Unsqueeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TensorScatter);
+
+// Iterate over schema from ai.onnx version 24
+class OpSet_Onnx_ver24 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Attention)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Swish)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, SplitToSequence)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TopK)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Unsqueeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TensorScatter)>());
+  }
+};
+
 inline void RegisterOnnxOperatorSetSchema() {
   RegisterOpSetSchema<OpSet_Onnx_ver1>();
   RegisterOpSetSchema<OpSet_Onnx_ver2>();
@@ -1365,6 +1420,7 @@ inline void RegisterOnnxOperatorSetSchema() {
   RegisterOpSetSchema<OpSet_Onnx_ver21>();
   RegisterOpSetSchema<OpSet_Onnx_ver22>();
   RegisterOpSetSchema<OpSet_Onnx_ver23>();
+  RegisterOpSetSchema<OpSet_Onnx_ver24>();
   // 0 means all versions of ONNX schema have been loaded
   OpSchemaRegistry::Instance()->SetLoadedSchemaVersion(0);
 }
@@ -1374,6 +1430,7 @@ inline void RegisterOnnxOperatorSetSchema(int target_version, bool fail_duplicat
   // These calls for schema registration here are required to be in descending order for this to work correctly
   //
   // Version-specific registration sees duplicate schema version request as error if fail_duplicate_schema
+  RegisterOpSetSchema<OpSet_Onnx_ver24>(target_version, fail_duplicate_schema);
   RegisterOpSetSchema<OpSet_Onnx_ver23>(target_version, fail_duplicate_schema);
   RegisterOpSetSchema<OpSet_Onnx_ver22>(target_version, fail_duplicate_schema);
   RegisterOpSetSchema<OpSet_Onnx_ver21>(target_version, fail_duplicate_schema);

onnx/defs/parser.cc

@@ -481,6 +481,7 @@ Status OnnxParser::Parse(TensorProto& tensorProto, const TypeProto& tensorTypePr
           case TensorProto::DataType::TensorProto_DataType_FLOAT8E4M3FNUZ:
           case TensorProto::DataType::TensorProto_DataType_FLOAT8E5M2:
           case TensorProto::DataType::TensorProto_DataType_FLOAT8E5M2FNUZ:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT8E8M0:
           case TensorProto::DataType::TensorProto_DataType_BOOL:
           case TensorProto::DataType::TensorProto_DataType_FLOAT4E2M1:
             PARSE_TOKEN(intval);

onnx/defs/parser.h

@@ -92,6 +92,7 @@ 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;
@@ -124,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,
@@ -264,7 +265,7 @@ class ParserBase {
     return (next_ >= end_);
   }
 
-  enum class LiteralType { UNDEFINED, INT_LITERAL, FLOAT_LITERAL, STRING_LITERAL };
+  enum class LiteralType : std::uint8_t { UNDEFINED, INT_LITERAL, FLOAT_LITERAL, STRING_LITERAL };
 
   struct Literal {
     LiteralType type{LiteralType::UNDEFINED};
@@ -275,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;
@@ -285,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;
@@ -295,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:
@@ -309,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:
@@ -324,7 +325,7 @@ class ParserBase {
   // 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;
@@ -398,7 +399,7 @@ class ParserBase {
 
   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();
   }
@@ -416,29 +417,29 @@ class OnnxParser : public ParserBase {
  public:
   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/quantization/defs.cc

@@ -7,7 +7,7 @@
 
 namespace ONNX_NAMESPACE {
 
-static const char* QuantizeLinear_ver23_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)`.
@@ -39,7 +39,7 @@ In all cases, `y_zero_point` must have the same shape as `y_scale`.
 
 ONNX_OPERATOR_SET_SCHEMA(
     QuantizeLinear,
-    23,
+    24,
     OpSchema()
         .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
         .Input(
@@ -52,7 +52,7 @@ ONNX_OPERATOR_SET_SCHEMA(
         .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.",
             "T3",
             OpSchema::Optional)
@@ -100,7 +100,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             "The type of the input 'x'.")
         .TypeConstraint(
             "T2",
-            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(int32)"},
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)", "tensor(int32)", "tensor(float8e8m0)"},
             "The type of the input 'y_scale'.")
         .TypeConstraint(
             "T3",
@@ -116,7 +116,7 @@ ONNX_OPERATOR_SET_SCHEMA(
              "tensor(int4)",
              "tensor(float4e2m1)"},
             "The type of the input `y_zero_point` and the output `y`.")
-        .SetDoc(QuantizeLinear_ver23_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 =
@@ -145,7 +145,7 @@ ONNX_OPERATOR_SET_SCHEMA(
           updateOutputShape(ctx, 0, input_shape);
         }));
 
-static const char* DequantizeLinear_ver23_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,
@@ -162,7 +162,7 @@ is the same as `x_scale`. The output type also determines the precision of the m
 
 ONNX_OPERATOR_SET_SCHEMA(
     DequantizeLinear,
-    23,
+    24,
     OpSchema()
         .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
         .Input(
@@ -222,10 +222,10 @@ ONNX_OPERATOR_SET_SCHEMA(
             "The type of the inputs 'x_zero_point' and 'x'.")
         .TypeConstraint(
             "T2",
-            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"},
+            {"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_ver23_doc)
+        .SetDoc(DequantizeLinear_ver24_doc)
         .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
           auto const output_dtype =
               static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));