Split cpu and reference implementation (#671)

* Add all_targets cmake target

* Rename target

* Add ref target

* Rename tests

* Refactor compiler target

* Formatting

* Verify for every target

* Formatting

* Add verify test suite

* Formatting

* Add initial test programs

* Formatting

* Add rnn tests

* Formatting

* Validate gpu

* Formatting

* Remove old gpu tests

* Fix gpu tests

* Fix ref error

* Fix tidy issues

* Formatting

* Tidy fixes

* Fix header in python api

* Rename to ref

* Use ref in verify_onnx

* Fix tidy issue

* Build with verbose on

* Fix typo

* Remove verbose

* rename some cpu prefix to ref
Co-authored-by: Shucai Xiao <Shucai.Xiao@amd.com>

test/verify/test_concat_relu.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_concat_relu : verify_program<test_concat_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        int axis = 0;
+        migraphx::shape s0{migraphx::shape::float_type, {2, 2}};
+        migraphx::shape s1{migraphx::shape::float_type, {3, 2}};
+        migraphx::shape s2{migraphx::shape::float_type, {1, 2}};
+        auto l0 = p.add_parameter("x", s0);
+        auto l1 = p.add_parameter("y", s1);
+        auto l2 = p.add_parameter("z", s2);
+        auto r0 = p.add_instruction(migraphx::op::relu{}, l0);
+        auto r1 = p.add_instruction(migraphx::op::relu{}, l1);
+        auto r2 = p.add_instruction(migraphx::op::relu{}, l2);
+        auto c0 = p.add_instruction(migraphx::op::concat{axis}, r0, r1, r2);
+        p.add_instruction(migraphx::op::relu{}, c0);
+        return p;
+    }
+};

test/verify/test_concat_transpose.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_concat_transpose : verify_program<test_concat_transpose>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        int axis = 1;
+        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
+        migraphx::shape s1{migraphx::shape::int32_type, {3, 2}};
+        migraphx::shape s2{migraphx::shape::int32_type, {2, 4}};
+        auto l0  = p.add_parameter("x", s0);
+        auto lp1 = p.add_parameter("y", s1);
+        auto l1  = p.add_instruction(migraphx::op::transpose{{1, 0}}, lp1);
+        auto l2  = p.add_parameter("z", s2);
+        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
+        return p;
+    }
+};

test/verify/test_concat_transpose2.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_concat_transpose2 : verify_program<test_concat_transpose2>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        int axis = 1;
+        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
+        migraphx::shape s1{migraphx::shape::int32_type, {2, 3}};
+        migraphx::shape s2{migraphx::shape::int32_type, {5, 2}};
+        auto l0  = p.add_parameter("x", s0);
+        auto l1  = p.add_parameter("y", s1);
+        auto lp2 = p.add_parameter("z", s2);
+        auto l2  = p.add_instruction(migraphx::op::transpose{{1, 0}}, lp2);
+        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
+        return p;
+    }
+};

test/verify/test_concat_transpose3.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_concat_transpose3 : verify_program<test_concat_transpose3>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        int axis = 1;
+        migraphx::shape s0{migraphx::shape::int32_type, {2, 2}};
+        migraphx::shape s1{migraphx::shape::int32_type, {3, 2}};
+        migraphx::shape s2{migraphx::shape::int32_type, {5, 2}};
+        auto l0  = p.add_parameter("x", s0);
+        auto lp1 = p.add_parameter("y", s1);
+        auto l1  = p.add_instruction(migraphx::op::transpose{{1, 0}}, lp1);
+        auto lp2 = p.add_parameter("z", s2);
+        auto l2  = p.add_instruction(migraphx::op::transpose{{1, 0}}, lp2);
+        p.add_instruction(migraphx::op::concat{axis}, l0, l1, l2);
+        return p;
+    }
+};

test/verify/test_contiguous.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+#include <cassert>
+
+struct test_contiguous : verify_program<test_contiguous>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        migraphx::shape s{migraphx::shape::float_type, {4, 4, 4, 3}, {48, 4, 1, 16}};
+        auto x = p.add_parameter("x", s);
+        p.add_instruction(migraphx::op::contiguous{}, x);
+        assert(p.get_output_shapes().back().standard());
+        return p;
+    }
+};

test/verify/test_contiguous_broadcast.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+#include <cassert>
+
+struct test_contiguous_broadcast : verify_program<test_contiguous_broadcast>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        migraphx::shape s{migraphx::shape::float_type, {1, 2}, {0, 1}};
+        auto x = p.add_parameter("x", s);
+        p.add_instruction(migraphx::op::contiguous{}, x);
+        assert(p.get_output_shapes().back().standard());
+        return p;
+    }
+};

test/verify/test_contiguous_broadcast_transpose.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+#include <cassert>
+
+struct test_contiguous_broadcast_transpose : verify_program<test_contiguous_broadcast_transpose>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        migraphx::shape s{migraphx::shape::float_type, {1, 3072, 768}, {0, 1, 3072}};
+        auto x = p.add_parameter("x", s);
+        p.add_instruction(migraphx::op::contiguous{}, x);
+        assert(p.get_output_shapes().back().standard());
+        return p;
+    }
+};

test/verify/test_conv.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv : verify_program<test_conv>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        p.add_instruction(migraphx::op::convolution{}, input, weights);
+        return p;
+    }
+};

test/verify/test_conv2.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv2 : verify_program<test_conv2>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {1, 512, 28, 28}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}});
+        p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, input, weights);
+        return p;
+    }
+};

test/verify/test_conv3d.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv3d : verify_program<test_conv3d>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3, 3}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3, 3}});
+        p.add_instruction(
+            migraphx::op::convolution{{0, 0, 0}, {1, 1, 1}, {1, 1, 1}}, input, weights);
+        return p;
+    }
+};

test/verify/test_conv_add.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_add : verify_program<test_conv_add>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto x = p.add_parameter("x", {migraphx::shape::float_type, {1, 8, 4, 4}});
+        auto w = p.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 3, 3}}, 1));
+        auto y = p.add_parameter("y", {migraphx::shape::float_type, {1, 8, 4, 4}});
+        auto v = p.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 3, 3}}, 2));
+        auto conv1 = p.add_instruction(migraphx::op::convolution{}, x, w);
+        auto conv2 = p.add_instruction(migraphx::op::convolution{}, y, v);
+        auto sum   = p.add_instruction(migraphx::op::add{}, conv1, conv2);
+        p.add_instruction(migraphx::op::exp{}, sum);
+        return p;
+    }
+};

test/verify/test_conv_add_1x1_diff_strides.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_add_1x1_diff_strides : verify_program<test_conv_add_1x1_diff_strides>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto x = p.add_parameter("x", {migraphx::shape::float_type, {1, 8, 2, 2}});
+        auto w = p.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 1, 1}}, 1));
+        auto y = p.add_parameter("y", {migraphx::shape::float_type, {1, 8, 4, 4}});
+        auto v = p.add_literal(
+            migraphx::generate_literal({migraphx::shape::float_type, {2, 8, 1, 1}}, 2));
+        auto conv1 = p.add_instruction(migraphx::op::convolution{}, x, w);
+        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}}, y, v);
+        auto sum   = p.add_instruction(migraphx::op::add{}, conv1, conv2);
+        p.add_instruction(migraphx::op::exp{}, sum);
+        return p;
+    }
+};

test/verify/test_conv_bias_clipped_relu.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+#include <migraphx/instruction.hpp>
+
+struct test_conv_bias_clipped_relu : verify_program<test_conv_bias_clipped_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        std::vector<size_t> input_lens{4, 3, 3, 3};
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto l0   = migraphx::literal{migraphx::shape{migraphx::shape::float_type, {4}},
+                                    {2.0f, 2.0f, 2.0f, 2.0f}};
+        auto bias = p.add_literal(l0);
+        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
+        auto bcast_add =
+            p.add_instruction(migraphx::op::broadcast{1, conv->get_shape().lens()}, bias);
+        auto bias_add = p.add_instruction(migraphx::op::add{}, conv, bcast_add);
+        auto min_val  = p.add_literal(0.0f);
+        auto max_val  = p.add_literal(6.0f);
+        min_val       = p.add_instruction(migraphx::op::multibroadcast{input_lens}, min_val);
+        max_val       = p.add_instruction(migraphx::op::multibroadcast{input_lens}, max_val);
+        p.add_instruction(migraphx::op::clip{}, bias_add, min_val, max_val);
+        return p;
+    }
+};

test/verify/test_conv_bn.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_bn : verify_program<test_conv_bn>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+
+        migraphx::shape xs{migraphx::shape::float_type, {1, 3, 224, 224}};
+        migraphx::shape ws{migraphx::shape::float_type, {64, 3, 7, 7}};
+        migraphx::shape vars{migraphx::shape::float_type, {64}};
+        auto x        = p.add_parameter("x", xs);
+        auto w        = p.add_parameter("w", ws);
+        auto conv     = p.add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
+        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
+        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
+        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
+        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
+        p.add_instruction(migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
+        return p;
+    }
+};

test/verify/test_conv_bn_add.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+// struct test_conv_bn_add : verify_program<test_conv_bn_add>
+// {
+//     static migraphx::instruction_ref add_bn(migraphx::program& p,
+//                                             migraphx::instruction_ref x,
+//                                             std::size_t channels,
+//                                             std::size_t seed = 1)
+//     {
+//         migraphx::shape vars{migraphx::shape::float_type, {channels}};
+//         auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 + seed)));
+//         auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2 + seed)));
+//         auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3 + seed)));
+//         auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + seed)));
+//         return p.add_instruction(
+//             migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
+//     }
+
+//     migraphx::program create_program() const
+//     {
+//         migraphx::program p;
+//         std::size_t ichannels = 64;
+//         std::size_t ochannels = 256;
+//         auto x     = p.add_parameter("x", {migraphx::shape::float_type, {1, ichannels, 56, 56}});
+//         auto w     = p.add_literal(migraphx::generate_literal(
+//             {migraphx::shape::float_type, {ochannels, ichannels, 1, 1}}, 1));
+//         auto y     = p.add_parameter("y", {migraphx::shape::float_type, {1, ichannels, 56, 56}});
+//         auto v     = p.add_literal(migraphx::generate_literal(
+//             {migraphx::shape::float_type, {ochannels, ichannels, 1, 1}}, 2));
+//         auto relu1 = p.add_instruction(migraphx::op::relu{}, x);
+//         auto conv1 = p.add_instruction(migraphx::op::convolution{}, relu1, w);
+//         auto bn1   = add_bn(p, conv1, ochannels, 1);
+//         auto relu2 = p.add_instruction(migraphx::op::relu{}, y);
+//         auto conv2 = p.add_instruction(migraphx::op::convolution{}, relu2, v);
+//         auto bn2   = add_bn(p, conv2, ochannels, 1);
+//         auto sum   = p.add_instruction(migraphx::op::add{}, bn1, bn2);
+//         p.add_instruction(migraphx::op::relu{}, sum);
+//         return p;
+//     }
+// };

test/verify/test_conv_bn_relu_pooling.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_bn_relu_pooling : verify_program<test_conv_bn_relu_pooling>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+
+        migraphx::shape xs{migraphx::shape::float_type, {1, 3, 224, 224}};
+        migraphx::shape ws{migraphx::shape::float_type, {64, 3, 7, 7}};
+        migraphx::shape vars{migraphx::shape::float_type, {64}};
+        auto x        = p.add_parameter("x", xs);
+        auto w        = p.add_parameter("w", ws);
+        auto conv     = p.add_instruction(migraphx::op::convolution{{3, 3}, {2, 2}, {1, 1}}, x, w);
+        auto scale    = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
+        auto bias     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
+        auto mean     = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
+        auto variance = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
+        auto bn       = p.add_instruction(
+            migraphx::op::batch_norm_inference{}, conv, scale, bias, mean, variance);
+        auto relu = p.add_instruction(migraphx::op::relu{}, bn);
+        p.add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
+        return p;
+    }
+};

test/verify/test_conv_bn_relu_pooling2.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_bn_relu_pooling2 : verify_program<test_conv_bn_relu_pooling2>
+{
+    static migraphx::instruction_ref
+    add_bn(migraphx::program& p, migraphx::instruction_ref x, std::size_t channels)
+    {
+        migraphx::shape vars{migraphx::shape::float_type, {channels}};
+        auto scale = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 1 + channels)));
+        auto bias  = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 2 + channels)));
+        auto mean  = p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 3 + channels)));
+        auto variance =
+            p.add_literal(migraphx::abs(migraphx::generate_literal(vars, 4 + channels)));
+        return p.add_instruction(
+            migraphx::op::batch_norm_inference{}, x, scale, bias, mean, variance);
+    }
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+
+        migraphx::shape xs1{migraphx::shape::float_type, {1, 512, 7, 7}};
+        migraphx::shape xs2{migraphx::shape::float_type, {1, 1024, 14, 14}};
+        migraphx::shape ws1{migraphx::shape::float_type, {2048, 512, 1, 1}};
+        migraphx::shape ws2{migraphx::shape::float_type, {2048, 1024, 1, 1}};
+        auto x1    = p.add_parameter("x1", xs1);
+        auto w1    = p.add_parameter("w1", ws1);
+        auto conv1 = p.add_instruction(migraphx::op::convolution{{0, 0}, {1, 1}, {1, 1}}, x1, w1);
+        auto bn1   = add_bn(p, conv1, 2048);
+        auto x2    = p.add_parameter("x2", xs2);
+        auto w2    = p.add_parameter("w2", ws2);
+        auto conv2 = p.add_instruction(migraphx::op::convolution{{0, 0}, {2, 2}, {1, 1}}, x2, w2);
+        auto bn2   = add_bn(p, conv2, 2048);
+        auto add   = p.add_instruction(migraphx::op::add{}, bn1, bn2);
+        auto relu  = p.add_instruction(migraphx::op::relu{}, add);
+        p.add_instruction(migraphx::op::pooling{"average", {1, 1}, {2, 2}, {3, 3}}, relu);
+        return p;
+    }
+};

test/verify/test_conv_pooling.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_pooling : verify_program<test_conv_pooling>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 32, 32}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto conv    = p.add_instruction(migraphx::op::convolution{}, input, weights);
+        auto pooling = p.add_instruction(migraphx::op::pooling{"max"}, conv);
+        p.add_instruction(migraphx::op::relu{}, pooling);
+        return p;
+    }
+};

test/verify/test_conv_relu.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_relu : verify_program<test_conv_relu>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::float_type, {4, 3, 3, 3}});
+        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
+        p.add_instruction(migraphx::op::relu{}, conv);
+        return p;
+    }
+};

test/verify/test_conv_relu_half.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_conv_relu_half : verify_program<test_conv_relu_half>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto input =
+            p.add_parameter("x", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
+        auto weights =
+            p.add_parameter("w", migraphx::shape{migraphx::shape::half_type, {4, 3, 3, 3}});
+        auto conv = p.add_instruction(migraphx::op::convolution{}, input, weights);
+        p.add_instruction(migraphx::op::relu{}, conv);
+        return p;
+    }
+};