Size ONNX op (#1122)

* Implement size ONNX operator and tests

src/onnx/parse_size.cpp

+#include <migraphx/onnx/op_parser.hpp>
+#include <migraphx/onnx/checks.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/make_op.hpp>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace onnx {
+
+struct parse_size : op_parser<parse_size>
+{
+    std::vector<op_desc> operators() const { return {{"Size"}}; }
+
+    instruction_ref parse(const op_desc&,
+                          const onnx_parser&,
+                          const onnx_parser::node_info& info,
+                          std::vector<instruction_ref> args) const
+    {
+        return info.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int64_type},
+                                                  {args[0]->get_shape().elements()}});
+    }
+};
+
+} // namespace onnx
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

test/onnx/gen_onnx.py

@@ -4434,6 +4434,54 @@ def sinh_test():
     return ([node], [x], [y])
 
 
+@onnx_test
+def size_float_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3, 4])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def size_half_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [3, 1])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def size_int_test():
+    x = helper.make_tensor_value_info('x', TensorProto.INT32, [8, 2, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
+@onnx_test
+def size_verify_test():
+    x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 5, 3])
+    y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
+    node = onnx.helper.make_node(
+        'Size',
+        inputs=['x'],
+        outputs=['y'],
+    )
+    return ([node], [x], [y])
+
+
 @onnx_test
 def slice_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 2])

test/onnx/onnx_test.cpp

@@ -4298,6 +4298,40 @@ TEST_CASE(sinh_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(size_float_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s   = migraphx::shape{migraphx::shape::float_type, {2, 3, 4}};
+    mm->add_parameter("x", s);
+    mm->add_literal(migraphx::literal{migraphx::shape::int64_type, {s.elements()}});
+
+    auto prog = optimize_onnx("size_float_test.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(size_half_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s   = migraphx::shape{migraphx::shape::half_type, {3, 1}};
+    mm->add_parameter("x", s);
+    mm->add_literal(migraphx::literal{migraphx::shape::int64_type, {s.elements()}});
+    auto prog = optimize_onnx("size_half_test.onnx");
+    EXPECT(p == prog);
+}
+
+TEST_CASE(size_int_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    auto s   = migraphx::shape{migraphx::shape::int32_type, {8, 2, 3}};
+    mm->add_parameter("x", s);
+    mm->add_literal(migraphx::literal{migraphx::shape::int64_type, {s.elements()}});
+    auto prog = optimize_onnx("size_int_test.onnx");
+    EXPECT(p == prog);
+}
+
 TEST_CASE(slice_test)
 {
     migraphx::program p;

test/onnx/size_float_test.onnx

+size_float_test:I
+
+
x
y"Sizesize_float_testZ
+
x
+

+
+
+b
+
y
+
+
+
B
\ No newline at end of file

test/onnx/size_half_test.onnx

+size_half_test:D
+
+
x
y"Sizesize_half_testZ
+
x
+
+
+
+
b
+
y
+
+
+
B
\ No newline at end of file

test/onnx/size_int_test.onnx

+
size_int_test:G
+
+
x
y"Size
size_int_testZ
+
x
+
+
+
+b
+
y
+
+
+
B
\ No newline at end of file

test/onnx/size_verify_test.onnx

+size_verify_test:J
+
+
x
y"Sizesize_verify_testZ
+
x
+

+
+
+b
+
y
+
+
+
B
\ No newline at end of file

test/onnx/verify_onnx.cpp

@@ -640,6 +640,21 @@ TEST_CASE(selu_test)
     EXPECT(migraphx::verify_range(result_vector, gold));
 }
 
+TEST_CASE(size_verify_test)
+{
+    migraphx::program p = migraphx::parse_onnx("size_verify_test.onnx");
+    p.compile(migraphx::ref::target{});
+
+    migraphx::shape s{migraphx::shape::float_type, {2, 5, 3}};
+    std::vector<float> data(30, 1.);
+    migraphx::parameter_map pp;
+    pp["x"] = migraphx::argument(s, data.data());
+
+    auto result      = p.eval(pp).back();
+    auto size_result = result.at<int64_t>();
+    EXPECT(size_result == int64_t{30});
+}
+
 TEST_CASE(slice_test)
 {
     migraphx::program p = migraphx::parse_onnx("slice_test.onnx");

test/py/onnx_backend_test.py

@@ -274,8 +274,6 @@ def create_backend_test(testname=None, target_device=None):
         backend_test.exclude(r'test_negative_log_likelihood_loss_*')
 
         # all reduce ops have dynamic axes inputs
-        backend_test.exclude(r'test_size_cpu')
-        backend_test.exclude(r'test_size_example_cpu')
         backend_test.exclude(r'test_softmax_cross_entropy_*')
         backend_test.exclude(r'test_Embedding_cpu')