pick onnx release candidate (#7177)

* pick onnx release candidate

* fix typo

* filter batchnorm tests

* add implementation for reshape 14

* add identity op kernel for opset 14

* fix typo

* update onnx commit

* update commit to latest master

* add hashes for new kernel registrations and update 1

* TEST commit

* update onnx back to right commit

* Update onnx to latest in rel-1.9.0

* temp fix

* remove nonzeroshapesetter transformer

* pick rel branch latest commit

* fix build failures

* fix build failures

* fix build failures

* update the commit to latest in release branch

* add test filters for not impemented op14 ops in c# tests

* plus review comments

Author: askhade

cgmanifests/submodules/cgmanifest.json

@@ -262,7 +262,7 @@
       "component": {
         "type": "git",
         "git": {
-          "commitHash": "fe2433d3dd677ed5c582e194a49a632e707d0543",
+          "commitHash": "971632833036c576cf95499291f689f8bb3519e1",
           "repositoryUrl": "https://github.com/onnx/onnx"
         },
         "comments": "git submodule at cmake/external/onnx"

cmake/external/onnx

@@ -790,7 +790,27 @@ private static Dictionary<string, string> GetSkippedModels(DirectoryInfo modelsD
                 { "test_training_dropout_default_mask", "node test error"},
                 { "test_min_int8", "node test error"},
                 { "test_cast_FLOAT_to_STRING", "node test error"},
-                { "test_identity_sequence", "data type not supported"}
+                { "test_identity_sequence", "data type not supported"},
+                { "test_gru_batchwise", "opset14 version not implemented yet"},
+                { "test_gru_defaults", "opset14 version not implemented yet"}, 
+                { "test_gru_seq_length", "opset14 version not implemented yet"}, 
+                { "test_gru_with_initial_bias", "opset14 version not implemented yet"},
+                { "test_lstm_batchwise", "opset14 version not implemented yet"},
+                { "test_lstm_defaults", "opset14 version not implemented yet"},
+                { "test_lstm_with_initial_bias", "opset14 version not implemented yet"},
+                { "test_lstm_with_peepholes", "opset14 version not implemented yet"},
+                { "test_rnn_seq_length", "opset14 version not implemented yet"},
+                { "test_simple_rnn_batchwise", "opset14 version not implemented yet"},
+                { "test_simple_rnn_defaults", "opset14 version not implemented yet"},
+                { "test_simple_rnn_with_initial_bias", "opset14 version not implemented yet"},
+                { "test_sub_uint8", "data type not supported"},
+                { "test_mul_uint8", "data type not supported"},
+                { "test_add_uint8", "data type not supported"},
+                { "test_div_uint8", "data type not supported"},
+                { "test_batchnorm_epsilon", "opset14 version not implemented yet"},
+                { "test_batchnorm_epsilon_training_mode", "opset14 version not implemented yet"},
+                { "test_batchnorm_example", "opset14 version not implemented yet"},
+                { "test_batchnorm_example_training_mode", "opset14 version not implemented yet"},
             };
 
             // The following models fails on nocontribops win CI

csharp/test/Microsoft.ML.OnnxRuntime.Tests/InferenceTest.cs

@@ -162,37 +162,53 @@ REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 7, 12, float, Add);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 7, 12, double, Add);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 7, 12, int32_t, Add);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 7, 12, int64_t, Add);
-REG_ELEMENTWISE_TYPED_KERNEL(Add, 13, float, Add);
-REG_ELEMENTWISE_TYPED_KERNEL(Add, 13, double, Add);
-REG_ELEMENTWISE_TYPED_KERNEL(Add, 13, int32_t, Add);
-REG_ELEMENTWISE_TYPED_KERNEL(Add, 13, int64_t, Add);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 13, 13, float, Add);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 13, 13, double, Add);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 13, 13, int32_t, Add);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Add, 13, 13, int64_t, Add);
+REG_ELEMENTWISE_TYPED_KERNEL(Add, 14, float, Add);
+REG_ELEMENTWISE_TYPED_KERNEL(Add, 14, double, Add);
+REG_ELEMENTWISE_TYPED_KERNEL(Add, 14, int32_t, Add);
+REG_ELEMENTWISE_TYPED_KERNEL(Add, 14, int64_t, Add);
 
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 7, 12, float, Sub);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 7, 12, double, Sub);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 7, 12, int32_t, Sub);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 7, 12, int64_t, Sub);
-REG_ELEMENTWISE_TYPED_KERNEL(Sub, 13, float, Sub);
-REG_ELEMENTWISE_TYPED_KERNEL(Sub, 13, double, Sub);
-REG_ELEMENTWISE_TYPED_KERNEL(Sub, 13, int32_t, Sub);
-REG_ELEMENTWISE_TYPED_KERNEL(Sub, 13, int64_t, Sub);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 13, 13, float, Sub);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 13, 13, double, Sub);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 13, 13, int32_t, Sub);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Sub, 13, 13, int64_t, Sub);
+REG_ELEMENTWISE_TYPED_KERNEL(Sub, 14, float, Sub);
+REG_ELEMENTWISE_TYPED_KERNEL(Sub, 14, double, Sub);
+REG_ELEMENTWISE_TYPED_KERNEL(Sub, 14, int32_t, Sub);
+REG_ELEMENTWISE_TYPED_KERNEL(Sub, 14, int64_t, Sub);
 
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 7, 12, float, Mul);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 7, 12, double, Mul);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 7, 12, int32_t, Mul);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 7, 12, int64_t, Mul);
-REG_ELEMENTWISE_TYPED_KERNEL(Mul, 13, float, Mul);
-REG_ELEMENTWISE_TYPED_KERNEL(Mul, 13, double, Mul);
-REG_ELEMENTWISE_TYPED_KERNEL(Mul, 13, int32_t, Mul);
-REG_ELEMENTWISE_TYPED_KERNEL(Mul, 13, int64_t, Mul);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 13, 13, float, Mul);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 13, 13, double, Mul);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 13, 13, int32_t, Mul);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Mul, 13, 13, int64_t, Mul);
+REG_ELEMENTWISE_TYPED_KERNEL(Mul, 14, float, Mul);
+REG_ELEMENTWISE_TYPED_KERNEL(Mul, 14, double, Mul);
+REG_ELEMENTWISE_TYPED_KERNEL(Mul, 14, int32_t, Mul);
+REG_ELEMENTWISE_TYPED_KERNEL(Mul, 14, int64_t, Mul);
 
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 7, 12, float, Div);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 7, 12, double, Div);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 7, 12, int32_t, Div);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 7, 12, int64_t, Div);
-REG_ELEMENTWISE_TYPED_KERNEL(Div, 13, float, Div);
-REG_ELEMENTWISE_TYPED_KERNEL(Div, 13, double, Div);
-REG_ELEMENTWISE_TYPED_KERNEL(Div, 13, int32_t, Div);
-REG_ELEMENTWISE_TYPED_KERNEL(Div, 13, int64_t, Div);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 13, 13, float, Div);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 13, 13, double, Div);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 13, 13, int32_t, Div);
+REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Div, 13, 13, int64_t, Div);
+REG_ELEMENTWISE_TYPED_KERNEL(Div, 14, float, Div);
+REG_ELEMENTWISE_TYPED_KERNEL(Div, 14, double, Div);
+REG_ELEMENTWISE_TYPED_KERNEL(Div, 14, int32_t, Div);
+REG_ELEMENTWISE_TYPED_KERNEL(Div, 14, int64_t, Div);
 
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Abs, 6, 12, float, Abs);
 REG_ELEMENTWISE_VERSIONED_TYPED_KERNEL(Abs, 6, 12, double, Abs);

onnxruntime/core/providers/cpu/cpu_execution_provider.cc

@@ -31,9 +31,16 @@ ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
     KernelDefBuilder().TypeConstraint("T", DataTypeImpl::AllTensorTypes()).Alias(0, 0),
     IdentityOp<false>);
 
-ONNX_CPU_OPERATOR_KERNEL(
+ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
     Identity,
     13,
+    13,
+    KernelDefBuilder().TypeConstraint("T", DataTypeImpl::AllTensorTypes()).Alias(0, 0),
+    IdentityOp<false>);
+
+ONNX_CPU_OPERATOR_KERNEL(
+    Identity,
+    14,
     KernelDefBuilder().TypeConstraint("V", DataTypeImpl::AllTensorTypes()).Alias(0, 0),
     IdentityOp<false>);
 

onnxruntime/core/providers/cpu/math/element_wise_ops.cc

@@ -4,6 +4,15 @@
 #include "core/providers/cpu/tensor/reshape.h"
 namespace onnxruntime {
 
+ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
+    Reshape,
+    1,
+    4,
+    KernelDefBuilder()
+        .Alias(0, 0)
+        .TypeConstraint("T", DataTypeImpl::AllTensorTypes()),
+    Reshape_1);
+
 ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
     Reshape,
     5,
@@ -14,22 +23,23 @@ ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
         .TypeConstraint("shape", DataTypeImpl::GetTensorType<int64_t>()),
     Reshape);
 
-ONNX_CPU_OPERATOR_KERNEL(
+ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
     Reshape,
     13,
+    13,
     KernelDefBuilder()
         .Alias(0, 0)
         .TypeConstraint("T", DataTypeImpl::AllTensorTypes())
         .TypeConstraint("shape", DataTypeImpl::GetTensorType<int64_t>()),
     Reshape);
 
-ONNX_CPU_OPERATOR_VERSIONED_KERNEL(
+ONNX_CPU_OPERATOR_KERNEL(
     Reshape,
-    1,
-    4,
+    14,
     KernelDefBuilder()
         .Alias(0, 0)
-        .TypeConstraint("T", DataTypeImpl::AllTensorTypes()),
-    Reshape_1);
+        .TypeConstraint("T", DataTypeImpl::AllTensorTypes())
+        .TypeConstraint("shape", DataTypeImpl::GetTensorType<int64_t>()),
+    Reshape);
 
 }  // namespace onnxruntime

onnxruntime/core/providers/cpu/tensor/identity_op.cc

@@ -14,7 +14,8 @@ namespace onnxruntime {
 
 class Reshape final : public OpKernel {
  public:
-  explicit Reshape(const OpKernelInfo& info) : OpKernel(info) {
+  explicit Reshape(const OpKernelInfo& info) : OpKernel(info),
+                                               allow_zero_(info.GetAttrOrDefault<int64_t>("allowzero", 0) == 1) {
   }
 
   Status Compute(OpKernelContext* context) const override {
@@ -29,14 +30,17 @@ class Reshape final : public OpKernel {
     const auto* X = context->Input<Tensor>(0);
     const TensorShape& X_shape = X->Shape();
 
-    ReshapeHelper helper(X_shape, shape);
+    ReshapeHelper helper(X_shape, shape, allow_zero_);
 
     Tensor* Y = context->Output(0, TensorShape(shape));
 
     CopyCpuTensor(X, Y);
 
     return Status::OK();
   }
+
+ private:
+  const bool allow_zero_;
 };
 
 class Reshape_1 final : public OpKernel {

onnxruntime/core/providers/cpu/tensor/reshape.cc

@@ -12,17 +12,20 @@ namespace onnxruntime {
 // Verify and convert unknown dim during reshape
 class ReshapeHelper {
  public:
-  ReshapeHelper(const TensorShape& input_shape, std::vector<int64_t>& requested_shape) {
+  ReshapeHelper(const TensorShape& input_shape, std::vector<int64_t>& requested_shape, bool allow_zero = false) {
     auto nDims = requested_shape.size();
     ptrdiff_t unknown_dim = -1;
     int64_t size = 1;
     for (size_t i = 0; i < nDims; ++i) {
       ORT_ENFORCE(requested_shape[i] >= -1, "A dimension cannot be less than -1, got ", requested_shape[i]);
       if (requested_shape[i] == -1) {
+        ORT_ENFORCE(!allow_zero,
+                    "The input tensor cannot be reshaped to the requested shape. Input shape:",
+                    input_shape, ", requested shape:", TensorShape(requested_shape));
         ORT_ENFORCE(unknown_dim == -1, "At most one dimension can be -1.");
         unknown_dim = i;
       } else {
-        if (requested_shape[i] == 0) {
+        if (!allow_zero && requested_shape[i] == 0) {
           ORT_ENFORCE(i < input_shape.NumDimensions(),
                       "The dimension with value zero exceeds"
                       " the dimension size of the input tensor.");

onnxruntime/core/providers/cpu/tensor/reshape.h

@@ -14,16 +14,16 @@ limitations under the License.
 ==============================================================================*/
 /* Modifications Copyright (c) Microsoft. */
 
+#include <thrust/device_vector.h>
+#include <thrust/execution_policy.h>
+
 #include "non_max_suppression_impl.h"
 #include "core/providers/cpu/object_detection/non_max_suppression_helper.h"
 #include "core/providers/cuda/cu_inc/common.cuh"
 #include "core/providers/cuda/cuda_common.h"
 
 #include "core/framework/tensor.h"
 
-#include <thrust/device_vector.h>
-#include <thrust/execution_policy.h>
-
 #include <cub/cub.cuh>
 //TODO:fix the warnings
 #ifdef _MSC_VER