Merge branch 'develop' into uif2-initial

.github/workflows/ci.yaml

@@ -281,6 +281,7 @@ jobs:
           -DBUILD_DEV=On \
           -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/local/bin/ccache \
           -DCMAKE_C_COMPILER_LAUNCHER=/usr/local/bin/ccache \
+          -DCMAKE_CXX_FLAGS="-Werror" \
           -DGPU_TARGETS=gfx908 \
           ..
         make -j$(nproc) tests driver

CMakeLists.txt

@@ -80,7 +80,7 @@ include(ROCMSetupVersion)
 
 option(BUILD_DEV "Build for development purpose only" OFF)
 
-rocm_setup_version(VERSION 2.7.0)
+rocm_setup_version(VERSION 2.8.0)
 set(MIGRAPHX_SO_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
 
 option( BUILD_SHARED_LIBS "Build as a shared library" ON )
@@ -297,7 +297,6 @@ file(MAKE_DIRECTORY ${DEST_DIR}/lib/onnx_migraphx)
 foreach(py_file ${backend_files})
     configure_file(${py_file} ${DEST_DIR}/lib/onnx_migraphx/. COPYONLY)
 endforeach(py_file)
-configure_file(${CMAKE_SOURCE_DIR}/test/py/onnx_backend_test.py ${DEST_DIR}/onnx_backend_test.py COPYONLY)
 
 rocm_create_package(
     NAME MIGraphX

src/include/migraphx/op/convert.hpp

@@ -68,13 +68,6 @@ struct convert : unary<convert>
             auto y = x;
             shape::visit(type, [&](auto as) {
                 // clamping value between target_type's max and min doesn't work for NaNs,
-
-                // WIN32: The standard library from MSVC does implement std::isfinite()
-                // (used by std::isnan() internally) for floating-point types only
-                // - there are no additional overloads for integer types, which should be
-                // treated as doubles according to the C++ specification.
-                // Reference: https://en.cppreference.com/w/cpp/numeric/math/isfinite
-
                 if(std::isnan(static_cast<double>(x)))
                 {
                     y = as.nan();

src/onnx/parse_castlike.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <migraphx/onnx/op_parser.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/instruction.hpp>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace onnx {
+
+struct parse_castlike : op_parser<parse_castlike>
+{
+    std::vector<op_desc> operators() const { return {{"CastLike"}}; }
+
+    instruction_ref parse(const op_desc& /*opd*/,
+                          const onnx_parser& /*parser*/,
+                          const onnx_parser::node_info& info,
+                          const std::vector<instruction_ref>& args) const
+    {
+        if(not(args.size() == 2))
+        {
+            MIGRAPHX_THROW("PARSE_CASTLIKE: CastLike must have exactly 2 inputs!");
+        }
+        shape::type_t target_type = args[1]->get_shape().type();
+        return info.add_instruction(make_op("convert", {{"target_type", target_type}}), args[0]);
+    }
+};
+
+} // namespace onnx
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

src/onnx/parse_constant_of_shape.cpp

@@ -49,6 +49,8 @@ struct parse_constant_of_shape : op_parser<parse_constant_of_shape>
             {
                 MIGRAPHX_THROW("ConstantOfShape: attribute value can contain only 1 elements!");
             }
+            // convert to a scalar literal
+            l_val = literal(shape{l_val.get_shape().type(), {1}, {0}}, l_val.data());
         }
         else
         {
@@ -64,30 +66,37 @@ struct parse_constant_of_shape : op_parser<parse_constant_of_shape>
             migraphx::shape s;
             // input is empty, output is a scalar
             auto type = l_val.get_shape().type();
-            // empty input tensor, output is a scalar
-            if(args[0]->get_shape().elements() == 0)
+            migraphx::argument input = args[0]->eval();
+            if(not input.empty())
             {
-                s = migraphx::shape{type, {1}, {0}};
+                // empty input tensor, output is a scalar
+                if(args[0]->get_shape().elements() == 0)
+                {
+                    s = migraphx::shape{type, {1}, {0}};
+                }
+                else
+                {
+                    std::vector<std::size_t> dims;
+                    input.visit([&](auto ia) { dims.assign(ia.begin(), ia.end()); });
+                    s = migraphx::shape{type, dims};
+                }
+                literal l_out{};
+                l_val.visit([&](auto val) {
+                    using val_type = std::remove_cv_t<typename decltype(val)::value_type>;
+                    // l_val contains only one element
+                    std::vector<val_type> out_vec(s.elements(), val.front());
+                    l_out = literal(s, out_vec);
+                });
+                return info.add_literal(l_out);
             }
+            // has variable input (dynamic shape buffer)
             else
             {
-                migraphx::argument in = args[0]->eval();
-                check_arg_empty(in, "ConstantOfShape: dynamic shape is not supported");
-
-                std::vector<std::size_t> dims;
-                in.visit([&](auto input) { dims.assign(input.begin(), input.end()); });
-                s = migraphx::shape{type, dims};
+                auto dv_lit = info.add_literal(l_val);
+                auto alloc_ins =
+                    info.add_instruction(make_op("allocate", {{"buf_type", type}}), args[0]);
+                return info.add_instruction(make_op("fill"), dv_lit, alloc_ins);
             }
-
-            literal l_out{};
-            l_val.visit([&](auto val) {
-                using val_type = std::remove_cv_t<typename decltype(val)::value_type>;
-                // l_val contains only one element
-                std::vector<val_type> out_vec(s.elements(), val.front());
-                l_out = literal(s, out_vec);
-            });
-
-            return info.add_literal(l_out);
         }
     }
 };

src/onnx/parse_resize.cpp

@@ -320,7 +320,8 @@ struct parse_resize : op_parser<parse_resize>
 
             // get the number of dimensions
             std::size_t n_dim = out_lens.size();
-            auto vvv_ind = std::vector(n_dim, std::vector(2, std::vector<size_t>(out_elements)));
+            std::vector<std::vector<std::size_t>> vv_ind(2, std::vector<std::size_t>(out_elements));
+            std::vector<std::vector<std::vector<std::size_t>>> vvv_ind(n_dim, vv_ind);
             std::vector<std::vector<float>> delta(n_dim, std::vector<float>(out_elements));
 
             shape_for_each(out_s, [&](const auto& out_idx_v, size_t out_idx) {

src/targets/gpu/device/include/migraphx/gpu/device/launch.hpp

@@ -81,6 +81,14 @@ inline auto launch(hipStream_t stream, index_int global, index_int local)
         using f_type = decltype(f);
         dim3 nblocks(global / local);
         dim3 nthreads(local);
+        /*
+        hipGetLastError() returns error for the first failed HIP call that happened previously.
+        MIGraphX calls into various backend libraries and failed HIP calls can also happen there.
+        Calling hipGetLastError() would reset error code to hipSuccess, so that inside MIGraphX
+        failed call to hipLaunchKernelGGL() can be captured.
+        */
+        hipError_t flush_call = hipGetLastError();
+        (void)(flush_call);
         // cppcheck-suppress UseDeviceLaunch
         hipLaunchKernelGGL((launcher<f_type>), nblocks, nthreads, 0, stream, f);
         hipError_t kernel_launch_status = hipGetLastError();

test/onnx/castlike_error_test.onnx

+	castlike_error_test:M
+
+
0out"CastLikecastlike_error_testZ
+
0
+
+
+
+
+b
+out
+
+

+
+B
\ No newline at end of file

test/onnx/castlike_test.onnx

+	
castlike_test:[
+
+
0
+
1out"CastLike
castlike_testZ
+
0
+
+
+
+
+Z
+
1
+
+

+
+b
+out
+
+

+
+B
\ No newline at end of file

test/onnx/const_of_shape_default_test.onnx

+const_of_shape_default_test:

+6shape"Constant*#
+value*:Bshape_tensor

+
+shape
y"ConstantOfShapeconst_of_shape_default_testb
+
y
+
+
+
+B
\ No newline at end of file

test/onnx/const_of_shape_dyn_int64_test.onnx

+const_of_shape_dyn_int64_test:

+=
+output_dims
y"ConstantOfShape*
+value*
:

+Bvalue
const_of_shape_dyn_int64_testZ
+output_dims
+
+
+b
+
y
+
+
+
+B
\ No newline at end of file

test/onnx/const_of_shape_int64_test.onnx

-constant-of-shape:

+const_of_shape_int64_test:

 6shape"Constant*#
-value**Bshape_tensor 

+value*:Bshape_tensor

 7
 shape
y"ConstantOfShape*
 value*
:

-Bvalue 
constant_of_shapeb
+Bvalue
const_of_shape_int64_testb
 
y
-

+
 
 
-B
+B
\ No newline at end of file

test/onnx/const_of_shape_no_value_attr_test.onnx

-constant-of-shape:

+!const_of_shape_no_value_attr_test:

 6shape"Constant*#
-value**Bshape_tensor 

+value*:Bshape_tensor

 
-shape
y"ConstantOfShapeconstant_of_shapeb
+shape
y"ConstantOfShape!const_of_shape_no_value_attr_testb
 
y
 

 
 
-B
+B
\ No newline at end of file

test/onnx/gen_onnx.py

@@ -582,6 +582,29 @@ def cast_test():
     return ([node], [x], [y])
 
 
+@onnx_test()
+def castlike_test():
+    input = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [10])
+    target_type = helper.make_tensor_value_info('1', TensorProto.FLOAT, [10])
+    output = helper.make_tensor_value_info('out', TensorProto.FLOAT, [10])
+
+    node = onnx.helper.make_node('CastLike',
+                                 inputs=['0', '1'],
+                                 outputs=['out'])
+
+    return ([node], [input, target_type], [output])
+
+
+@onnx_test()
+def castlike_error_test():
+    input = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [10])
+    output = helper.make_tensor_value_info('out', TensorProto.FLOAT, [10])
+
+    node = onnx.helper.make_node('CastLike', inputs=['0'], outputs=['out'])
+
+    return ([node], [input], [output])
+
+
 @onnx_test()
 def ceil_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
@@ -1007,9 +1030,9 @@ def const_of_shape_empty_input_test():
                                          [10])
     empty_val = np.array([]).astype(np.int64)
     empty_ts = helper.make_tensor(name='empty_tensor',
-                                  data_type=TensorProto.INT32,
+                                  data_type=TensorProto.INT64,
                                   dims=empty_val.shape,
-                                  vals=empty_val.flatten().astype(int))
+                                  vals=empty_val.flatten().astype(np.int64))
     shape_const = helper.make_node(
         'Constant',
         inputs=[],
@@ -1035,9 +1058,9 @@ def const_of_shape_float_test():
 
     shape_val = np.array([2, 3, 4]).astype(np.int64)
     shape_ts = helper.make_tensor(name='shape_tensor',
-                                  data_type=TensorProto.INT32,
+                                  data_type=TensorProto.INT64,
                                   dims=shape_val.shape,
-                                  vals=shape_val.flatten().astype(int))
+                                  vals=shape_val.flatten().astype(np.int64))
 
     shape_const = helper.make_node(
         'Constant',
@@ -1055,22 +1078,44 @@ def const_of_shape_float_test():
     return ([shape_const, node], [], [y])
 
 
+@onnx_test()
+def const_of_shape_default_test():
+    shape_val = np.array([2, 3, 4]).astype(np.int64)
+    shape_ts = helper.make_tensor(name='shape_tensor',
+                                  data_type=TensorProto.INT64,
+                                  dims=shape_val.shape,
+                                  vals=shape_val.flatten().astype(np.int64))
+    shape_const = helper.make_node(
+        'Constant',
+        inputs=[],
+        outputs=['shape'],
+        value=shape_ts,
+    )
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [2, 3, 4])
+
+    node = onnx.helper.make_node('ConstantOfShape',
+                                 inputs=['shape'],
+                                 outputs=['y'])
+
+    return ([shape_const, node], [], [y])
+
+
 @onnx_test()
 def const_of_shape_int64_test():
     tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1],
                                          [10])
     shape_val = np.array([2, 3, 4]).astype(np.int64)
     shape_ts = helper.make_tensor(name='shape_tensor',
-                                  data_type=TensorProto.INT32,
+                                  data_type=TensorProto.INT64,
                                   dims=shape_val.shape,
-                                  vals=shape_val.flatten().astype(int))
+                                  vals=shape_val.flatten().astype(np.int64))
     shape_const = helper.make_node(
         'Constant',
         inputs=[],
         outputs=['shape'],
         value=shape_ts,
     )
-    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [2, 3, 4])
 
     node = onnx.helper.make_node('ConstantOfShape',
                                  inputs=['shape'],
@@ -1084,9 +1129,9 @@ def const_of_shape_int64_test():
 def const_of_shape_no_value_attr_test():
     shape_val = np.array([2, 3, 4]).astype(np.int64)
     shape_ts = helper.make_tensor(name='shape_tensor',
-                                  data_type=TensorProto.INT32,
+                                  data_type=TensorProto.INT64,
                                   dims=shape_val.shape,
-                                  vals=shape_val.flatten().astype(int))
+                                  vals=shape_val.flatten().astype(np.int64))
     shape_const = helper.make_node(
         'Constant',
         inputs=[],
@@ -1104,6 +1149,40 @@ def const_of_shape_no_value_attr_test():
     return ([shape_const, node], [], [y])
 
 
+@onnx_test()
+def const_of_shape_dyn_float_test():
+    tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.FLOAT, [1],
+                                         [10])
+
+    output_dims = helper.make_tensor_value_info('output_dims',
+                                                TensorProto.INT64, [3])
+    y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3, 4])
+
+    node = onnx.helper.make_node('ConstantOfShape',
+                                 inputs=['output_dims'],
+                                 outputs=['y'],
+                                 value=tensor_val)
+
+    return ([node], [output_dims], [y])
+
+
+@onnx_test()
+def const_of_shape_dyn_int64_test():
+    tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1],
+                                         [10])
+
+    output_dims = helper.make_tensor_value_info('output_dims',
+                                                TensorProto.INT64, [3])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [2, 3, 4])
+
+    node = onnx.helper.make_node('ConstantOfShape',
+                                 inputs=['output_dims'],
+                                 outputs=['y'],
+                                 value=tensor_val)
+
+    return ([node], [output_dims], [y])
+
+
 @onnx_test()
 def conv_1d_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5])

test/onnx/onnx_test.cpp

@@ -687,6 +687,26 @@ TEST_CASE(cast_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(castlike_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto l   = mm->add_parameter("0", migraphx::shape{migraphx::shape::half_type, {10}});
+    mm->add_parameter("1", migraphx::shape{migraphx::shape::float_type, {10}});
+    mm->add_instruction(
+        migraphx::make_op("convert",
+                          {{"target_type", migraphx::to_value(migraphx::shape::float_type)}}),
+        l);
+
+    auto prog = optimize_onnx("castlike_test.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(castlike_error_test)
+{
+    EXPECT(test::throws([&] { migraphx::parse_onnx("castlike_error_test.onnx"); }));
+}
+
 TEST_CASE(ceil_test)
 {
     migraphx::program p;
@@ -1040,11 +1060,25 @@ TEST_CASE(constant_one_val_int64_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(const_of_shape_default_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    migraphx::shape output_dims_shape(migraphx::shape::int64_type, {3});
+    mm->add_literal(migraphx::literal(output_dims_shape, {2, 3, 4}));
+    migraphx::shape output_shape{migraphx::shape::float_type, {2, 3, 4}};
+    std::vector<float> vec(output_shape.elements(), 0.0);
+    mm->add_literal(migraphx::literal(output_shape, vec));
+
+    auto prog = optimize_onnx("const_of_shape_default_test.onnx");
+    EXPECT(p == prog);
+}
+
 TEST_CASE(const_of_shape_empty_input_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
-    mm->add_literal(migraphx::literal(migraphx::shape::int32_type));
+    mm->add_literal(migraphx::literal(migraphx::shape::int64_type));
     migraphx::shape s(migraphx::shape::int64_type, {1}, {0});
     std::vector<int64_t> vec(s.elements(), 10);
     mm->add_literal(migraphx::literal(s, vec));
@@ -1057,7 +1091,7 @@ TEST_CASE(const_of_shape_float_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
-    migraphx::shape ss(migraphx::shape::int32_type, {3});
+    migraphx::shape ss(migraphx::shape::int64_type, {3});
     mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
     migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
     std::vector<float> vec(s.elements(), 10.0f);
@@ -1071,8 +1105,10 @@ TEST_CASE(const_of_shape_int64_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
-    migraphx::shape ss(migraphx::shape::int32_type, {3});
+    // output_dims
+    migraphx::shape ss(migraphx::shape::int64_type, {3});
     mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
+    // constant shape literal
     migraphx::shape s(migraphx::shape::int64_type, {2, 3, 4});
     std::vector<int64_t> vec(s.elements(), 10);
     mm->add_literal(migraphx::literal(s, vec));
@@ -1085,7 +1121,7 @@ TEST_CASE(const_of_shape_no_value_attr_test)
 {
     migraphx::program p;
     auto* mm = p.get_main_module();
-    migraphx::shape ss(migraphx::shape::int32_type, {3});
+    migraphx::shape ss(migraphx::shape::int64_type, {3});
     mm->add_literal(migraphx::literal(ss, {2, 3, 4}));
     migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
     std::vector<float> vec(s.elements(), 0.0f);
@@ -1095,6 +1131,42 @@ TEST_CASE(const_of_shape_no_value_attr_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(const_of_shape_dyn_float_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto od_param =
+        mm->add_parameter("output_dims", migraphx::shape{migraphx::shape::int64_type, {3}});
+    auto alloc_ins = mm->add_instruction(
+        migraphx::make_op("allocate", {{"buf_type", migraphx::shape::float_type}}), od_param);
+    migraphx::shape dv_shape(migraphx::shape::float_type, {1}, {0});
+    auto dv_lit   = mm->add_literal(migraphx::literal(dv_shape, {10}));
+    auto fill_ins = mm->add_instruction(migraphx::make_op("fill"), dv_lit, alloc_ins);
+    mm->add_return({fill_ins});
+
+    migraphx::onnx_options options;
+    auto prog = parse_onnx("const_of_shape_dyn_float_test.onnx", options);
+    EXPECT(p == prog);
+}
+
+TEST_CASE(const_of_shape_dyn_int64_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto od_param =
+        mm->add_parameter("output_dims", migraphx::shape{migraphx::shape::int64_type, {3}});
+    auto alloc_ins = mm->add_instruction(
+        migraphx::make_op("allocate", {{"buf_type", migraphx::shape::int64_type}}), od_param);
+    migraphx::shape dv_shape(migraphx::shape::int64_type, {1}, {0});
+    auto dv_lit   = mm->add_literal(migraphx::literal(dv_shape, {10}));
+    auto fill_ins = mm->add_instruction(migraphx::make_op("fill"), dv_lit, alloc_ins);
+    mm->add_return({fill_ins});
+
+    migraphx::onnx_options options;
+    auto prog = parse_onnx("const_of_shape_dyn_int64_test.onnx", options);
+    EXPECT(p == prog);
+}
+
 TEST_CASE(conv_autopad_fail_test)
 {
     EXPECT(test::throws([&] { optimize_onnx("conv_autopad_fail_test.onnx"); }));

test/py/onnx_backend_test.py

@@ -64,44 +64,587 @@ class MIGraphXBackendTest(onnx.backend.test.BackendTest):
 
 
 def disabled_tests_onnx_1_7_0(backend_test):
+    # fails
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_argmax_keepdims_example_select_last_index_cpu')
+    backend_test.exclude(
+        r'test_argmax_negative_axis_keepdims_example_select_last_index_cpu')
+    backend_test.exclude(
+        r'test_argmax_no_keepdims_example_select_last_index_cpu')
+    backend_test.exclude(r'test_argmin_keepdims_example_select_last_index_cpu')
+    backend_test.exclude(
+        r'test_argmin_negative_axis_keepdims_example_select_last_index_cpu')
+    backend_test.exclude(
+        r'test_argmin_no_keepdims_example_select_last_index_cpu')
     backend_test.exclude(r'test_logsoftmax_axis_0_cpu')
     backend_test.exclude(r'test_logsoftmax_axis_1_cpu')
     backend_test.exclude(r'test_logsoftmax_default_axis_cpu')
+    backend_test.exclude(r'test_maxpool_2d_dilations_cpu')
+    backend_test.exclude(r'test_maxpool_with_argmax_2d_precomputed_pads_cpu')
+    backend_test.exclude(
+        r'test_maxpool_with_argmax_2d_precomputed_strides_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_center_point_box_format_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_flipped_coordinates_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_identical_boxes_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_limit_output_size_cpu')
+    backend_test.exclude(
+        r'test_nonmaxsuppression_suppress_by_IOU_and_scores_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_suppress_by_IOU_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_two_batches_cpu')
+    backend_test.exclude(r'test_nonmaxsuppression_two_classes_cpu')
+    backend_test.exclude(r'test_nonzero_example_cpu')
+    backend_test.exclude(r'test_round_cpu')
     backend_test.exclude(r'test_softmax_axis_0_cpu')
     backend_test.exclude(r'test_softmax_axis_1_cpu')
     backend_test.exclude(r'test_softmax_default_axis_cpu')
 
+    # from OnnxBackendPyTorchConvertedModelTest
+    backend_test.exclude(r'test_ConvTranspose2d_cpu')
+    backend_test.exclude(r'test_ConvTranspose2d_no_bias_cpu')
 
-def disabled_tests_onnx_1_8_1(backend_test):
-    backend_test.exclude(r'test_if_seq_cpu')
+    # from OnnxBackendPyTorchOperatorModelTest
+    backend_test.exclude(r'test_operator_add_broadcast_cpu')
+    backend_test.exclude(r'test_operator_add_size1_right_broadcast_cpu')
+    backend_test.exclude(r'test_operator_addconstant_cpu')
+    backend_test.exclude(r'test_operator_convtranspose_cpu')
+
+    # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_bitshift_left_uint16_cpu')
+    backend_test.exclude(r'test_bitshift_left_uint32_cpu')
+    backend_test.exclude(r'test_bitshift_left_uint64_cpu')
+    backend_test.exclude(r'test_bitshift_left_uint8_cpu')
+    backend_test.exclude(r'test_bitshift_right_uint16_cpu')
+    backend_test.exclude(r'test_bitshift_right_uint32_cpu')
+    backend_test.exclude(r'test_bitshift_right_uint64_cpu')
+    backend_test.exclude(r'test_bitshift_right_uint8_cpu')
+    backend_test.exclude(r'test_cast_FLOAT_to_STRING_cpu')
+    backend_test.exclude(r'test_cast_STRING_to_FLOAT_cpu')
+    backend_test.exclude(r'test_compress_0_cpu')
+    backend_test.exclude(r'test_compress_1_cpu')
+    backend_test.exclude(r'test_compress_default_axis_cpu')
+    backend_test.exclude(r'test_compress_negative_axis_cpu')
+    backend_test.exclude(r'test_constant_pad_cpu')
+    backend_test.exclude(r'test_convinteger_with_padding_cpu')
+    backend_test.exclude(r'test_convtranspose_1d_cpu')
+    backend_test.exclude(r'test_det_2d_cpu')
+    backend_test.exclude(r'test_det_nd_cpu')
+    backend_test.exclude(r'test_dynamicquantizelinear_cpu')
+    backend_test.exclude(r'test_dynamicquantizelinear_max_adjusted_cpu')
+    backend_test.exclude(r'test_dynamicquantizelinear_min_adjusted_cpu')
+    backend_test.exclude(r'test_edge_pad_cpu')
+    backend_test.exclude(r'test_einsum_batch_diagonal_cpu')
+    backend_test.exclude(r'test_einsum_batch_matmul_cpu')
+    backend_test.exclude(r'test_einsum_inner_prod_cpu')
+    backend_test.exclude(r'test_einsum_sum_cpu')
+    backend_test.exclude(r'test_einsum_transpose_cpu')
+    backend_test.exclude(r'test_hardmax_axis_0_cpu')
+    backend_test.exclude(r'test_hardmax_axis_1_cpu')
+    backend_test.exclude(r'test_hardmax_axis_2_cpu')
+    backend_test.exclude(r'test_hardmax_default_axis_cpu')
+    backend_test.exclude(r'test_hardmax_example_cpu')
+    backend_test.exclude(r'test_hardmax_negative_axis_cpu')
+    backend_test.exclude(r'test_hardmax_one_hot_cpu')
+    backend_test.exclude(r'test_isinf_cpu')
+    backend_test.exclude(r'test_isinf_negative_cpu')
+    backend_test.exclude(r'test_isinf_positive_cpu')
+    backend_test.exclude(r'test_matmulinteger_cpu')
+    backend_test.exclude(r'test_maxpool_2d_uint8_cpu')
+    backend_test.exclude(r'test_maxunpool_export_with_output_shape_cpu')
+    backend_test.exclude(r'test_maxunpool_export_without_output_shape_cpu')
+    backend_test.exclude(r'test_mod_mixed_sign_int32_cpu')
+    backend_test.exclude(r'test_mod_mixed_sign_int8_cpu')
+    backend_test.exclude(r'test_mvn_cpu')
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_iinput_shape_is_NCd1_weight_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NC_cpu')
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1_cpu')
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1_mean_weight_negative_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1_weight_cpu')
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_cpu')
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_no_weight_reduction_mean_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_reduction_mean_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_reduction_sum_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_with_weight_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_with_weight_reduction_mean_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_with_weight_reduction_sum_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2_with_weight_reduction_sum_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2d3_none_no_weight_negative_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2d3_sum_weight_high_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2d3d4d5_mean_weight_cpu'
+    )
+    backend_test.exclude(
+        r'test_negative_log_likelihood_loss_input_shape_is_NCd1d2d3d4d5_none_no_weight_cpu'
+    )
+    backend_test.exclude(r'test_qlinearconv_cpu')
+    backend_test.exclude(r'test_qlinearmatmul_2D_cpu')
+    backend_test.exclude(r'test_qlinearmatmul_3D_cpu')
+    backend_test.exclude(r'test_range_float_type_positive_delta_expanded_cpu')
+    backend_test.exclude(r'test_range_int32_type_negative_delta_expanded_cpu')
+    backend_test.exclude(r'test_reflect_pad_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_scales_cubic_A_n0p5_exclude_outside_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_scales_cubic_align_corners_cpu')
+    backend_test.exclude(r'test_resize_downsample_scales_cubic_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_scales_linear_align_corners_cpu')
+    backend_test.exclude(r'test_resize_downsample_scales_linear_cpu')
+    backend_test.exclude(r'test_resize_downsample_scales_nearest_cpu')
+    backend_test.exclude(r'test_resize_downsample_sizes_cubic_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_sizes_linear_pytorch_half_pixel_cpu')
+    backend_test.exclude(r'test_resize_downsample_sizes_nearest_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_sizes_nearest_tf_half_pixel_for_nn_cpu')
+    backend_test.exclude(r'test_resize_tf_crop_and_resize_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_scales_cubic_A_n0p5_exclude_outside_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_scales_cubic_align_corners_cpu')
+    backend_test.exclude(r'test_resize_upsample_scales_cubic_asymmetric_cpu')
+    backend_test.exclude(r'test_resize_upsample_scales_cubic_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_scales_linear_align_corners_cpu')
+    backend_test.exclude(r'test_resize_upsample_scales_linear_cpu')
+    backend_test.exclude(r'test_resize_upsample_scales_nearest_cpu')
+    backend_test.exclude(r'test_resize_upsample_sizes_cubic_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_sizes_nearest_ceil_half_pixel_cpu')
+    backend_test.exclude(r'test_resize_upsample_sizes_nearest_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_sizes_nearest_floor_align_corners_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric_cpu')
+    backend_test.exclude(r'test_reversesequence_batch_cpu')
+    backend_test.exclude(r'test_reversesequence_time_cpu')
+    backend_test.exclude(r'test_scan9_sum_cpu')
+    backend_test.exclude(r'test_scan_sum_cpu')
+    backend_test.exclude(r'test_shrink_hard_cpu')
+    backend_test.exclude(r'test_shrink_soft_cpu')
+    backend_test.exclude(r'test_slice_cpu')
+    backend_test.exclude(r'test_slice_default_axes_cpu')
+    backend_test.exclude(r'test_slice_default_steps_cpu')
+    backend_test.exclude(r'test_slice_end_out_of_bounds_cpu')
+    backend_test.exclude(r'test_slice_neg_cpu')
+    backend_test.exclude(r'test_slice_neg_steps_cpu')
+    backend_test.exclude(r'test_slice_negative_axes_cpu')
+    backend_test.exclude(r'test_slice_start_out_of_bounds_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1_mean_weight_negative_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1_mean_weight_negative_ignore_index_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1_mean_weight_negative_ignore_index_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1_mean_weight_negative_ignore_index_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_none_no_weight_negative_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_none_no_weight_negative_ignore_index_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_none_no_weight_negative_ignore_index_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_none_no_weight_negative_ignore_index_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_sum_weight_high_ignore_index_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_sum_weight_high_ignore_index_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_sum_weight_high_ignore_index_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3_sum_weight_high_ignore_index_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_mean_weight_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_mean_weight_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_mean_weight_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_mean_weight_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_none_no_weight_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_none_no_weight_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_none_no_weight_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_input_shape_is_NCd1d2d3d4d5_none_no_weight_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_3d_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_3d_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_3d_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_3d_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_log_prob_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_3d_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_3d_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_3d_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_3d_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_4d_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_4d_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_4d_log_prob_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_4d_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_no_weight_ignore_index_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(r'test_softmax_cross_entropy_mean_weight_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_3d_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_3d_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_3d_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_3d_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_4d_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_4d_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_4d_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_4d_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_ignore_index_log_prob_expanded_cpu'
+    )
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_mean_weight_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_none_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_none_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_none_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_none_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_none_weights_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_none_weights_expanded_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_none_weights_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_none_weights_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_sum_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_sum_expanded_cpu')
+    backend_test.exclude(r'test_softmax_cross_entropy_sum_log_prob_cpu')
+    backend_test.exclude(
+        r'test_softmax_cross_entropy_sum_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_split_zero_size_splits_cpu')
+    backend_test.exclude(
+        r'test_strnormalizer_export_monday_casesensintive_lower_cpu')
+    backend_test.exclude(
+        r'test_strnormalizer_export_monday_casesensintive_nochangecase_cpu')
+    backend_test.exclude(
+        r'test_strnormalizer_export_monday_casesensintive_upper_cpu')
+    backend_test.exclude(r'test_strnormalizer_export_monday_empty_output_cpu')
+    backend_test.exclude(
+        r'test_strnormalizer_export_monday_insensintive_upper_twodim_cpu')
+    backend_test.exclude(r'test_strnormalizer_nostopwords_nochangecase_cpu')
+    backend_test.exclude(
+        r'test_tfidfvectorizer_tf_batch_onlybigrams_skip0_cpu')
+    backend_test.exclude(
+        r'test_tfidfvectorizer_tf_batch_onlybigrams_skip5_cpu')
+    backend_test.exclude(
+        r'test_tfidfvectorizer_tf_batch_uniandbigrams_skip5_cpu')
+    backend_test.exclude(r'test_tfidfvectorizer_tf_only_bigrams_skip0_cpu')
+    backend_test.exclude(r'test_tfidfvectorizer_tf_onlybigrams_levelempty_cpu')
+    backend_test.exclude(r'test_tfidfvectorizer_tf_onlybigrams_skip5_cpu')
+    backend_test.exclude(r'test_tfidfvectorizer_tf_uniandbigrams_skip5_cpu')
+    backend_test.exclude(r'test_top_k_cpu')
+    backend_test.exclude(r'test_top_k_negative_axis_cpu')
+    backend_test.exclude(r'test_top_k_smallest_cpu')
+    backend_test.exclude(r'test_unique_not_sorted_without_axis_cpu')
+    backend_test.exclude(r'test_unique_sorted_with_axis_3d_cpu')
+    backend_test.exclude(r'test_unique_sorted_with_axis_cpu')
+    backend_test.exclude(r'test_unique_sorted_with_negative_axis_cpu')
+    backend_test.exclude(r'test_unique_sorted_without_axis_cpu')
+    backend_test.exclude(r'test_upsample_nearest_cpu')
+
+    # from OnnxBackendPyTorchConvertedModelTest
+    backend_test.exclude(r'test_PReLU_1d_multiparam_cpu')
+    backend_test.exclude(r'test_PReLU_2d_multiparam_cpu')
+    backend_test.exclude(r'test_PReLU_3d_multiparam_cpu')
+    backend_test.exclude(r'test_ReplicationPad2d_cpu')
+
+    # from OnnxBackendPyTorchOperatorModelTest
+    backend_test.exclude(r'test_operator_add_size1_broadcast_cpu')
+    backend_test.exclude(r'test_operator_add_size1_singleton_broadcast_cpu')
+
+    # from OnnxBackendSimpleModelTest
+    backend_test.exclude(r'test_gradient_of_add_and_mul_cpu')
+    backend_test.exclude(r'test_gradient_of_add_cpu')
+    backend_test.exclude(r'test_sequence_model1_cpu')
+    backend_test.exclude(r'test_sequence_model2_cpu')
+    backend_test.exclude(r'test_sequence_model3_cpu')
+    backend_test.exclude(r'test_sequence_model4_cpu')
+    backend_test.exclude(r'test_sequence_model5_cpu')
+    backend_test.exclude(r'test_sequence_model6_cpu')
+    backend_test.exclude(r'test_sequence_model7_cpu')
+    backend_test.exclude(r'test_sequence_model8_cpu')
+    backend_test.exclude(r'test_shrink_cpu')
+    backend_test.exclude(r'test_strnorm_model_monday_casesensintive_lower_cpu')
+    backend_test.exclude(
+        r'test_strnorm_model_monday_casesensintive_nochangecase_cpu')
+    backend_test.exclude(r'test_strnorm_model_monday_casesensintive_upper_cpu')
+    backend_test.exclude(r'test_strnorm_model_monday_empty_output_cpu')
+    backend_test.exclude(
+        r'test_strnorm_model_monday_insensintive_upper_twodim_cpu')
+    backend_test.exclude(r'test_strnorm_model_nostopwords_nochangecase_cpu')
+
+
+def disabled_tests_onnx_1_8_0(backend_test):
+    # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_cast_BFLOAT16_to_FLOAT_cpu')
+    backend_test.exclude(r'test_cast_FLOAT_to_BFLOAT16_cpu')
     backend_test.exclude(r'test_if_seq_cpu')
-    backend_test.exclude(r'test_reduce_sum_default_axes_keepdims_example_cpu')
-    backend_test.exclude(r'test_reduce_sum_default_axes_keepdims_random_cpu')
-    backend_test.exclude(r'test_reduce_sum_do_not_keepdims_example_cpu')
-    backend_test.exclude(r'test_reduce_sum_do_not_keepdims_random_cpu')
-    backend_test.exclude(r'test_reduce_sum_empty_axes_input_noop_example_cpu')
+    backend_test.exclude(r'test_loop11_cpu')
+    backend_test.exclude(r'test_loop13_seq_cpu')
+    backend_test.exclude(r'test_nllloss_NC_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1_ii_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1_mean_weight_negative_ii_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1_weight_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1_weight_ii_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2_cpu')
+    backend_test.exclude(
+        r'test_nllloss_NCd1d2_no_weight_reduction_mean_ii_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2_reduction_mean_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2_reduction_sum_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2_with_weight_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2_with_weight_reduction_mean_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2_with_weight_reduction_sum_cpu')
+    backend_test.exclude(
+        r'test_nllloss_NCd1d2_with_weight_reduction_sum_ii_cpu')
+    backend_test.exclude(
+        r'test_nllloss_NCd1d2d3_none_no_weight_negative_ii_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2d3_sum_weight_high_ii_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2d3d4d5_mean_weight_cpu')
+    backend_test.exclude(r'test_nllloss_NCd1d2d3d4d5_none_no_weight_cpu')
     backend_test.exclude(r'test_reduce_sum_empty_axes_input_noop_random_cpu')
-    backend_test.exclude(r'test_reduce_sum_keepdims_example_cpu')
-    backend_test.exclude(r'test_reduce_sum_keepdims_random_cpu')
-    backend_test.exclude(r'test_reduce_sum_negative_axes_keepdims_example_cpu')
-    backend_test.exclude(r'test_reduce_sum_negative_axes_keepdims_random_cpu')
-    backend_test.exclude(r'test_unsqueeze_axis_0_cpu')
-    backend_test.exclude(r'test_unsqueeze_axis_1_cpu')
-    backend_test.exclude(r'test_unsqueeze_axis_2_cpu')
-    backend_test.exclude(r'test_unsqueeze_negative_axes_cpu')
-    backend_test.exclude(r'test_unsqueeze_three_axes_cpu')
-    backend_test.exclude(r'test_unsqueeze_two_axes_cpu')
-    backend_test.exclude(r'test_unsqueeze_unsorted_axes_cpu')
+    backend_test.exclude(r'test_sce_NCd1_mean_weight_negative_ii_cpu')
+    backend_test.exclude(r'test_sce_NCd1_mean_weight_negative_ii_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1_mean_weight_negative_ii_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3_none_no_weight_negative_ii_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3_sum_weight_high_ii_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3_sum_weight_high_ii_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3d4d5_mean_weight_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3d4d5_mean_weight_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3d4d5_mean_weight_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3d4d5_none_no_weight_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3d4d5_none_no_weight_expanded_cpu')
+    backend_test.exclude(r'test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_3d_cpu')
+    backend_test.exclude(r'test_sce_mean_3d_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_3d_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_3d_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_cpu')
+    backend_test.exclude(r'test_sce_mean_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_3d_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_3d_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_3d_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_mean_no_weight_ii_3d_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_4d_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_4d_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_4d_log_prob_cpu')
+    backend_test.exclude(
+        r'test_sce_mean_no_weight_ii_4d_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_no_weight_ii_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_3d_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_3d_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_3d_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_3d_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_4d_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_4d_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_4d_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_4d_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_ii_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_log_prob_cpu')
+    backend_test.exclude(r'test_sce_mean_weight_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_none_cpu')
+    backend_test.exclude(r'test_sce_none_expanded_cpu')
+    backend_test.exclude(r'test_sce_none_log_prob_cpu')
+    backend_test.exclude(r'test_sce_none_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_none_weights_cpu')
+    backend_test.exclude(r'test_sce_none_weights_expanded_cpu')
+    backend_test.exclude(r'test_sce_none_weights_log_prob_cpu')
+    backend_test.exclude(r'test_sce_none_weights_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sce_sum_cpu')
+    backend_test.exclude(r'test_sce_sum_expanded_cpu')
+    backend_test.exclude(r'test_sce_sum_log_prob_cpu')
+    backend_test.exclude(r'test_sce_sum_log_prob_expanded_cpu')
+    backend_test.exclude(r'test_sequence_insert_at_back_cpu')
+    backend_test.exclude(r'test_sequence_insert_at_front_cpu')
+    backend_test.exclude(r'test_split_variable_parts_1d_cpu')
+    backend_test.exclude(r'test_split_variable_parts_2d_cpu')
+    backend_test.exclude(r'test_split_variable_parts_default_axis_cpu')
+
+
+def disabled_tests_onnx_1_9_0(backend_test):
+    # fails
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_gru_batchwise_cpu')
+    backend_test.exclude(r'test_lstm_batchwise_cpu')
+    backend_test.exclude(r'test_simple_rnn_batchwise_cpu')
+    backend_test.exclude(r'test_tril_cpu')
+    backend_test.exclude(r'test_tril_one_row_neg_cpu')
+    backend_test.exclude(r'test_tril_square_cpu')
+    # from OnnxBackendPyTorchConvertedModelTest
+    backend_test.exclude(r'test_MaxPool1d_stride_padding_dilation_cpu')
+    backend_test.exclude(r'test_MaxPool2d_stride_padding_dilation_cpu')
+
+    # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_convinteger_without_padding_cpu')
+    backend_test.exclude(r'test_convtranspose_autopad_same_cpu')
+    backend_test.exclude(r'test_identity_sequence_cpu')
+    backend_test.exclude(r'test_tril_neg_cpu')
+    backend_test.exclude(r'test_tril_out_neg_cpu')
+    backend_test.exclude(r'test_tril_out_pos_cpu')
+    backend_test.exclude(r'test_tril_pos_cpu')
+    backend_test.exclude(r'test_tril_square_neg_cpu')
+    backend_test.exclude(r'test_tril_zero_cpu')
+    backend_test.exclude(r'test_triu_neg_cpu')
+    backend_test.exclude(r'test_triu_one_row_cpu')
+    backend_test.exclude(r'test_triu_out_neg_out_cpu')
+    backend_test.exclude(r'test_triu_out_pos_cpu')
+    backend_test.exclude(r'test_triu_pos_cpu')
+    backend_test.exclude(r'test_triu_square_neg_cpu')
+    backend_test.exclude(r'test_triu_zero_cpu')
 
 
 def disabled_tests_onnx_1_10_0(backend_test):
-    # unsupported shape attributes
-    backend_test.exclude(r'test_shape_end_1_cpu')
-    backend_test.exclude(r'test_shape_end_negative_1_cpu')
-    backend_test.exclude(r'test_shape_start_1_cpu')
-    backend_test.exclude(r'test_shape_start_1_end_2_cpu')
-    backend_test.exclude(r'test_shape_start_1_end_negative_1_cpu')
-    backend_test.exclude(r'test_shape_start_negative_1_cpu')
+    # fails
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_bernoulli_double_expanded_cpu')
+    backend_test.exclude(r'test_bernoulli_expanded_cpu')
+    backend_test.exclude(r'test_bernoulli_seed_expanded_cpu')
+
+    # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_bernoulli_cpu')
+    backend_test.exclude(r'test_bernoulli_double_cpu')
+    backend_test.exclude(r'test_bernoulli_seed_cpu')
+    backend_test.exclude(r'test_castlike_BFLOAT16_to_FLOAT_cpu')
+    backend_test.exclude(r'test_castlike_BFLOAT16_to_FLOAT_expanded_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_BFLOAT16_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_BFLOAT16_expanded_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_STRING_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_STRING_expanded_cpu')
+    backend_test.exclude(r'test_castlike_STRING_to_FLOAT_cpu')
+    backend_test.exclude(r'test_castlike_STRING_to_FLOAT_expanded_cpu')
+    backend_test.exclude(r'test_optional_get_element_cpu')
+    backend_test.exclude(r'test_optional_get_element_sequence_cpu')
+    backend_test.exclude(r'test_optional_has_element_cpu')
+    backend_test.exclude(r'test_optional_has_element_empty_cpu')
 
 
 def disabled_tests_onnx_1_11_0(backend_test):
@@ -109,22 +652,90 @@ def disabled_tests_onnx_1_11_0(backend_test):
     backend_test.exclude(r'test_scatter_elements_with_duplicate_indices_cpu')
 
     # fails
+    # from OnnxBackendNodeModelTest
     backend_test.exclude(r'test_roialign_aligned_false_cpu')
     backend_test.exclude(r'test_roialign_aligned_true_cpu')
     backend_test.exclude(r'test_scatternd_add_cpu')
     backend_test.exclude(r'test_scatternd_multiply_cpu')
 
     # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_gridsample_aligncorners_true_cpu')
+    backend_test.exclude(r'test_gridsample_bicubic_cpu')
+    backend_test.exclude(r'test_gridsample_bilinear_cpu')
+    backend_test.exclude(r'test_gridsample_border_padding_cpu')
+    backend_test.exclude(r'test_gridsample_cpu')
+    backend_test.exclude(r'test_gridsample_nearest_cpu')
+    backend_test.exclude(r'test_gridsample_reflection_padding_cpu')
+    backend_test.exclude(r'test_gridsample_zeros_padding_cpu')
     backend_test.exclude(r'test_identity_opt_cpu')
     backend_test.exclude(r'test_if_opt_cpu')
+    backend_test.exclude(r'test_loop16_seq_none_cpu')
 
 
 def disabled_tests_onnx_1_12_0(backend_test):
-    pass
+    # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_blackmanwindow_cpu')
+    backend_test.exclude(r'test_blackmanwindow_expanded_cpu')
+    backend_test.exclude(r'test_blackmanwindow_symmetric_cpu')
+    backend_test.exclude(r'test_blackmanwindow_symmetric_expanded_cpu')
+    backend_test.exclude(r'test_dft_axis_cpu')
+    backend_test.exclude(r'test_dft_cpu')
+    backend_test.exclude(r'test_dft_inverse_cpu')
+    backend_test.exclude(r'test_hammingwindow_cpu')
+    backend_test.exclude(r'test_hammingwindow_expanded_cpu')
+    backend_test.exclude(r'test_hammingwindow_symmetric_cpu')
+    backend_test.exclude(r'test_hammingwindow_symmetric_expanded_cpu')
+    backend_test.exclude(r'test_hannwindow_cpu')
+    backend_test.exclude(r'test_hannwindow_expanded_cpu')
+    backend_test.exclude(r'test_hannwindow_symmetric_cpu')
+    backend_test.exclude(r'test_hannwindow_symmetric_expanded_cpu')
+    backend_test.exclude(r'test_layer_normalization_2d_axis0_cpu')
+    backend_test.exclude(r'test_layer_normalization_2d_axis1_cpu')
+    backend_test.exclude(r'test_layer_normalization_2d_axis_negative_1_cpu')
+    backend_test.exclude(r'test_layer_normalization_2d_axis_negative_2_cpu')
+    backend_test.exclude(r'test_layer_normalization_3d_axis0_epsilon_cpu')
+    backend_test.exclude(r'test_layer_normalization_3d_axis1_epsilon_cpu')
+    backend_test.exclude(r'test_layer_normalization_3d_axis2_epsilon_cpu')
+    backend_test.exclude(
+        r'test_layer_normalization_3d_axis_negative_1_epsilon_cpu')
+    backend_test.exclude(
+        r'test_layer_normalization_3d_axis_negative_2_epsilon_cpu')
+    backend_test.exclude(
+        r'test_layer_normalization_3d_axis_negative_3_epsilon_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis0_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis1_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis2_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis3_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis_negative_1_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis_negative_2_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis_negative_3_cpu')
+    backend_test.exclude(r'test_layer_normalization_4d_axis_negative_4_cpu')
+    backend_test.exclude(r'test_layer_normalization_default_axis_cpu')
+    backend_test.exclude(r'test_melweightmatrix_cpu')
+    backend_test.exclude(r'test_sequence_map_add_1_sequence_1_tensor_cpu')
+    backend_test.exclude(
+        r'test_sequence_map_add_1_sequence_1_tensor_expanded_cpu')
+    backend_test.exclude(r'test_sequence_map_add_2_sequences_cpu')
+    backend_test.exclude(r'test_sequence_map_add_2_sequences_expanded_cpu')
+    backend_test.exclude(r'test_sequence_map_extract_shapes_cpu')
+    backend_test.exclude(r'test_sequence_map_extract_shapes_expanded_cpu')
+    backend_test.exclude(r'test_sequence_map_identity_1_sequence_1_tensor_cpu')
+    backend_test.exclude(
+        r'test_sequence_map_identity_1_sequence_1_tensor_expanded_cpu')
+    backend_test.exclude(r'test_sequence_map_identity_1_sequence_cpu')
+    backend_test.exclude(r'test_sequence_map_identity_1_sequence_expanded_cpu')
+    backend_test.exclude(r'test_sequence_map_identity_2_sequences_cpu')
+    backend_test.exclude(
+        r'test_sequence_map_identity_2_sequences_expanded_cpu')
+    backend_test.exclude(r'test_stft_cpu')
+    backend_test.exclude(r'test_stft_with_window_cpu')
 
 
 def disabled_tests_onnx_1_13_0(backend_test):
     # fails
+    # from OnnxBackendNodeModelTest
     backend_test.exclude(r'test_reduce_l1_do_not_keepdims_example_cpu')
     backend_test.exclude(r'test_reduce_l1_do_not_keepdims_random_cpu')
     backend_test.exclude(r'test_reduce_l1_keep_dims_example_cpu')
@@ -158,11 +769,253 @@ def disabled_tests_onnx_1_13_0(backend_test):
     backend_test.exclude(r'test_scatternd_min_cpu')
 
     # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_bitwise_and_i16_3d_cpu')
+    backend_test.exclude(r'test_bitwise_and_i32_2d_cpu')
+    backend_test.exclude(r'test_bitwise_and_ui64_bcast_3v1d_cpu')
+    backend_test.exclude(r'test_bitwise_and_ui8_bcast_4v3d_cpu')
+    backend_test.exclude(r'test_bitwise_not_2d_cpu')
+    backend_test.exclude(r'test_bitwise_not_3d_cpu')
+    backend_test.exclude(r'test_bitwise_not_4d_cpu')
+    backend_test.exclude(r'test_bitwise_or_i16_4d_cpu')
+    backend_test.exclude(r'test_bitwise_or_i32_2d_cpu')
+    backend_test.exclude(r'test_bitwise_or_ui64_bcast_3v1d_cpu')
+    backend_test.exclude(r'test_bitwise_or_ui8_bcast_4v3d_cpu')
+    backend_test.exclude(r'test_bitwise_xor_i16_3d_cpu')
+    backend_test.exclude(r'test_bitwise_xor_i32_2d_cpu')
+    backend_test.exclude(r'test_bitwise_xor_ui64_bcast_3v1d_cpu')
+    backend_test.exclude(r'test_bitwise_xor_ui8_bcast_4v3d_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_and_pad_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_and_pad_expanded_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_axes_chw_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_axes_chw_expanded_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_axes_hwc_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_axes_hwc_expanded_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_expanded_cpu')
+    backend_test.exclude(r'test_center_crop_pad_pad_cpu')
+    backend_test.exclude(r'test_center_crop_pad_pad_expanded_cpu')
+    backend_test.exclude(r'test_col2im_5d_cpu')
+    backend_test.exclude(r'test_col2im_cpu')
+    backend_test.exclude(r'test_col2im_dilations_cpu')
+    backend_test.exclude(r'test_col2im_pads_cpu')
+    backend_test.exclude(r'test_col2im_strides_cpu')
     backend_test.exclude(r'test_constant_pad_axes_cpu')
+    backend_test.exclude(r'test_group_normalization_epsilon_cpu')
+    backend_test.exclude(r'test_group_normalization_epsilon_expanded_cpu')
+    backend_test.exclude(r'test_group_normalization_example_cpu')
+    backend_test.exclude(r'test_group_normalization_example_expanded_cpu')
+    backend_test.exclude(r'test_mish_cpu')
+    backend_test.exclude(r'test_mvn_expanded_ver18_cpu')
+    backend_test.exclude(r'test_optional_get_element_optional_sequence_cpu')
+    backend_test.exclude(r'test_optional_get_element_optional_tensor_cpu')
+    backend_test.exclude(r'test_optional_get_element_tensor_cpu')
+    backend_test.exclude(
+        r'test_optional_has_element_empty_no_input_name_optional_input_cpu')
+    backend_test.exclude(
+        r'test_optional_has_element_empty_no_input_name_tensor_input_cpu')
+    backend_test.exclude(
+        r'test_optional_has_element_empty_no_input_optional_input_cpu')
+    backend_test.exclude(
+        r'test_optional_has_element_empty_no_input_tensor_input_cpu')
+    backend_test.exclude(r'test_optional_has_element_empty_optional_input_cpu')
+    backend_test.exclude(r'test_optional_has_element_optional_input_cpu')
+    backend_test.exclude(r'test_optional_has_element_tensor_input_cpu')
+    backend_test.exclude(r'test_prelu_broadcast_expanded_cpu')
+    backend_test.exclude(r'test_prelu_example_expanded_cpu')
     backend_test.exclude(r'test_reduce_l1_default_axes_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_l1_default_axes_keepdims_random_cpu')
+    backend_test.exclude(r'test_reduce_l2_default_axes_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_l2_default_axes_keepdims_random_cpu')
+    backend_test.exclude(
+        r'test_reduce_log_sum_exp_default_axes_keepdims_example_cpu')
+    backend_test.exclude(
+        r'test_reduce_log_sum_exp_default_axes_keepdims_random_cpu')
+    backend_test.exclude(
+        r'test_reduce_sum_square_default_axes_keepdims_example_cpu')
+    backend_test.exclude(
+        r'test_reduce_sum_square_default_axes_keepdims_random_cpu')
+    backend_test.exclude(r'test_resize_downsample_scales_cubic_antialias_cpu')
+    backend_test.exclude(r'test_resize_downsample_scales_linear_antialias_cpu')
+    backend_test.exclude(r'test_resize_downsample_sizes_cubic_antialias_cpu')
+    backend_test.exclude(r'test_resize_downsample_sizes_linear_antialias_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_sizes_nearest_not_larger_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_sizes_nearest_not_smaller_cpu')
+    backend_test.exclude(r'test_resize_tf_crop_and_resize_axes_2_3_cpu')
+    backend_test.exclude(r'test_resize_tf_crop_and_resize_axes_3_2_cpu')
+    backend_test.exclude(r'test_resize_upsample_scales_nearest_axes_2_3_cpu')
+    backend_test.exclude(r'test_resize_upsample_scales_nearest_axes_3_2_cpu')
+    backend_test.exclude(r'test_resize_upsample_sizes_nearest_axes_2_3_cpu')
+    backend_test.exclude(r'test_resize_upsample_sizes_nearest_axes_3_2_cpu')
+    backend_test.exclude(r'test_resize_upsample_sizes_nearest_not_larger_cpu')
+    backend_test.exclude(r'test_scatter_elements_with_reduction_max_cpu')
+    backend_test.exclude(r'test_scatter_elements_with_reduction_min_cpu')
+
+    # The following tests fail due to the CastLike operator being unsupported
+    backend_test.exclude(r'test_split_1d_uneven_split_opset18_cpu')
+    backend_test.exclude(r'test_split_2d_uneven_split_opset18_cpu')
+
+
+def disabled_tests_onnx_1_14_0(backend_test):
+    # fails
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_averagepool_2d_dilations_cpu')
+    backend_test.exclude(r'test_roialign_mode_max_cpu')
+
+    # errors
+    # from OnnxBackendNodeModelTest
+    backend_test.exclude(r'test_basic_deform_conv_with_padding_cpu')
+    backend_test.exclude(r'test_basic_deform_conv_without_padding_cpu')
+    backend_test.exclude(r'test_center_crop_pad_crop_negative_axes_hwc_cpu')
+    backend_test.exclude(
+        r'test_center_crop_pad_crop_negative_axes_hwc_expanded_cpu')
+    backend_test.exclude(r'test_constant_pad_negative_axes_cpu')
+    backend_test.exclude(r'test_deform_conv_with_mask_bias_cpu')
+    backend_test.exclude(r'test_deform_conv_with_multiple_offset_groups_cpu')
+    backend_test.exclude(r'test_equal_string_broadcast_cpu')
+    backend_test.exclude(r'test_equal_string_cpu')
+    backend_test.exclude(r'test_lppool_1d_default_cpu')
+    backend_test.exclude(r'test_lppool_2d_default_cpu')
+    backend_test.exclude(r'test_lppool_2d_dilations_cpu')
+    backend_test.exclude(r'test_lppool_2d_pads_cpu')
+    backend_test.exclude(r'test_lppool_2d_same_lower_cpu')
+    backend_test.exclude(r'test_lppool_2d_same_upper_cpu')
+    backend_test.exclude(r'test_lppool_2d_strides_cpu')
+    backend_test.exclude(r'test_lppool_3d_default_cpu')
+    backend_test.exclude(
+        r'test_resize_downsample_scales_linear_half_pixel_symmetric_cpu')
+    backend_test.exclude(
+        r'test_resize_upsample_scales_linear_half_pixel_symmetric_cpu')
+
+    # The following tests fail due to the CastLike operator being unsupported
+    backend_test.exclude(r'test_softplus_example_expanded_ver18_cpu')
+    backend_test.exclude(r'test_softplus_expanded_ver18_cpu')
+    backend_test.exclude(r'test_split_to_sequence_1_cpu')
+    backend_test.exclude(r'test_split_to_sequence_2_cpu')
+    backend_test.exclude(r'test_split_to_sequence_nokeepdims_cpu')
+    backend_test.exclude(r'test_wrap_pad_cpu')
+
+
+def disabled_tests_float8(backend_test):
+    # e4m3fn (Prototensor data type 17 not supported)
+    backend_test.exclude(r'test_dequantizelinear_e4m3fn_cpu')
+    backend_test.exclude(r'test_quantizelinear_e4m3fn_cpu')
+    backend_test.exclude(r'test_cast_FLOAT16_to_FLOAT8E4M3FN_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E4M3FN_to_FLOAT16_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E4M3FN_to_FLOAT_cpu')
+    backend_test.exclude(r'test_cast_FLOAT_to_FLOAT8E4M3FN_cpu')
+    backend_test.exclude(r'test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN_cpu')
+    backend_test.exclude(r'test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E4M3FN_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded_cpu')
+    # e4m3fnuz (Prototensor data type 18 not supported)
+    backend_test.exclude(r'test_cast_FLOAT16_to_FLOAT8E4M3FNUZ_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E4M3FNUZ_to_FLOAT16_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E4M3FNUZ_to_FLOAT_cpu')
+    backend_test.exclude(r'test_cast_FLOAT_to_FLOAT8E4M3FNUZ_cpu')
+    backend_test.exclude(
+        r'test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_cpu')
+    backend_test.exclude(r'test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E4M3FN_to_FLOAT_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded_cpu')
+    # e5m2 ( Prototensor data type 19 not supported )
+    backend_test.exclude(r'test_dequantizelinear_e5m2_cpu')
+    backend_test.exclude(r'test_quantizelinear_e5m2_cpu')
+    backend_test.exclude(r'test_cast_FLOAT16_to_FLOAT8E5M2_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E5M2_to_FLOAT16_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E5M2_to_FLOAT_cpu')
+    backend_test.exclude(r'test_cast_FLOAT_to_FLOAT8E5M2_cpu')
+    backend_test.exclude(r'test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2_cpu')
+    backend_test.exclude(r'test_cast_no_saturate_FLOAT_to_FLOAT8E5M2_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E5M2_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E5M2_expanded_cpu')
+    # e5m2fnuz (Prototensor data type 20 not supported)
+    backend_test.exclude(r'test_cast_FLOAT16_to_FLOAT8E5M2FNUZ_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E5M2FNUZ_to_FLOAT16_cpu')
+    backend_test.exclude(r'test_cast_FLOAT8E5M2FNUZ_to_FLOAT_cpu')
+    backend_test.exclude(r'test_cast_FLOAT_to_FLOAT8E5M2FNUZ_cpu')
+    backend_test.exclude(
+        r'test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_cpu')
+    backend_test.exclude(r'test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E5M2_to_FLOAT_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT8E5M2_to_FLOAT_expanded_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_cpu')
+    backend_test.exclude(r'test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded_cpu')
+
+
+def disabled_tests_dynamic_shape(backend_test):
+    # constantofshape
+    backend_test.exclude(r'test_constantofshape_float_ones_cpu')
+    backend_test.exclude(r'test_constantofshape_int_shape_zero_cpu')
+    backend_test.exclude(r'test_constantofshape_int_zeros_cpu')
+    # cumsum
+    backend_test.exclude(r'test_cumsum_1d_cpu')
+    backend_test.exclude(r'test_cumsum_1d_exclusive_cpu')
+    backend_test.exclude(r'test_cumsum_1d_reverse_cpu')
+    backend_test.exclude(r'test_cumsum_1d_reverse_exclusive_cpu')
+    backend_test.exclude(r'test_cumsum_2d_axis_0_cpu')
+    backend_test.exclude(r'test_cumsum_2d_axis_1_cpu')
+    backend_test.exclude(r'test_cumsum_2d_negative_axis_cpu')
+    # expand
+    backend_test.exclude(r'test_expand_dim_changed_cpu')
+    backend_test.exclude(r'test_expand_dim_unchanged_cpu')
+    backend_test.exclude(r'test_expand_shape_model1_cpu')
+    backend_test.exclude(r'test_expand_shape_model2_cpu')
+    backend_test.exclude(r'test_expand_shape_model3_cpu')
+    backend_test.exclude(r'test_expand_shape_model4_cpu')
+    # onehot
+    backend_test.exclude(r'test_onehot_negative_indices_cpu')
+    backend_test.exclude(r'test_onehot_with_axis_cpu')
+    backend_test.exclude(r'test_onehot_with_negative_axis_cpu')
+    backend_test.exclude(r'test_onehot_without_axis_cpu')
+    # range
+    backend_test.exclude(r'test_range_float_type_positive_delta_cpu')
+    backend_test.exclude(r'test_range_int32_type_negative_delta_cpu')
+    # split
+    backend_test.exclude(r'test_split_variable_parts_1d_opset13_cpu')
+    backend_test.exclude(r'test_split_variable_parts_1d_opset18_cpu')
+    backend_test.exclude(r'test_split_variable_parts_2d_opset13_cpu')
+    backend_test.exclude(r'test_split_variable_parts_2d_opset18_cpu')
+    backend_test.exclude(r'test_split_variable_parts_default_axis_opset13_cpu')
+    backend_test.exclude(r'test_split_variable_parts_default_axis_opset18_cpu')
+    backend_test.exclude(r'test_split_zero_size_splits_opset13_cpu')
+    backend_test.exclude(r'test_split_zero_size_splits_opset18_cpu')
+    # squeeze
+    backend_test.exclude(r'test_squeeze_cpu')
+    backend_test.exclude(r'test_squeeze_negative_axes_cpu')
+    # unsqueeze
+    backend_test.exclude(r'test_unsqueeze_axis_0_cpu')
+    backend_test.exclude(r'test_unsqueeze_axis_1_cpu')
+    backend_test.exclude(r'test_unsqueeze_axis_2_cpu')
+    backend_test.exclude(r'test_unsqueeze_negative_axes_cpu')
+    backend_test.exclude(r'test_unsqueeze_three_axes_cpu')
+    backend_test.exclude(r'test_unsqueeze_two_axes_cpu')
+    backend_test.exclude(r'test_unsqueeze_unsorted_axes_cpu')
+    # tile
+    backend_test.exclude(r'test_tile_cpu')
+    backend_test.exclude(r'test_tile_precomputed_cpu')
+    # reshape
+    backend_test.exclude(r'test_reshape_allowzero_reordered_cpu')
+    backend_test.exclude(r'test_reshape_extended_dims_cpu')
+    backend_test.exclude(r'test_reshape_negative_dim_cpu')
+    backend_test.exclude(r'test_reshape_negative_extended_dims_cpu')
+    backend_test.exclude(r'test_reshape_one_dim_cpu')
+    backend_test.exclude(r'test_reshape_reduced_dims_cpu')
+    backend_test.exclude(r'test_reshape_reordered_all_dims_cpu')
+    backend_test.exclude(r'test_reshape_reordered_last_dims_cpu')
+    backend_test.exclude(r'test_reshape_zero_and_negative_dim_cpu')
+    backend_test.exclude(r'test_reshape_zero_dim_cpu')
+    # reduce
     backend_test.exclude(
         r'test_reduce_l1_default_axes_keepdims_example_expanded_cpu')
-    backend_test.exclude(r'test_reduce_l1_default_axes_keepdims_random_cpu')
     backend_test.exclude(
         r'test_reduce_l1_default_axes_keepdims_random_expanded_cpu')
     backend_test.exclude(
@@ -174,10 +1027,8 @@ def disabled_tests_onnx_1_13_0(backend_test):
         r'test_reduce_l1_negative_axes_keep_dims_example_expanded_cpu')
     backend_test.exclude(
         r'test_reduce_l1_negative_axes_keep_dims_random_expanded_cpu')
-    backend_test.exclude(r'test_reduce_l2_default_axes_keepdims_example_cpu')
     backend_test.exclude(
         r'test_reduce_l2_default_axes_keepdims_example_expanded_cpu')
-    backend_test.exclude(r'test_reduce_l2_default_axes_keepdims_random_cpu')
     backend_test.exclude(
         r'test_reduce_l2_default_axes_keepdims_random_expanded_cpu')
     backend_test.exclude(
@@ -195,12 +1046,8 @@ def disabled_tests_onnx_1_13_0(backend_test):
     backend_test.exclude(r'test_reduce_log_sum_default_expanded_cpu')
     backend_test.exclude(r'test_reduce_log_sum_desc_axes_cpu')
     backend_test.exclude(r'test_reduce_log_sum_desc_axes_expanded_cpu')
-    backend_test.exclude(
-        r'test_reduce_log_sum_exp_default_axes_keepdims_example_cpu')
     backend_test.exclude(
         r'test_reduce_log_sum_exp_default_axes_keepdims_example_expanded_cpu')
-    backend_test.exclude(
-        r'test_reduce_log_sum_exp_default_axes_keepdims_random_cpu')
     backend_test.exclude(
         r'test_reduce_log_sum_exp_default_axes_keepdims_random_expanded_cpu')
     backend_test.exclude(
@@ -245,12 +1092,17 @@ def disabled_tests_onnx_1_13_0(backend_test):
     backend_test.exclude(
         r'test_reduce_prod_negative_axes_keepdims_example_cpu')
     backend_test.exclude(r'test_reduce_prod_negative_axes_keepdims_random_cpu')
-    backend_test.exclude(
-        r'test_reduce_sum_square_default_axes_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_sum_default_axes_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_sum_default_axes_keepdims_random_cpu')
+    backend_test.exclude(r'test_reduce_sum_do_not_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_sum_do_not_keepdims_random_cpu')
+    backend_test.exclude(r'test_reduce_sum_empty_axes_input_noop_example_cpu')
+    backend_test.exclude(r'test_reduce_sum_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_sum_keepdims_random_cpu')
+    backend_test.exclude(r'test_reduce_sum_negative_axes_keepdims_example_cpu')
+    backend_test.exclude(r'test_reduce_sum_negative_axes_keepdims_random_cpu')
     backend_test.exclude(
         r'test_reduce_sum_square_default_axes_keepdims_example_expanded_cpu')
-    backend_test.exclude(
-        r'test_reduce_sum_square_default_axes_keepdims_random_cpu')
     backend_test.exclude(
         r'test_reduce_sum_square_default_axes_keepdims_random_expanded_cpu')
     backend_test.exclude(
@@ -265,47 +1117,6 @@ def disabled_tests_onnx_1_13_0(backend_test):
         r'test_reduce_sum_square_negative_axes_keepdims_example_expanded_cpu')
     backend_test.exclude(
         r'test_reduce_sum_square_negative_axes_keepdims_random_expanded_cpu')
-    backend_test.exclude(r'test_scatter_elements_with_reduction_max_cpu')
-    backend_test.exclude(r'test_scatter_elements_with_reduction_min_cpu')
-
-    # The following tests fail due to the CastLike operator being unsupported
-    backend_test.exclude(r'test_elu_default_expanded_ver18_cpu')
-    backend_test.exclude(r'test_elu_example_expanded_ver18_cpu')
-    backend_test.exclude(r'test_elu_expanded_ver18_cpu')
-    backend_test.exclude(r'test_hardsigmoid_default_expanded_ver18_cpu')
-    backend_test.exclude(r'test_hardsigmoid_example_expanded_ver18_cpu')
-    backend_test.exclude(r'test_hardsigmoid_expanded_ver18_cpu')
-    backend_test.exclude(r'test_leakyrelu_default_expanded_cpu')
-    backend_test.exclude(r'test_leakyrelu_example_expanded_cpu')
-    backend_test.exclude(r'test_leakyrelu_expanded_cpu')
-    backend_test.exclude(r'test_selu_default_expanded_ver18_cpu')
-    backend_test.exclude(r'test_selu_example_expanded_ver18_cpu')
-    backend_test.exclude(r'test_selu_expanded_ver18_cpu')
-    backend_test.exclude(r'test_thresholdedrelu_default_expanded_ver18_cpu')
-    backend_test.exclude(r'test_thresholdedrelu_example_expanded_ver18_cpu')
-    backend_test.exclude(r'test_thresholdedrelu_expanded_ver18_cpu')
-    backend_test.exclude(r'test_relu_expanded_ver18_cpu')
-    backend_test.exclude(r'test_softsign_example_expanded_ver18_cpu')
-    backend_test.exclude(r'test_softsign_expanded_ver18_cpu')
-
-
-def disabled_tests_onnx_1_14_0(backend_test):
-    # fails
-    backend_test.exclude(r'test_averagepool_2d_dilations_cpu')
-    backend_test.exclude(r'test_roialign_mode_max_cpu')
-
-    # errors
-    backend_test.exclude(r'test_constant_pad_negative_axes_cpu')
-    backend_test.exclude(r'test_dequantizelinear_e4m3fn_cpu')
-    backend_test.exclude(r'test_dequantizelinear_e5m2_cpu')
-    backend_test.exclude(r'test_equal_string_broadcast_cpu')
-    backend_test.exclude(r'test_equal_string_cpu')
-    backend_test.exclude(r'test_quantizelinear_e4m3fn_cpu')
-    backend_test.exclude(r'test_quantizelinear_e5m2_cpu')
-
-    # The following tests fail due to the CastLike operator being unsupported
-    backend_test.exclude(r'test_softplus_example_expanded_ver18_cpu')
-    backend_test.exclude(r'test_softplus_expanded_ver18_cpu')
 
 
 def create_backend_test(testname=None, target_device=None):
@@ -316,8 +1127,7 @@ def create_backend_test(testname=None, target_device=None):
     if testname:
         backend_test.include(testname + '.*')
     else:
-        # Include all of the nodes that we support.
-        # Onnx native node tests
+        # Onnx Operator tests
         backend_test.include(r'.*test_abs.*')
         backend_test.include(r'.*test_acos.*')
         backend_test.include(r'.*test_acosh.*')
@@ -331,73 +1141,209 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.include(r'.*test_atanh.*')
         backend_test.include(r'.*test_averagepool.*')
         backend_test.include(r'.*test_AvgPool.*')
-        backend_test.include(r'.*test_BatchNorm.*eval.*')
+        backend_test.include(r'.*test_[bB]atch[nN]orm(?!.*training).*')
+        backend_test.include(r'.*test_bitshift.*')
+        backend_test.include(r'.*test_bitwise.*')
         backend_test.include(r'.*test_ceil.*')
-        backend_test.include(r'.*test_celu.*')
-        backend_test.include(r'.*test_clip.*')
+        backend_test.include(r'.*test_cast_.*')
+        backend_test.include(r'.*test_col2im.*')
+        backend_test.include(r'.*test_compress.*')
         backend_test.include(r'.*test_concat.*')
-        backend_test.include(r'.*test_constant.*')
-        backend_test.include(r'.*test_Conv[1-3]d*')
+        backend_test.include(r'.*test_constant_.*')
+        backend_test.include(r'.*test_Constant.*')
+        backend_test.include(r'.*test_constantofshape.*')
+        backend_test.include(r'.*test_(basic_)?conv_.*')
+        backend_test.include(r'.*test_Conv[1-3]d.*')
+        backend_test.include(r'.*test_convinteger.*')
+        backend_test.include(r'.*test_convtranspose.*')
+        backend_test.include(r'.*test_ConvTranspose[1-3]d.*')
         backend_test.include(r'.*test_cos.*')
         backend_test.include(r'.*test_cosh.*')
+        backend_test.include(r'.*test_cumsum.*')
+        backend_test.include(r'.*test_(basic_)?deform_conv.*')
         backend_test.include(r'.*test_depthtospace.*')
-        backend_test.include(r'.*test_dequantizelinear')
+        backend_test.include(r'.*test_dequantizelinear.*')
+        backend_test.include(r'.*test_det.*')
+        backend_test.include(r'.*test_dft.*')
         backend_test.include(r'.*test_div.*')
         backend_test.include(r'.*test_dropout.*')
-        backend_test.include(r'.*test_ELU*')
-        backend_test.include(r'.*test_elu.*')
+        backend_test.include(r'.*test_einsum.*')
         backend_test.include(r'.*test_equal.*')
-        backend_test.include(r'.*test_Embedding*')
-        backend_test.include(r'.*test_exp.*')
+        backend_test.include(r'.*test_Embedding.*')
+        backend_test.include(r'.*test_erf.*')
+        backend_test.include(r'.*test_exp_.*')
+        backend_test.include(r'.*test_expand.*')
         backend_test.include(r'.*test_eyelike.*')
         backend_test.include(r'.*test_flatten.*')
         backend_test.include(r'.*test_floor.*')
-        backend_test.include(r'.*test_fmod.*')
+        backend_test.include(r'.*test_gru.*')
         backend_test.include(r'.*test_gather.*')
         backend_test.include(r'.*test_gemm.*')
         backend_test.include(r'.*test_globalaveragepool.*')
+        backend_test.include(r'.*test_globallppool.*')
         backend_test.include(r'.*test_globalmaxpool.*')
         backend_test.include(r'.*test_greater.*')
-        backend_test.include(r'.*test_hardsigmoid.*')
-        backend_test.include(r'.*test_hardswish.*')
+        backend_test.include(r'.*test_gridsample.*')
+        backend_test.include(r'.*test_hardmax.*')
         backend_test.include(r'.*test_identity.*')
         backend_test.include(r'.*test_if.*')
+        backend_test.include(r'.*test_instancenorm.*')
+        backend_test.include(r'.*test_isinf.*')
         backend_test.include(r'.*test_isnan.*')
-        backend_test.include(r'.*test_LeakyReLU*')
-        backend_test.include(r'.*test_leakyrelu.*')
-        backend_test.include(r'.*test_less.*')
-        backend_test.include(r'.*test_Linear.*')
-        backend_test.include(r'.*test_log.*')
-        backend_test.include(r'.*test_logsoftmax.*')
-        backend_test.include(r'.*test_LogSoftmax.*')
-        backend_test.include(r'.*test_log_softmax.*')
         backend_test.include(r'.*test_lrn.*')
+        backend_test.include(r'.*test_lstm.*')
+        backend_test.include(r'.*test_log.*')
+        backend_test.include(r'.*test_loop.*')
+        backend_test.include(r'.*test_lpnorm.*')
+        backend_test.include(r'.*test_lppool.*')
         backend_test.include(r'.*test_matmul.*')
-        backend_test.include(r'.*test_max.*')
-        backend_test.include(r'.*test_MaxPool[1-9]d.*')
+        backend_test.include(r'.*test_max_.*')
+        backend_test.include(r'.*test_maxpool.*')
+        backend_test.include(r'.*test_MaxPool[1-3]d.*')
+        backend_test.include(r'.*test_maxroipool.*')
+        backend_test.include(r'.*test_maxunpool.*')
         backend_test.include(r'.*test_mean.*')
+        backend_test.include(r'.*test_melweightmatrix.*')
         backend_test.include(r'.*test_min.*')
-        backend_test.include(r' .*test_mod.*')
+        backend_test.include(r'.*test_mod.*')
         backend_test.include(r'.*test_mul.*')
-        backend_test.include(r'.*test_multinomial.*')
-        backend_test.include(r'.*test_Multinomial.*')
+        backend_test.include(r'.*test_[mM]ultinomial.*')
         backend_test.include(r'.*test_neg.*')
+        backend_test.include(r'.*test_nonmaxsuppression.*')
+        backend_test.include(r'.*test_nonzero.*')
         backend_test.include(r'.*test_not.*')
+        backend_test.include(r'.*test_onehot.*')
+        backend_test.include(r'.*optional_get_element.*')
+        backend_test.include(r'.*optional_has_element.*')
+        backend_test.include(r'.*test_or.*')
+        backend_test.include(r'.*test_(constant_|edge_|reflect_|wrap_)?pad.*')
+        backend_test.include(
+            r'.*test_(Constant|Reflection|Replication|Zero)+Pad2d.*')
+        backend_test.include(r'.*test_pow.*')
+        backend_test.include(r'.*test_qlinearconv.*')
+        backend_test.include(r'.*test_qlinearmatmul.*')
+        backend_test.include(r'.*test_quantizelinear.*')
+        backend_test.include(r'.*test_(simple_)?rnn.*')
+        backend_test.include(r'.*test_randomnormal.*')
+        backend_test.include(r'.*test_randomuniform.*')
+        backend_test.include(r'.*test_reciprocal.*')
+        backend_test.include(r'.*test_reduce_max.*')
+        backend_test.include(r'.*test_reduce_mean.*')
+        backend_test.include(r'.*test_reduce_min.*')
+        backend_test.include(r'.*test_reduce_prod.*')
+        backend_test.include(r'.*test_reduce_sum.*')
+        backend_test.include(r'.*test_reshape.*')
+        backend_test.include(r'.*test_resize.*')
+        backend_test.include(r'.*test_reversesequence.*')
+        backend_test.include(r'.*test_roialign.*')
+        backend_test.include(r'.*test_round.*')
+        backend_test.include(r'.*test_stft.*')
+        backend_test.include(r'.*test_scan.*')
+        backend_test.include(r'.*test_scatter.*')
+        backend_test.include(r'.*test_sequence_at.*')
+        backend_test.include(r'.*test_sequence_construct.*')
+        backend_test.include(r'.*test_sequence_empty.*')
+        backend_test.include(r'.*test_sequence_erase.*')
+        backend_test.include(r'.*test_sequence_insert.*')
+        backend_test.include(r'.*test_sequence_length.*')
+        backend_test.include(r'.*test_shape.*')
+        backend_test.include(r'.*test_[sS]igmoid.*')
+        backend_test.include(r'.*test_sign.*')
+        backend_test.include(r'.*test_sin_.*')
+        backend_test.include(r'.*test_sinh.*')
+        backend_test.include(r'.*test_size.*')
+        backend_test.include(r'.*test_slice.*')
+        backend_test.include(r'.*test_spacetodepth.*')
+        backend_test.include(r'.*test_split.*')
+        backend_test.include(r'.*test_split_to_sequence.*')
+        backend_test.include(r'.*test_sqrt.*')
+        backend_test.include(r'.*test_squeeze.*')
+        backend_test.include(r'.*test_squeeze.*')
+        backend_test.include(r'.*test_strnorm.*')
+        backend_test.include(r'.*test_sub.*')
+        backend_test.include(r'.*test_sum.*')
+        backend_test.include(r'.*test_tan_.*')
+        backend_test.include(r'.*test_[tT]anh.*')
+        backend_test.include(r'.*test_tfidfvectorizer.*')
+        backend_test.include(r'.*test_tile.*')
+        backend_test.include(r'.*test_top_k.*')
+        backend_test.include(r'.*test_transpose.*')
+        backend_test.include(r'.*test_tril.*')
+        backend_test.include(r'.*test_triu.*')
+        backend_test.include(r'.*test_unique.*')
+        backend_test.include(r'.*test_unsqueeze.*')
+        backend_test.include(r'.*test_upsample.*')
+        backend_test.include(r'.*test_where.*')
+        backend_test.include(r'.*test_xor.*')
+
+        # Onnx Function tests
+        backend_test.include(r'.*test_bernoulli.*')
+        backend_test.include(r'.*test_blackmanwindow.*')
+        backend_test.include(r'.*test_castlike.*')
+        backend_test.include(r'.*test_celu.*')
+        backend_test.include(r'.*test_center_crop_pad.*')
+        backend_test.include(r'.*test_clip.*')
+        backend_test.include(r'.*test_dynamicquantizelinear.*')
+        backend_test.include(r'.*test_elu.*')
+        backend_test.include(r'.*test_ELU.*')
+        backend_test.include(r'.*test_GLU.*')
+        backend_test.include(r'.*test_greater_equal.*')
+        backend_test.include(r'.*test_group_normalization.*')
+        backend_test.include(r'.*test_hammingwindow.*')
+        backend_test.include(r'.*test_hannwindow.*')
+        backend_test.include(r'.*test_hardsigmoid.*')
+        backend_test.include(r'.*test_hardswish.*')
+        backend_test.include(r'.*test_layer_normalization.*')
+        backend_test.include(r'.*test_LeakyReLU.*')
+        backend_test.include(r'.*test_leakyrelu.*')
+        backend_test.include(r'.*test_less.*')
+        backend_test.include(r'.*test_Linear.*')
+        backend_test.include(r'.*test_logsoftmax.*')
+        backend_test.include(r'.*test_log_softmax.*')
+        backend_test.include(r'.*test_LogSoftmax.*')
+        backend_test.include(r'.*test_mvn.*')
+        backend_test.include(r'.*test_mish.*')
+        backend_test.include(r'.*test_nllloss.*')
+        backend_test.include(r'.*test_PixelShuffle.*')
+        backend_test.include(r'.*test_PoissonNLLLLoss_no_reduce.*')
+        backend_test.include(r'.*test_prelu.*')
+        backend_test.include(r'.*test_PReLU.*')
+        backend_test.include(r'.*test_range.*')
+        backend_test.include(r'.*test_reduce_l1.*')
+        backend_test.include(r'.*test_reduce_l2.*')
+        backend_test.include(r'.*test_reduce_log.*')
+        backend_test.include(r'.*test_ReLU.*')
+        backend_test.include(r'.*test_relu.*')
+        backend_test.include(r'.*test_selu.*')
+        backend_test.include(r'.*test_SELU.*')
+        backend_test.include(r'.*test_sequence_map.*')
+        backend_test.include(r'.*test_shrink.*')
+        backend_test.include(r'.*test_[sS]oftmax.*')
+        backend_test.include(r'.*test_[sS]oftplus.*')
+        backend_test.include(r'.*test_[sS]oftsign.*')
+        backend_test.include(r'.*test_sce.*')
+        backend_test.include(r'.*test_thresholdedrelu.*')
+
+        # OnnxBackendPyTorchOperatorModelTest
+        backend_test.include(r'.*test_operator_add_broadcast.*')
+        backend_test.include(r'.*test_operator_addconstant.*')
         backend_test.include(r'.*test_operator_addmm.*')
+        backend_test.include(r'.*test_operator_add_size1.*')
         backend_test.include(r'.*test_operator_basic.*')
         backend_test.include(r'.*test_operator_chunk.*')
         backend_test.include(r'.*test_operator_clip.*')
         backend_test.include(r'.*test_operator_concat2.*')
         backend_test.include(r'.*test_operator_conv_.*')
+        backend_test.include(r'.*test_operator_convtranspose.*')
         backend_test.include(r'.*test_operator_exp.*')
         backend_test.include(r'.*test_operator_flatten.*')
         backend_test.include(r'.*test_operator_index.*')
         backend_test.include(r'.*test_operator_max_.*')
         backend_test.include(r'.*test_operator_maxpool.*')
         backend_test.include(r'.*test_operator_min.*')
-        backend_test.include(r'.*test_operator_mod.*')
         backend_test.include(r'.*test_operator_mm.*')
         backend_test.include(r'.*test_operator_non_float_params.*')
+        backend_test.include(r'.*test_operator_pad.*')
         backend_test.include(r'.*test_operator_params.*')
         backend_test.include(r'.*test_operator_permute2.*')
         backend_test.include(r'.*test_operator_pow.*')
@@ -405,55 +1351,19 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.include(r'.*test_operator_reduced_mean_keepdim.*')
         backend_test.include(r'.*test_operator_reduced_sum_.*')
         backend_test.include(r'.*test_operator_reduced_sum_keepdim.*')
+        backend_test.include(r'.*test_operator_repeat.*')
         backend_test.include(r'.*test_operator_selu.*')
         backend_test.include(r'.*test_operator_sqrt.*')
         backend_test.include(r'.*test_operator_symbolic_override.*')
         backend_test.include(r'.*test_operator_symbolic_override_nested.*')
         backend_test.include(r'.*test_operator_view.*')
-        backend_test.include(r'.*test_or.*')
-        backend_test.include(r'.*test_pow.*')
-        backend_test.include(r'.*test_PoissonNLLLLoss_no_reduce*')
-        backend_test.include(r'.*test_quantizelinear')
-        backend_test.include(r'.*test_reciprocal.*')
-        backend_test.include(r'.*test_reduce.*')
-        backend_test.include(r'.*test_ReLU*')
-        backend_test.include(r'.*test_relu.*')
-        #backend_test.include(r'.*test_reversesequence.*')
-        backend_test.include(r'.*test_RoiAlign*')
-        backend_test.include(r'.*test_roialign.*')
-        backend_test.include(r'.*test_scatter.*')
-        backend_test.include(r'.*test_Scatter.*')
-        backend_test.include(r'.*test_selu.*')
-        backend_test.include(r'.*test_shape.*')
-        backend_test.include(r'.*test_Sigmoid*')
-        backend_test.include(r'.*test_sigmoid.*')
-        backend_test.include(r'.*test_sin.*')
-        backend_test.include(r'.*test_sinh.*')
-        backend_test.include(r'.*test_size.*')
-        backend_test.include(r'.*test_Softmax*')
-        backend_test.include(r'.*test_softmax.*')
-        backend_test.include(r'.*test_Softmin*')
-        backend_test.include(r'.*test_Softplus*')
-        backend_test.include(r'.*test_softplus.*')
-        backend_test.include(r'.*test_softsign.*')
-        backend_test.include(r'.*test_sqrt.*')
-        backend_test.include(r'.*test_squeeze_cuda')
-        backend_test.include(r'.*test_sub.*')
-        backend_test.include(r'.*test_sum.*')
-        backend_test.include(r'.*test_tan.*')
-        backend_test.include(r'.*test_Tanh*')
-        backend_test.include(r'.*test_tanh.*')
-        backend_test.include(r'.*test_thresholdedrelu.*')
-        backend_test.include(r'.*test_topk.*')
-        backend_test.include(r'.*test_Topk.*')
-        backend_test.include(r'.*test_transpose.*')
-        backend_test.include(r'.*test_unsqueeze.*')
-        backend_test.include(r'.*test_where*')
-        backend_test.include(r'.*test_where.*')
-        backend_test.include(r'.*test_xor.*')
-        backend_test.include(r'.*test_ZeroPad2d*')
 
-        # # Onnx native model tests
+        # OnnxBackendSimpleModelTest
+        backend_test.include(r'.*test_gradient_of.*')
+        backend_test.include(r'.*test_sequence_model.*')
+        backend_test.include(r'.*test_single_relu_model.*')
+
+        # OnnxBackendRealModelTest
         backend_test.include(r'.*test_bvlc_alexnet.*')
         backend_test.include(r'.*test_densenet121.*')
         backend_test.include(r'.*test_inception_v1.*')
@@ -464,69 +1374,42 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.include(r'.*test_vgg19.*')
         backend_test.include(r'.*test_zfnet512.*')
 
-        # exclude unenabled ops get pulled in with wildcards
-        # test_constant_pad gets pulled in with the test_constant* wildcard. Explicitly disable padding tests for now.
-        # Operator MATMULINTEGER is not supported by TRT
-        backend_test.exclude(r'.*test_matmulinteger.*')
-        backend_test.exclude(r'.*test_maxunpool.*')
-        # Absolute diff failed because
-        # numpy compares the difference between actual and desired to atol + rtol * abs(desired)
-
-        # failed test cases
-        backend_test.exclude(
-            r'test_argmax_keepdims_example_select_last_index_cpu')
-        backend_test.exclude(
-            r'test_argmax_negative_axis_keepdims_example_select_last_index_cpu'
-        )
-        backend_test.exclude(
-            r'test_argmax_no_keepdims_example_select_last_index_cpu')
-        backend_test.exclude(
-            r'test_argmin_keepdims_example_select_last_index_cpu')
-        backend_test.exclude(
-            r'test_argmin_negative_axis_keepdims_example_select_last_index_cpu'
-        )
-        backend_test.exclude(
-            r'test_argmin_no_keepdims_example_select_last_index_cpu')
-        backend_test.exclude(r'test_lrn_cpu')
-        backend_test.exclude(r'test_lrn_default_cpu')
-        backend_test.exclude(r'test_maxpool_2d_dilations_cpu')
-        backend_test.exclude(r'test_MaxPool2d_stride_padding_dilation_cpu')
-        backend_test.exclude(r'test_MaxPool1d_stride_padding_dilation_cpu')
-        backend_test.exclude(
-            r'test_maxpool_with_argmax_2d_precomputed_pads_cpu')
-        backend_test.exclude(
-            r'test_maxpool_with_argmax_2d_precomputed_strides_cpu')
-
-        # error cases
-        backend_test.exclude(r'test_constant_pad_cpu')
-        backend_test.exclude(r'test_constantofshape_float_ones_cpu')
-        backend_test.exclude(r'test_constantofshape_int_shape_zero_cpu')
-        backend_test.exclude(r'test_constantofshape_int_zeros_cpu')
-        backend_test.exclude(r'test_expand_dim_changed_cpu')
-        backend_test.exclude(r'test_expand_dim_unchanged_cpu')
-        backend_test.exclude(r'test_expand_shape_model1_cpu')
-        backend_test.exclude(r'test_expand_shape_model2_cpu')
-        backend_test.exclude(r'test_expand_shape_model3_cpu')
-        backend_test.exclude(r'test_expand_shape_model4_cpu')
-        backend_test.exclude(r'test_identity_sequence_cpu')
-        backend_test.exclude(r'test_maxpool_2d_uint8_cpu')
-        backend_test.exclude(r'test_negative_log_likelihood_loss_*')
-
-        # all reduce ops have dynamic axes inputs
-        backend_test.exclude(r'test_softmax_cross_entropy_*')
-        backend_test.exclude(r'test_Embedding_cpu')
-
-        # real model tests
+        # Skipped tests
+        # backend_test.include(r'.*test_adagrad.*')
+        # backend_test.include(r'.*test_adam.*')
+        # backend_test.include(r'.*test_ai_onnx_ml.*')
+        # backend_test.include(r'.*test_batchnorm_epsilon_training.*')
+        # backend_test.include(r'.*test_batchnorm_example_training.*')
+        # backend_test.include(r'.*test_momentum.*')
+        # backend_test.include(r'.*test_nesterov_momentum.*')
+        # backend_test.include(r'.*test_training_dropout.*')
+        # backend_test.include(r'.*test_Softmin.*')
+
+        # Exclude failing tests
+
+        # from OnnxBackendRealModelTest
         backend_test.exclude(r'test_inception_v1_cpu')
         backend_test.exclude(r'test_resnet50_cpu')
         backend_test.exclude(r'test_squeezenet_cpu')
 
+        # PRelu OnnxBackendPyTorchConvertedModelTest has wrong dim for broadcasting
+        backend_test.exclude(r'[a-z,_]*PReLU_[0-9]d_multiparam[a-z,_]*')
+
+        # Remove when float8 is supported
+        disabled_tests_float8(backend_test)
+
+        # Remove when dynamic shapes are supported
+        disabled_tests_dynamic_shape(backend_test)
+
         # additional cases disabled for a specific onnx version
-        if version.parse(onnx.__version__) <= version.parse("1.7.0"):
+        if version.parse(onnx.__version__) >= version.parse("1.7.0"):
             disabled_tests_onnx_1_7_0(backend_test)
 
         if version.parse(onnx.__version__) >= version.parse("1.8.0"):
-            disabled_tests_onnx_1_8_1(backend_test)
+            disabled_tests_onnx_1_8_0(backend_test)
+
+        if version.parse(onnx.__version__) >= version.parse("1.9.0"):
+            disabled_tests_onnx_1_9_0(backend_test)
 
         if version.parse(onnx.__version__) >= version.parse("1.10.0"):
             disabled_tests_onnx_1_10_0(backend_test)