Skip to content

GitLab

Unverified Commit 99bcbf02 authored by mvermeulen's avatar mvermeulen Committed by GitHub
Browse files

Merge branch 'develop' into cse-fix

parents c0640134 92c62bd0
Hide whitespace changes
Inline Side-by-side
Showing with 582 additions and 571 deletions
test/onnx/implicit_bcast_test.onnx → test/onnx/implicit_pow_bcast_test.onnx
View file @ 99bcbf02
add2:u pow2:q
 
0 0
1out"Add subtraction2Z 1out"Powpow_testZ
0 0
 
 
......
test/onnx/leaky_relu.onnx → test/onnx/leaky_relu_test.onnx
View file @ 99bcbf02
leaky_relu-example:R leaky_relu-example:R
" "
01" LeakyRelu* 01" LeakyRelu*
alpha alpha
...@@ -11,4 +11,4 @@ test-modelZ ...@@ -11,4 +11,4 @@ test-modelZ
1 1
 
B B
\ No newline at end of file
test/onnx/onnx_cosh.onnx deleted 100644 → 0
View file @ c0640134
 cosh-example:;
xy"Cosh test_coshZ
x

b
y

B
\ No newline at end of file
test/onnx/onnx_test.cpp
View file @ 99bcbf02
...@@ -8,679 +8,684 @@ ...@@ -8,679 +8,684 @@
#include <migraphx/onnx.hpp> #include <migraphx/onnx.hpp>
#include "test.hpp" #include "test.hpp"
TEST_CASE(conv_autopad_fail_test) TEST_CASE(acos_test)
{
EXPECT(test::throws([&] { migraphx::parse_onnx("conv_autopad_fail_test.onnx"); }));
}
TEST_CASE(pytorch_conv_bias_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}}); p.add_instruction(migraphx::op::acos{}, input);
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}});
uint64_t axis = 1; auto prog = migraphx::parse_onnx("acos_test.onnx");
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
p.add_instruction(migraphx::op::add{}, l3, l4);
auto prog = migraphx::parse_onnx("conv.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(pytorch_conv_relu_maxpool) TEST_CASE(add_bcast_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}}); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}}); auto l2 = p.add_instruction(migraphx::op::broadcast{1, l0->get_shape().lens()}, l1);
uint64_t axis = 1; p.add_instruction(migraphx::op::add{}, l0, l2);
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2); auto prog = migraphx::parse_onnx("add_bcast_test.onnx");
auto l5 = p.add_instruction(migraphx::op::add{}, l3, l4);
auto l6 = p.add_instruction(migraphx::op::relu{}, l5);
p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l6);
auto prog = migraphx::parse_onnx("conv_relu_maxpool.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(pytorch_conv_bn_relu_maxpool) TEST_CASE(add_fp16_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}}); auto l0 =
auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}}); p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {1.5}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}}); auto l1 =
p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {2.5}});
auto p3 = p.add_parameter("3", {migraphx::shape::float_type, {1}}); p.add_instruction(migraphx::op::add{}, l0, l1);
auto p4 = p.add_parameter("4", {migraphx::shape::float_type, {1}}); auto prog = migraphx::parse_onnx("add_fp16_test.onnx");
auto p5 = p.add_parameter("5", {migraphx::shape::float_type, {1}});
auto p6 = p.add_parameter("6", {migraphx::shape::float_type, {1}});
uint64_t axis = 1;
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
auto l5 = p.add_instruction(migraphx::op::add{}, l3, l4);
auto l6 = p.add_instruction(migraphx::op::batch_norm_inference{1.0e-5f}, l5, p3, p4, p5, p6);
auto l7 = p.add_instruction(migraphx::op::relu{}, l6);
p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l7);
auto prog = migraphx::parse_onnx("conv_bn_relu_maxpool.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(pytorch_conv_relu_maxpool_x2) TEST_CASE(add_scalar_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {5, 3, 5, 5}}); auto l1 = p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type}, {1}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {5}}); auto m0 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0);
uint64_t axis = 1; auto m1 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1); p.add_instruction(migraphx::op::add{}, m0, m1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2); auto prog = migraphx::parse_onnx("add_scalar_test.onnx");
auto l5 = p.add_instruction(migraphx::op::add{}, l3, l4);
auto l6 = p.add_instruction(migraphx::op::relu{}, l5);
auto l7 = p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l6);
auto l8 = p.add_parameter("3", {migraphx::shape::float_type, {1, 5, 5, 5}});
auto l9 = p.add_parameter("4", {migraphx::shape::float_type, {1}});
auto l10 = p.add_instruction(migraphx::op::convolution{}, l7, l8);
auto l11 = p.add_instruction(migraphx::op::broadcast{axis, l10->get_shape().lens()}, l9);
auto l12 = p.add_instruction(migraphx::op::add{}, l10, l11);
auto l13 = p.add_instruction(migraphx::op::relu{}, l12);
p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l13);
auto prog = migraphx::parse_onnx("conv_relu_maxpoolX2.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(leaky_relu_test) TEST_CASE(argmax_test)
{ {
migraphx::program p; migraphx::program p;
float alpha = 0.01f; auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {3}}); auto ins = p.add_instruction(migraphx::op::argmax{2}, l0);
p.add_instruction(migraphx::op::leaky_relu{alpha}, l0); p.add_instruction(migraphx::op::squeeze{{2}}, ins);
auto prog = migraphx::parse_onnx("argmax_test.onnx");
auto prog = migraphx::parse_onnx("leaky_relu.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(imagescaler_test) TEST_CASE(argmin_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}}; auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l0 = p.add_parameter("0", s); auto ins = p.add_instruction(migraphx::op::argmin{3}, l0);
auto scale_val = p.add_literal(0.5f); p.add_instruction(migraphx::op::squeeze{{3}}, ins);
auto bias_vals = p.add_literal( auto prog = migraphx::parse_onnx("argmin_test.onnx");
migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
auto scaled_tensor = p.add_instruction(migraphx::op::scalar{s.lens()}, scale_val);
auto img_scaled = p.add_instruction(migraphx::op::mul{}, l0, scaled_tensor);
auto bias_bcast = p.add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
auto prog = migraphx::parse_onnx("imagescaler_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(globalavgpool_test) TEST_CASE(asin_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto op = migraphx::op::pooling{"average"}; p.add_instruction(migraphx::op::asin{}, input);
auto lens = input->get_shape().lens();
op.lengths = {lens[2], lens[3]};
p.add_instruction(op, input);
auto prog = migraphx::parse_onnx("globalavgpool_test.onnx"); auto prog = migraphx::parse_onnx("asin_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(globalmaxpool_test) TEST_CASE(atan_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto op = migraphx::op::pooling{"max"}; p.add_instruction(migraphx::op::atan{}, input);
auto lens = input->get_shape().lens();
op.lengths = {lens[2], lens[3]};
p.add_instruction(op, input);
auto prog = migraphx::parse_onnx("globalmaxpool_test.onnx"); auto prog = migraphx::parse_onnx("atan_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(transpose_test) TEST_CASE(cast_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}}); auto l = p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}});
std::vector<int64_t> perm{0, 3, 1, 2}; p.add_instruction(migraphx::op::convert{migraphx::shape::float_type}, l);
p.add_instruction(migraphx::op::transpose{perm}, input);
auto prog = migraphx::parse_onnx("transpose_test.onnx");
auto prog = migraphx::parse_onnx("cast_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(dropout_test) TEST_CASE(clip_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
p.add_instruction(migraphx::op::identity{}, input); p.add_instruction(migraphx::op::clip{6.0, 0.0}, l0);
auto prog = migraphx::parse_onnx("clip_test.onnx");
auto prog = migraphx::parse_onnx("dropout_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sum_test) TEST_CASE(concat_test)
{ {
migraphx::program p; migraphx::program p;
auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 4, 3}});
auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}}); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7, 4, 3}});
auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}}); p.add_instruction(migraphx::op::concat{0}, l0, l1);
auto l0 = p.add_instruction(migraphx::op::add{}, input0, input1); auto prog = migraphx::parse_onnx("concat_test.onnx");
p.add_instruction(migraphx::op::add{}, l0, input2);
auto prog = migraphx::parse_onnx("sum_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(exp_test) TEST_CASE(constant_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0, 1, 2}});
p.add_instruction(migraphx::op::exp{}, input); auto prog = migraphx::parse_onnx("constant_test.onnx");
auto prog = migraphx::parse_onnx("exp_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(erf_test) TEST_CASE(constant_fill_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}}); migraphx::shape s{migraphx::shape::float_type, {2, 3}};
p.add_instruction(migraphx::op::erf{}, input); std::vector<float> value(s.elements(), 1.0);
p.add_literal(migraphx::literal{s, value});
auto prog = migraphx::parse_onnx("constant_fill_test.onnx");
auto prog = migraphx::parse_onnx("erf_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sqrt_test) TEST_CASE(constant_fill_input_as_shape_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}}); auto l0 = p.add_literal(migraphx::literal{{migraphx::shape::int32_type, {2}}, {2, 3}});
p.add_instruction(migraphx::op::sqrt{}, input); std::vector<std::size_t> dims(l0->get_shape().elements());
migraphx::literal ls = l0->get_literal();
ls.visit([&](auto s) { dims.assign(s.begin(), s.end()); });
migraphx::shape s{migraphx::shape::float_type, dims};
std::vector<float> value(s.elements(), 1.0);
p.add_literal(migraphx::literal{s, value});
auto prog = migraphx::parse_onnx("constant_fill_input_as_shape_test.onnx");
auto prog = migraphx::parse_onnx("sqrt_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sign_test) TEST_CASE(constant_scalar_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}}); p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {1}}, {1}});
p.add_instruction(migraphx::op::sign{}, input); auto prog = migraphx::parse_onnx("constant_scalar_test.onnx");
auto prog = migraphx::parse_onnx("sign_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(log_test) TEST_CASE(const_of_shape_empty_input_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); p.add_literal(migraphx::literal());
p.add_instruction(migraphx::op::log{}, input); migraphx::shape s(migraphx::shape::int64_type, {1}, {0});
std::vector<int64_t> vec(s.elements(), 10);
p.add_literal(migraphx::literal(s, vec));
auto prog = migraphx::parse_onnx("log_test.onnx"); auto prog = migraphx::parse_onnx("const_of_shape_empty_input_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sin_test) TEST_CASE(const_of_shape_float_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); migraphx::shape ss(migraphx::shape::int32_type, {3});
p.add_instruction(migraphx::op::sin{}, input); p.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);
p.add_literal(migraphx::literal(s, vec));
auto prog = migraphx::parse_onnx("sin_test.onnx"); auto prog = migraphx::parse_onnx("const_of_shape_float_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(cos_test) TEST_CASE(const_of_shape_int64_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); migraphx::shape ss(migraphx::shape::int32_type, {3});
p.add_instruction(migraphx::op::cos{}, input); p.add_literal(migraphx::literal(ss, {2, 3, 4}));
migraphx::shape s(migraphx::shape::int64_type, {2, 3, 4});
std::vector<int64_t> vec(s.elements(), 10);
p.add_literal(migraphx::literal(s, vec));
auto prog = migraphx::parse_onnx("cos_test.onnx"); auto prog = migraphx::parse_onnx("const_of_shape_int64_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(tan_test) TEST_CASE(const_of_shape_no_value_attr_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); migraphx::shape ss(migraphx::shape::int32_type, {3});
p.add_instruction(migraphx::op::tan{}, input); p.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);
p.add_literal(migraphx::literal(s, vec));
auto prog = migraphx::parse_onnx("tan_test.onnx"); auto prog = migraphx::parse_onnx("const_of_shape_no_value_attr_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sinh_test) TEST_CASE(conv_autopad_fail_test)
{ {
migraphx::program p; EXPECT(test::throws([&] { migraphx::parse_onnx("conv_autopad_fail_test.onnx"); }));
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
p.add_instruction(migraphx::op::sinh{}, input);
auto prog = migraphx::parse_onnx("sinh_test.onnx");
EXPECT(p == prog);
} }
TEST_CASE(cosh_test) TEST_CASE(conv_bias_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}}); auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
p.add_instruction(migraphx::op::cosh{}, input); auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}});
auto prog = migraphx::parse_onnx("cosh_test.onnx"); uint64_t axis = 1;
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
p.add_instruction(migraphx::op::add{}, l3, l4);
auto prog = migraphx::parse_onnx("conv_bias_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(tanh_test) TEST_CASE(conv_bn_relu_maxpool_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}}); auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
p.add_instruction(migraphx::op::tanh{}, input); auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}});
auto prog = migraphx::parse_onnx("tanh_test.onnx"); auto p3 = p.add_parameter("3", {migraphx::shape::float_type, {1}});
auto p4 = p.add_parameter("4", {migraphx::shape::float_type, {1}});
auto p5 = p.add_parameter("5", {migraphx::shape::float_type, {1}});
auto p6 = p.add_parameter("6", {migraphx::shape::float_type, {1}});
uint64_t axis = 1;
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
auto l5 = p.add_instruction(migraphx::op::add{}, l3, l4);
auto l6 = p.add_instruction(migraphx::op::batch_norm_inference{1.0e-5f}, l5, p3, p4, p5, p6);
auto l7 = p.add_instruction(migraphx::op::relu{}, l6);
p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l7);
auto prog = migraphx::parse_onnx("conv_bn_relu_maxpool_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(elu_test) TEST_CASE(conv_relu_maxpool_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}}); auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
p.add_instruction(migraphx::op::elu{0.01}, input); auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {1, 3, 5, 5}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {1}});
auto prog = migraphx::parse_onnx("elu_test.onnx"); uint64_t axis = 1;
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
auto l5 = p.add_instruction(migraphx::op::add{}, l3, l4);
auto l6 = p.add_instruction(migraphx::op::relu{}, l5);
p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l6);
auto prog = migraphx::parse_onnx("conv_relu_maxpool_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(asin_test) TEST_CASE(conv_relu_maxpool_x2_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {1, 3, 32, 32}});
p.add_instruction(migraphx::op::asin{}, input); auto l1 = p.add_parameter("1", {migraphx::shape::float_type, {5, 3, 5, 5}});
auto l2 = p.add_parameter("2", {migraphx::shape::float_type, {5}});
uint64_t axis = 1;
auto l3 = p.add_instruction(migraphx::op::convolution{}, l0, l1);
auto l4 = p.add_instruction(migraphx::op::broadcast{axis, l3->get_shape().lens()}, l2);
auto l5 = p.add_instruction(migraphx::op::add{}, l3, l4);
auto l6 = p.add_instruction(migraphx::op::relu{}, l5);
auto l7 = p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l6);
auto prog = migraphx::parse_onnx("asin_test.onnx"); auto l8 = p.add_parameter("3", {migraphx::shape::float_type, {1, 5, 5, 5}});
auto l9 = p.add_parameter("4", {migraphx::shape::float_type, {1}});
auto l10 = p.add_instruction(migraphx::op::convolution{}, l7, l8);
auto l11 = p.add_instruction(migraphx::op::broadcast{axis, l10->get_shape().lens()}, l9);
auto l12 = p.add_instruction(migraphx::op::add{}, l10, l11);
auto l13 = p.add_instruction(migraphx::op::relu{}, l12);
p.add_instruction(migraphx::op::pooling{"max", {{0, 0}}, {{2, 2}}, {{2, 2}}}, l13);
auto prog = migraphx::parse_onnx("conv_relu_maxpool_x2_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(max_test) TEST_CASE(cos_test)
{ {
migraphx::program p; migraphx::program p;
auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}}); p.add_instruction(migraphx::op::cos{}, input);
auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
auto l0 = p.add_instruction(migraphx::op::max{}, input0, input1);
p.add_instruction(migraphx::op::max{}, l0, input2);
migraphx::parse_onnx("max_test.onnx"); auto prog = migraphx::parse_onnx("cos_test.onnx");
EXPECT(p == prog);
} }
TEST_CASE(acos_test) TEST_CASE(cosh_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
p.add_instruction(migraphx::op::acos{}, input); p.add_instruction(migraphx::op::cosh{}, input);
auto prog = migraphx::parse_onnx("acos_test.onnx"); auto prog = migraphx::parse_onnx("cosh_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(min_test) TEST_CASE(dropout_test)
{ {
migraphx::program p; migraphx::program p;
auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}}); auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 2, 2}});
auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}}); p.add_instruction(migraphx::op::identity{}, input);
auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
auto l0 = p.add_instruction(migraphx::op::min{}, input0, input1);
p.add_instruction(migraphx::op::min{}, l0, input2);
migraphx::parse_onnx("min_test.onnx"); auto prog = migraphx::parse_onnx("dropout_test.onnx");
EXPECT(p == prog);
} }
TEST_CASE(atan_test) TEST_CASE(elu_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}}); auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
p.add_instruction(migraphx::op::atan{}, input); p.add_instruction(migraphx::op::elu{0.01}, input);
auto prog = migraphx::parse_onnx("atan_test.onnx"); auto prog = migraphx::parse_onnx("elu_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(add_bcast_test) TEST_CASE(erf_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}}); p.add_instruction(migraphx::op::erf{}, input);
auto l2 = p.add_instruction(migraphx::op::broadcast{1, l0->get_shape().lens()}, l1);
p.add_instruction(migraphx::op::add{}, l0, l2);
auto prog = migraphx::parse_onnx("add_bcast_test.onnx");
auto prog = migraphx::parse_onnx("erf_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(implicit_add_bcast_test) TEST_CASE(exp_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}}); p.add_instruction(migraphx::op::exp{}, input);
auto l2 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0);
auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
p.add_instruction(migraphx::op::add{}, l2, l3);
auto prog = migraphx::parse_onnx("implicit_bcast_test.onnx");
auto prog = migraphx::parse_onnx("exp_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sub_bcast_test) TEST_CASE(expand_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); migraphx::shape s(migraphx::shape::float_type, {3, 1, 1});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}}); auto param = p.add_parameter("x", s);
auto l2 = p.add_instruction(migraphx::op::broadcast{1, l0->get_shape().lens()}, l1); migraphx::shape ss(migraphx::shape::int32_type, {4});
p.add_instruction(migraphx::op::sub{}, l0, l2); p.add_literal(migraphx::literal(ss, {2, 3, 4, 5}));
p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, param);
auto prog = migraphx::parse_onnx("sub_bcast_test.onnx");
auto prog = migraphx::parse_onnx("expand_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(implicit_sub_bcast_test) TEST_CASE(flatten_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5}}); p.add_instruction(migraphx::op::flatten{2}, l0);
auto l2 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0); p.add_instruction(migraphx::op::flatten{1}, l0);
auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1); auto prog = migraphx::parse_onnx("flatten_test.onnx");
p.add_instruction(migraphx::op::sub{}, l2, l3);
auto prog = migraphx::parse_onnx("implicit_sub_bcast_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(unknown_test) TEST_CASE(gather_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}}); auto l1 = p.add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 3}});
auto l2 = p.add_instruction(migraphx::op::unknown{"Unknown"}, l0, l1); int axis = 1;
p.add_instruction(migraphx::op::unknown{"Unknown"}, l2); p.add_instruction(migraphx::op::gather{axis}, l0, l1);
auto prog = migraphx::parse_onnx("unknown_test.onnx"); auto prog = migraphx::parse_onnx("gather_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(softmax_test) TEST_CASE(gemm_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 7}});
p.add_instruction(migraphx::op::softmax{1}, l0); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {11, 5}});
auto prog = migraphx::parse_onnx("softmax_test.onnx"); p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {}});
auto t0 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l0);
auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l1);
auto alpha = 2.f;
auto beta = 2.0f;
p.add_instruction(migraphx::op::dot{alpha, beta}, t0, t1);
auto prog = migraphx::parse_onnx("gemm_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reshape_test) TEST_CASE(gemm_ex_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::op::reshape op; auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}});
std::vector<int64_t> reshape_dims{3, 8}; auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}});
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}}); auto l2 = p.add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 7}});
p.add_literal( auto t0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims}); auto alpha = 0.5f;
op.dims = reshape_dims; auto beta = 0.8f;
p.add_instruction(op, l0); p.add_instruction(migraphx::op::dot{alpha, beta}, t0, l1, l2);
p.add_instruction(op, l0); auto prog = migraphx::parse_onnx("gemm_ex_test.onnx");
auto prog = migraphx::parse_onnx("reshape_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reshape_non_standard) TEST_CASE(gemm_ex_brcst_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::op::reshape op; auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}});
std::vector<int64_t> reshape_dims{4, 3, 2}; auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}});
migraphx::shape s{migraphx::shape::float_type, {2, 3, 4}}; auto l2 = p.add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 1}});
auto x = p.add_parameter("x", s); auto t0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0);
auto tran_x = p.add_instruction(migraphx::op::transpose{{0, 2, 1}}, x); std::vector<std::size_t> out_lens{1, 1, 6, 7};
auto cont_x = p.add_instruction(migraphx::op::contiguous{}, tran_x); auto t2 = p.add_instruction(migraphx::op::multibroadcast{out_lens}, l2);
p.add_instruction(migraphx::op::reshape{{4, 3, 2}}, cont_x); auto alpha = 0.5f;
auto prog = migraphx::parse_onnx("reshape_non_standard.onnx"); auto beta = 0.8f;
p.add_instruction(migraphx::op::dot{alpha, beta}, t0, l1, t2);
auto prog = migraphx::parse_onnx("gemm_ex_brcst_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(shape_test) TEST_CASE(globalavgpool_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}}; auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
auto l0 = p.add_parameter("x", s); auto op = migraphx::op::pooling{"average"};
migraphx::shape s_shape{migraphx::shape::int64_type, {4}}; auto lens = input->get_shape().lens();
p.add_literal(s_shape, l0->get_shape().lens()); op.lengths = {lens[2], lens[3]};
auto prog = migraphx::parse_onnx("shape_test.onnx"); p.add_instruction(op, input);
auto prog = migraphx::parse_onnx("globalavgpool_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(gather_test) TEST_CASE(globalmaxpool_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 16, 16}});
auto l1 = p.add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 3}}); auto op = migraphx::op::pooling{"max"};
int axis = 1; auto lens = input->get_shape().lens();
p.add_instruction(migraphx::op::gather{axis}, l0, l1); op.lengths = {lens[2], lens[3]};
auto prog = migraphx::parse_onnx("gather_test.onnx"); p.add_instruction(op, input);
auto prog = migraphx::parse_onnx("globalmaxpool_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(shape_gather_test) TEST_CASE(group_conv_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 4, 16, 16}});
auto l1 = auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 1, 3, 3}});
p.add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens()); migraphx::op::convolution op;
migraphx::shape const_shape{migraphx::shape::int32_type, {1}}; op.group = 4;
auto l2 = p.add_literal(migraphx::literal{const_shape, {1}}); p.add_instruction(op, l0, l1);
int axis = 0; auto prog = migraphx::parse_onnx("group_conv_test.onnx");
p.add_instruction(migraphx::op::gather{axis}, l1, l2);
auto prog = migraphx::parse_onnx("shape_gather.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(transpose_gather_test) TEST_CASE(imagescaler_test)
{ {
migraphx::program p; migraphx::program p;
auto make_contiguous = [&p](migraphx::instruction_ref ins) { migraphx::shape s{migraphx::shape::float_type, {1, 3, 16, 16}};
if(ins->get_shape().standard()) auto l0 = p.add_parameter("0", s);
{ auto scale_val = p.add_literal(0.5f);
return ins; auto bias_vals = p.add_literal(
} migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0.01, 0.02, 0.03}});
auto scaled_tensor = p.add_instruction(migraphx::op::scalar{s.lens()}, scale_val);
auto img_scaled = p.add_instruction(migraphx::op::mul{}, l0, scaled_tensor);
auto bias_bcast = p.add_instruction(migraphx::op::broadcast{1, s.lens()}, bias_vals);
p.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
return p.add_instruction(migraphx::op::contiguous{}, ins); auto prog = migraphx::parse_onnx("imagescaler_test.onnx");
};
auto data = p.add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}}); EXPECT(p == prog);
auto ind = }
p.add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
auto tr_data = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3}}, data);
auto tr_ind = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3}}, ind);
int axis = 1;
p.add_instruction(
migraphx::op::gather{axis}, make_contiguous(tr_data), make_contiguous(tr_ind));
auto prog = migraphx::parse_onnx("transpose_gather.onnx"); TEST_CASE(implicit_add_bcast_test)
{
migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}});
auto l2 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0);
auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
p.add_instruction(migraphx::op::add{}, l2, l3);
auto prog = migraphx::parse_onnx("implicit_add_bcast_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(flatten_test) TEST_CASE(implicit_pow_bcast_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
p.add_instruction(migraphx::op::flatten{2}, l0); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}});
p.add_instruction(migraphx::op::flatten{1}, l0); auto l2 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0);
auto prog = migraphx::parse_onnx("flatten_test.onnx"); auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
p.add_instruction(migraphx::op::pow{}, l2, l3);
auto prog = migraphx::parse_onnx("implicit_pow_bcast_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(squeeze_unsqueeze_test) TEST_CASE(implicit_sub_bcast_test)
{ {
migraphx::program p; migraphx::program p;
std::vector<int64_t> squeeze_axes{0, 2, 3, 5}; auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
std::vector<int64_t> unsqueeze_axes{0, 1, 3, 5}; auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 5}});
auto l0 = auto l2 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0);
p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}}); auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
auto l1 = p.add_instruction(migraphx::op::squeeze{squeeze_axes}, l0); p.add_instruction(migraphx::op::sub{}, l2, l3);
p.add_instruction(migraphx::op::unsqueeze{unsqueeze_axes}, l1);
auto prog = migraphx::parse_onnx("squeeze_unsqueeze_test.onnx"); auto prog = migraphx::parse_onnx("implicit_sub_bcast_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(concat_test) TEST_CASE(leaky_relu_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 4, 3}}); float alpha = 0.01f;
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7, 4, 3}}); auto l0 = p.add_parameter("0", {migraphx::shape::float_type, {3}});
p.add_instruction(migraphx::op::concat{0}, l0, l1); p.add_instruction(migraphx::op::leaky_relu{alpha}, l0);
auto prog = migraphx::parse_onnx("concat_test.onnx");
auto prog = migraphx::parse_onnx("leaky_relu_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(slice_test) TEST_CASE(log_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
p.add_instruction(migraphx::op::slice{{0, 1}, {1, 0}, {2, 2}}, l0); p.add_instruction(migraphx::op::log{}, input);
auto prog = migraphx::parse_onnx("slice_test.onnx");
auto prog = migraphx::parse_onnx("log_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(constant_test) TEST_CASE(logsoftmax_test)
{ {
migraphx::program p; migraphx::program p;
p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type, {3}}, {0, 1, 2}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto prog = migraphx::parse_onnx("constant_test.onnx"); int axis = 1;
p.add_instruction(migraphx::op::logsoftmax{axis}, l0);
auto prog = migraphx::parse_onnx("logsoftmax_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(constant_test_scalar) TEST_CASE(lrn_test)
{ {
migraphx::program p; migraphx::program p;
p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::int32_type, {1}}, {1}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 28, 24, 24}});
auto prog = migraphx::parse_onnx("constant_scalar.onnx"); migraphx::op::lrn op;
op.size = 5;
op.alpha = 0.0001;
op.beta = 0.75;
op.bias = 1.0;
p.add_instruction(op, l0);
auto prog = migraphx::parse_onnx("lrn_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(constant_fill_test) TEST_CASE(matmul_bmbm_test)
{ {
{ migraphx::program p;
migraphx::program p; auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}});
auto l0 = p.add_literal(migraphx::literal{{migraphx::shape::int32_type, {2}}, {2, 3}}); auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 2, 1, 7, 8}});
std::vector<std::size_t> dims(l0->get_shape().elements()); auto bl0 = p.add_instruction(migraphx::op::multibroadcast{{5, 2, 3, 6, 7}}, l0);
migraphx::literal ls = l0->get_literal(); auto bl1 = p.add_instruction(migraphx::op::multibroadcast{{5, 2, 3, 7, 8}}, l1);
ls.visit([&](auto s) { dims.assign(s.begin(), s.end()); }); p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, bl0, bl1);
migraphx::shape s{migraphx::shape::float_type, dims};
std::vector<float> value(s.elements(), 1.0);
p.add_literal(migraphx::literal{s, value});
auto prog = migraphx::parse_onnx("const_fill1.onnx");
EXPECT(p == prog); auto prog = migraphx::parse_onnx("matmul_bmbm_test.onnx");
}
EXPECT(p == prog);
}
TEST_CASE(matmul_bmv_test)
{
migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
auto sl1 = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1);
auto bsl1 = p.add_instruction(migraphx::op::multibroadcast{{3, 7, 1}}, sl1);
auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, l0, bsl1);
p.add_instruction(migraphx::op::squeeze{{2}}, res);
{ auto prog = migraphx::parse_onnx("matmul_bmv_test.onnx");
migraphx::program p;
migraphx::shape s{migraphx::shape::float_type, {2, 3}};
std::vector<float> value(s.elements(), 1.0);
p.add_literal(migraphx::literal{s, value});
auto prog = migraphx::parse_onnx("const_fill2.onnx");
EXPECT(p == prog); EXPECT(p == prog);
}
} }
TEST_CASE(gemm_test) TEST_CASE(matmul_mv_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {5, 7}}); auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {6, 7}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {11, 5}}); auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}});
p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {}}); auto sl1 = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1);
auto t0 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l0); auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, l0, sl1);
auto t1 = p.add_instruction(migraphx::op::transpose{{1, 0}}, l1); p.add_instruction(migraphx::op::squeeze{{1}}, res);
auto alpha = 2.f;
auto beta = 2.0f; auto prog = migraphx::parse_onnx("matmul_mv_test.onnx");
p.add_instruction(migraphx::op::dot{alpha, beta}, t0, t1);
auto prog = migraphx::parse_onnx("gemm_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(gemm_ex) TEST_CASE(matmul_vbm_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}}); auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}}); auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 7, 8}});
auto l2 = p.add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 7}}); auto sl0 = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0);
auto t0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0); auto bsl0 = p.add_instruction(migraphx::op::multibroadcast{{5, 1, 7}}, sl0);
auto alpha = 0.5f; std::cout << "ONNX_TEST" << std::endl;
auto beta = 0.8f; auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, bsl0, l1);
p.add_instruction(migraphx::op::dot{alpha, beta}, t0, l1, l2); std::cout << "After Dot" << std::endl;
auto prog = migraphx::parse_onnx("gemm_test_ex.onnx"); p.add_instruction(migraphx::op::squeeze{{1}}, res);
auto prog = migraphx::parse_onnx("matmul_vbm_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(gemm_ex_brcst) TEST_CASE(matmul_vm_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 6}}); auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 7}}); auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7, 8}});
auto l2 = p.add_parameter("3", migraphx::shape{migraphx::shape::float_type, {1, 1, 6, 1}}); auto sl0 = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0);
auto t0 = p.add_instruction(migraphx::op::transpose{{0, 1, 3, 2}}, l0); auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, sl0, l1);
std::vector<std::size_t> out_lens{1, 1, 6, 7}; p.add_instruction(migraphx::op::squeeze{{0}}, res);
auto t2 = p.add_instruction(migraphx::op::multibroadcast{out_lens}, l2);
auto alpha = 0.5f; auto prog = migraphx::parse_onnx("matmul_vm_test.onnx");
auto beta = 0.8f;
p.add_instruction(migraphx::op::dot{alpha, beta}, t0, l1, t2);
auto prog = migraphx::parse_onnx("gemm_test_ex1.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(matmul_vv) TEST_CASE(matmul_vv_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}}); auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}});
...@@ -691,376 +696,371 @@ TEST_CASE(matmul_vv) ...@@ -691,376 +696,371 @@ TEST_CASE(matmul_vv)
auto sr0 = p.add_instruction(migraphx::op::squeeze{{0}}, res); auto sr0 = p.add_instruction(migraphx::op::squeeze{{0}}, res);
p.add_instruction(migraphx::op::squeeze{{0}}, sr0); p.add_instruction(migraphx::op::squeeze{{0}}, sr0);
auto prog = migraphx::parse_onnx("matmul_vv.onnx"); auto prog = migraphx::parse_onnx("matmul_vv_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(matmul_vm) TEST_CASE(max_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}}); auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7, 8}}); auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
auto sl0 = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0); auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, sl0, l1); auto l0 = p.add_instruction(migraphx::op::max{}, input0, input1);
p.add_instruction(migraphx::op::squeeze{{0}}, res); p.add_instruction(migraphx::op::max{}, l0, input2);
auto prog = migraphx::parse_onnx("matmul_vm.onnx");
EXPECT(p == prog); migraphx::parse_onnx("max_test.onnx");
} }
TEST_CASE(matmul_vbm) TEST_CASE(min_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {7}}); auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 7, 8}}); auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
auto sl0 = p.add_instruction(migraphx::op::unsqueeze{{0}}, l0); auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
auto bsl0 = p.add_instruction(migraphx::op::multibroadcast{{5, 1, 7}}, sl0); auto l0 = p.add_instruction(migraphx::op::min{}, input0, input1);
std::cout << "ONNX_TEST" << std::endl; p.add_instruction(migraphx::op::min{}, l0, input2);
auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, bsl0, l1);
std::cout << "After Dot" << std::endl; migraphx::parse_onnx("min_test.onnx");
p.add_instruction(migraphx::op::squeeze{{1}}, res); }
auto prog = migraphx::parse_onnx("matmul_vbm.onnx"); TEST_CASE(no_pad_test)
{
migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
p.add_instruction(migraphx::op::identity{}, l0);
auto prog = migraphx::parse_onnx("no_pad_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(matmul_mv) TEST_CASE(pad_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {6, 7}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}}); p.add_instruction(migraphx::op::pad{{1, 1, 1, 1}}, l0);
auto sl1 = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1); auto prog = migraphx::parse_onnx("pad_test.onnx");
auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, l0, sl1);
p.add_instruction(migraphx::op::squeeze{{1}}, res);
auto prog = migraphx::parse_onnx("matmul_mv.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(matmul_bmv) TEST_CASE(pow_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {7}}); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto sl1 = p.add_instruction(migraphx::op::unsqueeze{{1}}, l1); p.add_instruction(migraphx::op::pow{}, l0, l1);
auto bsl1 = p.add_instruction(migraphx::op::multibroadcast{{3, 7, 1}}, sl1);
auto res = p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, l0, bsl1);
p.add_instruction(migraphx::op::squeeze{{2}}, res);
auto prog = migraphx::parse_onnx("matmul_bmv.onnx"); auto prog = migraphx::parse_onnx("pow_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(matmul_bmbm) TEST_CASE(reducemean_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 6, 7}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l1 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {5, 2, 1, 7, 8}}); auto l1 = p.add_instruction(migraphx::op::reduce_mean{{2, 3}}, l0);
auto bl0 = p.add_instruction(migraphx::op::multibroadcast{{5, 2, 3, 6, 7}}, l0); p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1);
auto bl1 = p.add_instruction(migraphx::op::multibroadcast{{5, 2, 3, 7, 8}}, l1); auto prog = migraphx::parse_onnx("reducemean_test.onnx");
p.add_instruction(migraphx::op::dot{1.0f, 0.0f}, bl0, bl1);
auto prog = migraphx::parse_onnx("matmul_bmbm.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(add_scalar_test) TEST_CASE(reducemean_keepdims_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l1 = p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type}, {1}}); p.add_instruction(migraphx::op::reduce_mean{{2}}, l0);
auto m0 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0); auto prog = migraphx::parse_onnx("reducemean_keepdims_test.onnx");
auto m1 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
p.add_instruction(migraphx::op::add{}, m0, m1);
auto prog = migraphx::parse_onnx("add_scalar_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(sub_scalar_test) TEST_CASE(reducesum_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l1 = auto l1 = p.add_instruction(migraphx::op::reduce_sum{{2}}, l0);
p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type, {1}}, {1}}); p.add_instruction(migraphx::op::squeeze{{2}}, l1);
auto m0 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0); auto prog = migraphx::parse_onnx("reducesum_test.onnx");
auto m1 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
p.add_instruction(migraphx::op::sub{}, m0, m1);
auto prog = migraphx::parse_onnx("sub_scalar_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(group_conv_test) TEST_CASE(reducesum_multiaxis_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 4, 16, 16}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {4, 1, 3, 3}}); auto l1 = p.add_instruction(migraphx::op::reduce_sum{{2, 3}}, l0);
migraphx::op::convolution op; p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1);
op.group = 4; auto prog = migraphx::parse_onnx("reducesum_multiaxis_test.onnx");
p.add_instruction(op, l0, l1);
auto prog = migraphx::parse_onnx("group_conv_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(pad_test) TEST_CASE(reducesum_keepdims_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}});
p.add_instruction(migraphx::op::pad{{1, 1, 1, 1}}, l0); p.add_instruction(migraphx::op::reduce_sum{{2, 3}}, l0);
auto prog = migraphx::parse_onnx("pad_test.onnx"); auto prog = migraphx::parse_onnx("reducesum_keepdims_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(lrn_test) TEST_CASE(reshape_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 28, 24, 24}}); migraphx::op::reshape op;
migraphx::op::lrn op; std::vector<int64_t> reshape_dims{3, 8};
op.size = 5; auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {4, 2, 3}});
op.alpha = 0.0001; p.add_literal(
op.beta = 0.75; migraphx::literal{migraphx::shape{migraphx::shape::int64_type, {2}}, reshape_dims});
op.bias = 1.0; op.dims = reshape_dims;
p.add_instruction(op, l0); p.add_instruction(op, l0);
auto prog = migraphx::parse_onnx("lrn_test.onnx"); p.add_instruction(op, l0);
auto prog = migraphx::parse_onnx("reshape_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(add_fp16_test) TEST_CASE(reshape_non_standard_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = migraphx::op::reshape op;
p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {1.5}}); std::vector<int64_t> reshape_dims{4, 3, 2};
auto l1 = migraphx::shape s{migraphx::shape::float_type, {2, 3, 4}};
p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::half_type, {1}}, {2.5}}); auto x = p.add_parameter("x", s);
p.add_instruction(migraphx::op::add{}, l0, l1); auto tran_x = p.add_instruction(migraphx::op::transpose{{0, 2, 1}}, x);
auto prog = migraphx::parse_onnx("add_fp16_test.onnx"); auto cont_x = p.add_instruction(migraphx::op::contiguous{}, tran_x);
p.add_instruction(migraphx::op::reshape{{4, 3, 2}}, cont_x);
auto prog = migraphx::parse_onnx("reshape_non_standard_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(logsoftmax) TEST_CASE(round_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
int axis = 1; p.add_instruction(migraphx::op::round{}, input);
p.add_instruction(migraphx::op::logsoftmax{axis}, l0);
auto prog = migraphx::parse_onnx("logsoftmax_test.onnx");
auto prog = migraphx::parse_onnx("round_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(argmax) TEST_CASE(shape_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); migraphx::shape s{migraphx::shape::float_type, {3, 4, 5, 6}};
auto ins = p.add_instruction(migraphx::op::argmax{2}, l0); auto l0 = p.add_parameter("x", s);
p.add_instruction(migraphx::op::squeeze{{2}}, ins); migraphx::shape s_shape{migraphx::shape::int64_type, {4}};
auto prog = migraphx::parse_onnx("argmax_test.onnx"); p.add_literal(s_shape, l0->get_shape().lens());
auto prog = migraphx::parse_onnx("shape_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(argmin) TEST_CASE(shape_gather_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {7, 3, 10}});
auto ins = p.add_instruction(migraphx::op::argmin{3}, l0); auto l1 =
p.add_instruction(migraphx::op::squeeze{{3}}, ins); p.add_literal(migraphx::shape{migraphx::shape::int64_type, {3}}, l0->get_shape().lens());
auto prog = migraphx::parse_onnx("argmin_test.onnx"); migraphx::shape const_shape{migraphx::shape::int32_type, {1}};
auto l2 = p.add_literal(migraphx::literal{const_shape, {1}});
int axis = 0;
p.add_instruction(migraphx::op::gather{axis}, l1, l2);
auto prog = migraphx::parse_onnx("shape_gather_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(no_pad_test) TEST_CASE(sign_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 2}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}});
p.add_instruction(migraphx::op::identity{}, l0); p.add_instruction(migraphx::op::sign{}, input);
auto prog = migraphx::parse_onnx("no_pad_test.onnx");
auto prog = migraphx::parse_onnx("sign_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reducesum_test1) TEST_CASE(sin_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto l1 = p.add_instruction(migraphx::op::reduce_sum{{2}}, l0); p.add_instruction(migraphx::op::sin{}, input);
p.add_instruction(migraphx::op::squeeze{{2}}, l1);
auto prog = migraphx::parse_onnx("reducesum_test1.onnx");
auto prog = migraphx::parse_onnx("sin_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reducesum_test2) TEST_CASE(sinh_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
auto l1 = p.add_instruction(migraphx::op::reduce_sum{{2, 3}}, l0); p.add_instruction(migraphx::op::sinh{}, input);
p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1);
auto prog = migraphx::parse_onnx("reducesum_test2.onnx"); auto prog = migraphx::parse_onnx("sinh_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reducesum_test3) TEST_CASE(slice_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3, 2}});
p.add_instruction(migraphx::op::reduce_sum{{2, 3}}, l0); p.add_instruction(migraphx::op::slice{{0, 1}, {1, 0}, {2, 2}}, l0);
auto prog = migraphx::parse_onnx("reducesum_test3.onnx"); auto prog = migraphx::parse_onnx("slice_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reducemean_test1) TEST_CASE(softmax_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3}});
auto l1 = p.add_instruction(migraphx::op::reduce_mean{{2, 3}}, l0); p.add_instruction(migraphx::op::softmax{1}, l0);
p.add_instruction(migraphx::op::squeeze{{2, 3}}, l1); auto prog = migraphx::parse_onnx("softmax_test.onnx");
auto prog = migraphx::parse_onnx("reducemean_test1.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(reducemean_test2) TEST_CASE(sqrt_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {3, 4, 5, 6}}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10, 15}});
p.add_instruction(migraphx::op::reduce_mean{{2}}, l0); p.add_instruction(migraphx::op::sqrt{}, input);
auto prog = migraphx::parse_onnx("reducemean_test2.onnx");
auto prog = migraphx::parse_onnx("sqrt_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(clip_test) TEST_CASE(squeeze_unsqueeze_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}}); std::vector<int64_t> squeeze_axes{0, 2, 3, 5};
p.add_instruction(migraphx::op::clip{6.0, 0.0}, l0); std::vector<int64_t> unsqueeze_axes{0, 1, 3, 5};
auto prog = migraphx::parse_onnx("clip_test.onnx"); auto l0 =
p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 3, 1, 1, 2, 1}});
auto l1 = p.add_instruction(migraphx::op::squeeze{squeeze_axes}, l0);
p.add_instruction(migraphx::op::unsqueeze{unsqueeze_axes}, l1);
auto prog = migraphx::parse_onnx("squeeze_unsqueeze_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(implicit_pow_bcast_test) TEST_CASE(sub_bcast_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4, 1}}); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
auto l2 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0); auto l2 = p.add_instruction(migraphx::op::broadcast{1, l0->get_shape().lens()}, l1);
auto l3 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1); p.add_instruction(migraphx::op::sub{}, l0, l2);
p.add_instruction(migraphx::op::pow{}, l2, l3);
auto prog = migraphx::parse_onnx("pow_bcast_test.onnx"); auto prog = migraphx::parse_onnx("sub_bcast_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(pow_test) TEST_CASE(sub_scalar_test)
{ {
migraphx::program p; migraphx::program p;
auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}}); auto l1 =
p.add_instruction(migraphx::op::pow{}, l0, l1); p.add_literal(migraphx::literal{migraphx::shape{migraphx::shape::float_type, {1}}, {1}});
auto m0 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l0);
auto prog = migraphx::parse_onnx("pow_bcast_test1.onnx"); auto m1 = p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, l1);
p.add_instruction(migraphx::op::sub{}, m0, m1);
auto prog = migraphx::parse_onnx("sub_scalar_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(cast_test) TEST_CASE(sum_test)
{ {
migraphx::program p; migraphx::program p;
auto l = p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {10}}); auto input0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {3}});
p.add_instruction(migraphx::op::convert{migraphx::shape::float_type}, l); auto input1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3}});
auto input2 = p.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {3}});
auto l0 = p.add_instruction(migraphx::op::add{}, input0, input1);
p.add_instruction(migraphx::op::add{}, l0, input2);
auto prog = migraphx::parse_onnx("cast_test.onnx"); auto prog = migraphx::parse_onnx("sum_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(const_of_shape_float) TEST_CASE(tan_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::shape ss(migraphx::shape::int32_type, {3}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {10}});
p.add_literal(migraphx::literal(ss, {2, 3, 4})); p.add_instruction(migraphx::op::tan{}, input);
migraphx::shape s(migraphx::shape::float_type, {2, 3, 4});
std::vector<float> vec(s.elements(), 10.0f);
p.add_literal(migraphx::literal(s, vec));
auto prog = migraphx::parse_onnx("const_of_shape1.onnx"); auto prog = migraphx::parse_onnx("tan_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(const_of_shape_int64) TEST_CASE(tanh_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::shape ss(migraphx::shape::int32_type, {3}); auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1}});
p.add_literal(migraphx::literal(ss, {2, 3, 4})); p.add_instruction(migraphx::op::tanh{}, input);
migraphx::shape s(migraphx::shape::int64_type, {2, 3, 4});
std::vector<int64_t> vec(s.elements(), 10); auto prog = migraphx::parse_onnx("tanh_test.onnx");
p.add_literal(migraphx::literal(s, vec));
auto prog = migraphx::parse_onnx("const_of_shape2.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(const_of_shape_no_value_attr) TEST_CASE(transpose_test)
{ {
migraphx::program p; migraphx::program p;
migraphx::shape ss(migraphx::shape::int32_type, {3}); auto input = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 2, 3}});
p.add_literal(migraphx::literal(ss, {2, 3, 4})); std::vector<int64_t> perm{0, 3, 1, 2};
migraphx::shape s(migraphx::shape::float_type, {2, 3, 4}); p.add_instruction(migraphx::op::transpose{perm}, input);
std::vector<float> vec(s.elements(), 0.0f);
p.add_literal(migraphx::literal(s, vec)); auto prog = migraphx::parse_onnx("transpose_test.onnx");
auto prog = migraphx::parse_onnx("const_of_shape3.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(const_of_shape_empty_input) TEST_CASE(transpose_gather_test)
{ {
migraphx::program p; migraphx::program p;
p.add_literal(migraphx::literal()); auto make_contiguous = [&p](migraphx::instruction_ref ins) {
migraphx::shape s(migraphx::shape::int64_type, {1}, {0}); if(ins->get_shape().standard())
std::vector<int64_t> vec(s.elements(), 10); {
p.add_literal(migraphx::literal(s, vec)); return ins;
}
auto prog = migraphx::parse_onnx("const_of_shape4.onnx"); return p.add_instruction(migraphx::op::contiguous{}, ins);
EXPECT(p == prog); };
}
TEST_CASE(expand_test) auto data = p.add_parameter("data", migraphx::shape{migraphx::shape::float_type, {3, 5, 4, 6}});
{ auto ind =
migraphx::program p; p.add_parameter("indices", migraphx::shape{migraphx::shape::int32_type, {2, 4, 3, 5}});
migraphx::shape s(migraphx::shape::float_type, {3, 1, 1}); auto tr_data = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3}}, data);
auto param = p.add_parameter("x", s); auto tr_ind = p.add_instruction(migraphx::op::transpose{{0, 2, 1, 3}}, ind);
migraphx::shape ss(migraphx::shape::int32_type, {4}); int axis = 1;
p.add_literal(migraphx::literal(ss, {2, 3, 4, 5})); p.add_instruction(
p.add_instruction(migraphx::op::multibroadcast{{2, 3, 4, 5}}, param); migraphx::op::gather{axis}, make_contiguous(tr_data), make_contiguous(tr_ind));
auto prog = migraphx::parse_onnx("transpose_gather_test.onnx");
auto prog = migraphx::parse_onnx("expand_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
TEST_CASE(round_test) TEST_CASE(unknown_test)
{ {
migraphx::program p; migraphx::program p;
auto input = p.add_parameter("x", migraphx::shape{migraphx::shape::double_type, {10, 5}}); auto l0 = p.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {2, 3, 4, 5}});
p.add_instruction(migraphx::op::round{}, input); auto l1 = p.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {3, 4}});
auto l2 = p.add_instruction(migraphx::op::unknown{"Unknown"}, l0, l1);
p.add_instruction(migraphx::op::unknown{"Unknown"}, l2);
auto prog = migraphx::parse_onnx("unknown_test.onnx");
auto prog = migraphx::parse_onnx("round_test.onnx");
EXPECT(p == prog); EXPECT(p == prog);
} }
......
test/onnx/pow_test.onnx 0 → 100644
View file @ 99bcbf02
pow2:u

0
1out"Powpow_testZ
0




Z
1




b
out




B
test/py/test_array.py
View file @ 99bcbf02
...@@ -69,7 +69,7 @@ def test_input(): ...@@ -69,7 +69,7 @@ def test_input():
def test_output(): def test_output():
p = migraphx.parse_onnx("conv_relu_maxpool.onnx") p = migraphx.parse_onnx("conv_relu_maxpool_test.onnx")
p.compile(migraphx.get_target("gpu")) p.compile(migraphx.get_target("gpu"))
r1 = run(p) r1 = run(p)
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment