Merge branch 'develop' into divide_by_zero_check

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);
 }
 
@@ -327,10 +371,9 @@ migraphx::program create_conv()
         mm->add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 32}}, weight_data);
 
     migraphx::op::convolution op;
-    op.padding_mode = migraphx::op::padding_mode_t::same;
-    op.padding      = {1, 1, 1, 1};
-    op.stride       = {1, 1};
-    op.dilation     = {1, 1};
+    op.padding  = {1, 1, 1, 1};
+    op.stride   = {1, 1};
+    op.dilation = {1, 1};
     auto l2 =
         mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {3, 2, 0, 1}}}), l1);
     mm->add_instruction(op, l0, l2);
@@ -406,11 +449,10 @@ TEST_CASE(depthwiseconv_test)
         mm->add_literal(migraphx::shape{migraphx::shape::float_type, {3, 3, 3, 1}}, weight_data);
 
     migraphx::op::convolution op;
-    op.padding_mode = migraphx::op::padding_mode_t::same;
-    op.padding      = {1, 1};
-    op.stride       = {1, 1};
-    op.dilation     = {1, 1};
-    op.group        = 3;
+    op.padding  = {1, 1};
+    op.stride   = {1, 1};
+    op.dilation = {1, 1};
+    op.group    = 3;
     auto l3 =
         mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {3, 2, 0, 1}}}), l1);
     auto l4 = mm->add_instruction(migraphx::make_op("contiguous"), l3);

test/verify/quant_conv_default_mode.cpp

@@ -37,10 +37,7 @@ struct quant_conv_default_mode : verify_program<quant_conv_default_mode>
         auto pa = mm->add_parameter("a", a_shape);
         migraphx::shape c_shape{migraphx::shape::int8_type, {2, 3, 3, 3}};
         auto pc = mm->add_parameter("c", c_shape);
-        mm->add_instruction(
-            migraphx::op::quant_convolution{{{0, 0}}, {{1, 1}}, {{1, 1}}, migraphx::op::same},
-            pa,
-            pc);
+        mm->add_instruction(migraphx::op::quant_convolution{{{0, 0}}, {{1, 1}}, {{1, 1}}}, pa, pc);
         return p;
     }
 };

test/verify/quant_conv_int8x4_default.cpp

@@ -37,10 +37,7 @@ struct quant_conv_int8x4_default : verify_program<quant_conv_int8x4_default>
         auto pa = mm->add_parameter("a", a_shape);
         migraphx::shape c_shape{migraphx::shape::int8_type, {16, 16, 3, 3}};
         auto pc = mm->add_parameter("c", c_shape);
-        mm->add_instruction(
-            migraphx::op::quant_convolution{{{0, 0}}, {{1, 1}}, {{1, 1}}, migraphx::op::same},
-            pa,
-            pc);
+        mm->add_instruction(migraphx::op::quant_convolution{{{0, 0}}, {{1, 1}}, {{1, 1}}}, pa, pc);
         return p;
     }
 };

test/verify/quant_conv_valid_mode.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/op/quant_convolution.hpp>
-
-struct quant_conv_valid_mode : verify_program<quant_conv_valid_mode>
-{
-    migraphx::program create_program() const
-    {
-        migraphx::program p;
-        auto* mm = p.get_main_module();
-        migraphx::shape a_shape{migraphx::shape::int8_type, {2, 3, 4, 4}};
-        auto pa = mm->add_parameter("a", a_shape);
-        migraphx::shape c_shape{migraphx::shape::int8_type, {2, 3, 3, 3}};
-        auto pc = mm->add_parameter("c", c_shape);
-        mm->add_instruction(
-            migraphx::op::quant_convolution{{{0, 0}}, {{1, 1}}, {{1, 1}}, migraphx::op::valid},
-            pa,
-            pc);
-        return p;
-    }
-};

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;
-    }
-};