Merge branch 'refactor_dynamic_compute' of...

Merge branch 'refactor_dynamic_compute' of github.com:ROCmSoftwarePlatform/AMDMIGraphX into dyn_ref_broadcast

test/tf/gen_tf_pb.py

@@ -120,19 +120,45 @@ def batchnorm_test(g1):
     with g1.as_default():
         g1_input = tf.compat.v1.placeholder(tf.float32,
                                             shape=(1, 16, 16, 32),
-                                            name='0')
-        g1_scale = tf.constant(1.0, dtype=tf.float32, shape=[32], name='1')
-        g1_offset = tf.compat.v1.placeholder(tf.float32, shape=(32), name='2')
-        g1_mean = tf.compat.v1.placeholder(tf.float32, shape=(32), name='3')
+                                            name='x')
+        g1_scale = tf.constant(1.0, dtype=tf.float32, shape=[32], name='scale')
+        g1_offset = tf.compat.v1.placeholder(tf.float32,
+                                             shape=(32),
+                                             name='bias')
+        g1_mean = tf.compat.v1.placeholder(tf.float32, shape=(32), name='mean')
         g1_variance = tf.compat.v1.placeholder(tf.float32,
                                                shape=(32),
-                                               name='4')
+                                               name='variance')
         tf.compat.v1.nn.fused_batch_norm(x=g1_input,
                                          scale=g1_scale,
                                          offset=g1_offset,
                                          mean=g1_mean,
                                          variance=g1_variance,
-                                         epsilon=0.00001,
+                                         epsilon=1e-4,
+                                         is_training=False,
+                                         name='batchnorm1')
+
+
+@tf_test
+def batchnorm_half_test(g1):
+    with g1.as_default():
+        g1_input = tf.compat.v1.placeholder(tf.float16,
+                                            shape=(1, 16, 16, 32),
+                                            name='x')
+        g1_scale = tf.constant(1.0, dtype=tf.float32, shape=[32], name='scale')
+        g1_offset = tf.compat.v1.placeholder(tf.float32,
+                                             shape=(32),
+                                             name='bias')
+        g1_mean = tf.compat.v1.placeholder(tf.float32, shape=(32), name='mean')
+        g1_variance = tf.compat.v1.placeholder(tf.float32,
+                                               shape=(32),
+                                               name='variance')
+        tf.compat.v1.nn.fused_batch_norm(x=g1_input,
+                                         scale=g1_scale,
+                                         offset=g1_offset,
+                                         mean=g1_mean,
+                                         variance=g1_variance,
+                                         epsilon=1e-4,
                                          is_training=False,
                                          name='batchnorm1')
 
@@ -142,19 +168,21 @@ def batchnormv3_test(g1):
     with g1.as_default():
         g1_input = tf.compat.v1.placeholder(tf.float32,
                                             shape=(1, 16, 16, 32),
-                                            name='0')
-        g1_scale = tf.constant(1.0, dtype=tf.float32, shape=[32], name='1')
-        g1_offset = tf.compat.v1.placeholder(tf.float32, shape=(32), name='2')
-        g1_mean = tf.compat.v1.placeholder(tf.float32, shape=(32), name='3')
+                                            name='x')
+        g1_scale = tf.constant(1.0, dtype=tf.float32, shape=[32], name='scale')
+        g1_offset = tf.compat.v1.placeholder(tf.float32,
+                                             shape=(32),
+                                             name='bias')
+        g1_mean = tf.compat.v1.placeholder(tf.float32, shape=(32), name='mean')
         g1_variance = tf.compat.v1.placeholder(tf.float32,
                                                shape=(32),
-                                               name='4')
+                                               name='variance')
         tf.raw_ops.FusedBatchNormV3(x=g1_input,
                                     scale=g1_scale,
                                     offset=g1_offset,
                                     mean=g1_mean,
                                     variance=g1_variance,
-                                    epsilon=0.00001,
+                                    epsilon=1e-6,
                                     is_training=False,
                                     name='batchnorm1')
 

test/tf/tf_test.cpp

@@ -24,6 +24,7 @@
 #include <iostream>
 #include <vector>
 #include <unordered_map>
+#include <migraphx/common.hpp>
 #include <migraphx/literal.hpp>
 #include <migraphx/pass_manager.hpp>
 #include <migraphx/simplify_reshapes.hpp>
@@ -33,7 +34,6 @@
 #include <migraphx/instruction.hpp>
 #include <migraphx/tf.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/op/batch_norm_inference.hpp>
 #include <migraphx/op/convolution.hpp>
 #include <migraphx/op/reduce_mean.hpp>
 #include <migraphx/op/pooling.hpp>
@@ -186,50 +186,94 @@ TEST_CASE(batchmatmul_test)
 
 TEST_CASE(batchnorm_test)
 {
-    float epsilon  = 1.001e-5f;
-    float momentum = 0.9f;
-
     migraphx::program p;
-
     auto* mm = p.get_main_module();
-    migraphx::op::batch_norm_inference op{
-        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
-    migraphx::shape s0{migraphx::shape::float_type, {32}};
-    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
-    std::vector<float> const_vals(32);
-    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
-
-    auto l2 = mm->add_parameter("2", s0);
-    auto l3 = mm->add_parameter("3", s0);
-    auto l4 = mm->add_parameter("4", s0);
-    auto l1 = mm->add_literal(migraphx::literal{s0, const_vals});
-    mm->add_instruction(op, l0, l1, l2, l3, l4);
+
+    auto x    = mm->add_parameter("x", {migraphx::shape::float_type, {1, 32, 16, 16}});
+    auto bias = mm->add_parameter("bias", {migraphx::shape::float_type, {32}});
+    auto mean = mm->add_parameter("mean", {migraphx::shape::float_type, {32}});
+    auto var  = mm->add_parameter("variance", {migraphx::shape::float_type, {32}});
+
+    std::vector<float> scale_data(32, 1.0);
+    auto scale = mm->add_literal(migraphx::shape{migraphx::shape::float_type, {32}}, scale_data);
+    auto rt    = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {0.5}});
+    auto eps   = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-4f}});
+
+    auto usq_scale = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), scale);
+    auto usq_bias  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), bias);
+    auto usq_mean  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), mean);
+    auto usq_var   = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), var);
+
+    auto numer   = add_common_op(*mm, migraphx::make_op("sub"), {x, usq_mean});
+    auto var_eps = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+    auto denom   = add_common_op(*mm, migraphx::make_op("pow"), {var_eps, rt});
+    auto div0    = add_common_op(*mm, migraphx::make_op("div"), {numer, denom});
+    auto r0      = add_common_op(*mm, migraphx::make_op("mul"), {div0, usq_scale});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
     auto prog = optimize_tf("batchnorm_test.pb", true);
+    EXPECT(p == prog);
+}
+
+TEST_CASE(batchnorm_half_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
 
+    auto x    = mm->add_parameter("x", {migraphx::shape::half_type, {1, 32, 16, 16}});
+    auto bias = mm->add_parameter("bias", {migraphx::shape::float_type, {32}});
+    auto mean = mm->add_parameter("mean", {migraphx::shape::float_type, {32}});
+    auto var  = mm->add_parameter("variance", {migraphx::shape::float_type, {32}});
+
+    std::vector<float> scale_data(32, 1.0);
+    auto scale = mm->add_literal(migraphx::shape{migraphx::shape::float_type, {32}}, scale_data);
+    auto rt    = mm->add_literal(migraphx::literal{migraphx::shape::half_type, {0.5}});
+    auto eps   = mm->add_literal(migraphx::literal{migraphx::shape::half_type, {1e-4f}});
+
+    auto usq_scale = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), scale);
+    auto usq_bias  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), bias);
+    auto usq_mean  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), mean);
+    auto usq_var   = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), var);
+
+    auto numer   = add_common_op(*mm, migraphx::make_op("sub"), {x, usq_mean});
+    auto var_eps = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+    auto denom   = add_common_op(*mm, migraphx::make_op("pow"), {var_eps, rt});
+    auto div0    = add_common_op(*mm, migraphx::make_op("div"), {numer, denom});
+    auto r0      = add_common_op(*mm, migraphx::make_op("mul"), {div0, usq_scale});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
+    auto prog = optimize_tf("batchnorm_half_test.pb", true);
     EXPECT(p == prog);
 }
 
 TEST_CASE(batchnormv3_test)
 {
-    float epsilon  = 1.0e-5f;
-    float momentum = 0.9f;
-
     migraphx::program p;
     auto* mm = p.get_main_module();
-    migraphx::op::batch_norm_inference op{
-        epsilon, momentum, migraphx::op::batch_norm_inference::spatial};
-    migraphx::shape s0{migraphx::shape::float_type, {32}};
-    auto l0 = mm->add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 32, 16, 16}});
-    std::vector<float> const_vals(32);
-    std::fill(const_vals.begin(), const_vals.end(), 1.0f);
-
-    auto l2 = mm->add_parameter("2", s0);
-    auto l3 = mm->add_parameter("3", s0);
-    auto l4 = mm->add_parameter("4", s0);
-    auto l1 = mm->add_literal(migraphx::literal{s0, const_vals});
-    mm->add_instruction(op, l0, l1, l2, l3, l4);
-    auto prog = optimize_tf("batchnormv3_test.pb", true);
 
+    auto x    = mm->add_parameter("x", {migraphx::shape::float_type, {1, 32, 16, 16}});
+    auto bias = mm->add_parameter("bias", {migraphx::shape::float_type, {32}});
+    auto mean = mm->add_parameter("mean", {migraphx::shape::float_type, {32}});
+    auto var  = mm->add_parameter("variance", {migraphx::shape::float_type, {32}});
+
+    std::vector<float> scale_data(32, 1.0);
+    auto scale = mm->add_literal(migraphx::shape{migraphx::shape::float_type, {32}}, scale_data);
+    auto rt    = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {0.5}});
+    auto eps   = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-6f}});
+
+    auto usq_scale = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), scale);
+    auto usq_bias  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), bias);
+    auto usq_mean  = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), mean);
+    auto usq_var   = mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), var);
+
+    auto numer   = add_common_op(*mm, migraphx::make_op("sub"), {x, usq_mean});
+    auto var_eps = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+    auto denom   = add_common_op(*mm, migraphx::make_op("pow"), {var_eps, rt});
+    auto div0    = add_common_op(*mm, migraphx::make_op("div"), {numer, denom});
+    auto r0      = add_common_op(*mm, migraphx::make_op("mul"), {div0, usq_scale});
+    add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
+    auto prog = optimize_tf("batchnormv3_test.pb", true);
     EXPECT(p == prog);
 }
 

test/verify/test_batchnorm_1d.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/make_op.hpp>
-
-struct test_batchnorm_1d : verify_program<test_batchnorm_1d>
-{
-    const size_t size     = 3;
-    const size_t channels = 3;
-    const size_t batches  = 4;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, size}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op("batch_norm_inference"), x, scale, bias, mean, variance);
-        return p;
-    }
-};

test/verify/test_batchnorm_1d_per_actv.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/serialize.hpp>
-
-#include <migraphx/make_op.hpp>
-
-#include <migraphx/op/batch_norm_inference.hpp>
-
-struct test_batchnorm_1d_per_actv : verify_program<test_batchnorm_1d_per_actv>
-{
-    const size_t d1       = 5;
-    const size_t channels = 2;
-    const size_t batches  = 3;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, d1}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels, d1}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op(
-                "batch_norm_inference",
-                {{"epsilon", 1.0e-5},
-                 {"momentum", 0.96f},
-                 {"bn_mode",
-                  migraphx::to_value(migraphx::op::batch_norm_inference::per_activation)}}),
-            x,
-            scale,
-            bias,
-            mean,
-            variance);
-        return p;
-    }
-};

test/verify/test_batchnorm_2d_per_actv.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/serialize.hpp>
-
-#include <migraphx/make_op.hpp>
-
-#include <migraphx/op/batch_norm_inference.hpp>
-
-struct test_batchnorm_2d_per_actv : verify_program<test_batchnorm_2d_per_actv>
-{
-    const size_t d1       = 2;
-    const size_t d2       = 4;
-    const size_t channels = 2;
-    const size_t batches  = 3;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, d1, d2}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels, d1, d2}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op(
-                "batch_norm_inference",
-                {{"epsilon", 1.0e-6},
-                 {"momentum", 0.9f},
-                 {"bn_mode",
-                  migraphx::to_value(migraphx::op::batch_norm_inference::per_activation)}}),
-            x,
-            scale,
-            bias,
-            mean,
-            variance);
-        return p;
-    }
-};

test/verify/test_batchnorm_3d.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/make_op.hpp>
-
-struct test_batchnorm_3d : verify_program<test_batchnorm_3d>
-{
-    const size_t d1       = 2;
-    const size_t d2       = 2;
-    const size_t d3       = 2;
-    const size_t channels = 2;
-    const size_t batches  = 2;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, d1, d2, d3}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op("batch_norm_inference"), x, scale, bias, mean, variance);
-        return p;
-    }
-};

test/verify/test_batchnorm_3d_per_actv.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/serialize.hpp>
-
-#include <migraphx/make_op.hpp>
-
-#include <migraphx/op/batch_norm_inference.hpp>
-
-struct test_batchnorm_3d_per_actv : verify_program<test_batchnorm_3d_per_actv>
-{
-    const size_t d1       = 2;
-    const size_t d2       = 4;
-    const size_t d3       = 5;
-    const size_t channels = 2;
-    const size_t batches  = 3;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, d1, d2, d3}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels, d1, d2, d3}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op(
-                "batch_norm_inference",
-                {{"epsilon", 1.0e-6},
-                 {"momentum", 0.8f},
-                 {"bn_mode",
-                  migraphx::to_value(migraphx::op::batch_norm_inference::per_activation)}}),
-            x,
-            scale,
-            bias,
-            mean,
-            variance);
-        return p;
-    }
-};

test/verify/test_batchnorm_inference.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/make_op.hpp>
-
-struct test_batchnorm_inference : verify_program<test_batchnorm_inference>
-{
-    const size_t width    = 3;
-    const size_t height   = 3;
-    const size_t channels = 3;
-    const size_t batches  = 4;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op("batch_norm_inference"), x, scale, bias, mean, variance);
-        return p;
-    }
-};

test/verify/test_batchnorm_inference_2.cpp

-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "verify_program.hpp"
-#include <migraphx/program.hpp>
-#include <migraphx/generate.hpp>
-#include <migraphx/make_op.hpp>
-
-struct test_batchnorm_inference_2 : verify_program<test_batchnorm_inference_2>
-{
-    const size_t width    = 14;
-    const size_t height   = 14;
-    const size_t channels = 256;
-    const size_t batches  = 1;
-
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-
-        migraphx::shape s{migraphx::shape::float_type, {batches, channels, height, width}};
-        migraphx::shape vars{migraphx::shape::float_type, {channels}};
-        auto x        = mm->add_parameter("x", s);
-        auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
-        auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
-        auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
-        auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op("batch_norm_inference"), x, scale, bias, mean, variance);
-        return p;
-    }
-};

test/verify/test_conv_bn.cpp

@@ -26,6 +26,8 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/common.hpp>
 
 struct test_conv_bn : verify_program<test_conv_bn>
 {
@@ -37,19 +39,38 @@ struct test_conv_bn : verify_program<test_conv_bn>
         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    = mm->add_parameter("x", xs);
-        auto w    = mm->add_parameter("w", ws);
+        auto x = mm->add_parameter("x", xs);
+        auto w = mm->add_parameter("w", ws);
+        // non-symmetrical tiling
         auto conv = mm->add_instruction(
             migraphx::make_op("convolution",
                               {{"padding", {3, 3}}, {"stride", {2, 2}}, {"dilation", {1, 1}}}),
             x,
             w);
+
         auto scale    = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 1)));
         auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
         auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
         auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        mm->add_instruction(
-            migraphx::make_op("batch_norm_inference"), conv, scale, bias, mean, variance);
+
+        auto rt  = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {0.5}});
+        auto eps = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-5f}});
+
+        auto usq_scale =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), scale);
+        auto usq_bias =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), bias);
+        auto usq_mean =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), mean);
+        auto usq_var =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), variance);
+
+        auto numer   = add_common_op(*mm, migraphx::make_op("sub"), {conv, usq_mean});
+        auto var_eps = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+        auto denom   = add_common_op(*mm, migraphx::make_op("pow"), {var_eps, rt});
+        auto div0    = add_common_op(*mm, migraphx::make_op("div"), {numer, denom});
+        auto r0      = add_common_op(*mm, migraphx::make_op("mul"), {div0, usq_scale});
+        add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
         return p;
     }
 };

test/verify/test_conv_bn_relu_pooling.cpp

@@ -27,6 +27,8 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 #include <migraphx/op/common.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/common.hpp>
 
 struct test_conv_bn_relu_pooling : verify_program<test_conv_bn_relu_pooling>
 {
@@ -49,8 +51,26 @@ struct test_conv_bn_relu_pooling : verify_program<test_conv_bn_relu_pooling>
         auto bias     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 2)));
         auto mean     = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 3)));
         auto variance = mm->add_literal(migraphx::abs(migraphx::generate_literal(vars, 4)));
-        auto bn       = mm->add_instruction(
-            migraphx::make_op("batch_norm_inference"), conv, scale, bias, mean, variance);
+
+        auto rt  = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {0.5}});
+        auto eps = mm->add_literal(migraphx::literal{migraphx::shape::float_type, {1e-5f}});
+
+        auto usq_scale =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), scale);
+        auto usq_bias =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), bias);
+        auto usq_mean =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), mean);
+        auto usq_var =
+            mm->add_instruction(migraphx::make_op("unsqueeze", {{"axes", {1, 2}}}), variance);
+
+        auto numer   = add_common_op(*mm, migraphx::make_op("sub"), {conv, usq_mean});
+        auto var_eps = add_common_op(*mm, migraphx::make_op("add"), {usq_var, eps});
+        auto denom   = add_common_op(*mm, migraphx::make_op("pow"), {var_eps, rt});
+        auto div0    = add_common_op(*mm, migraphx::make_op("div"), {numer, denom});
+        auto r0      = add_common_op(*mm, migraphx::make_op("mul"), {div0, usq_scale});
+        auto bn      = add_common_op(*mm, migraphx::make_op("add"), {r0, usq_bias});
+
         auto relu = mm->add_instruction(migraphx::make_op("relu"), bn);
         mm->add_instruction(migraphx::make_op("pooling",
                                               {{"mode", migraphx::op::pooling_mode::average},