[layer/test] Add unittests for conv1d

This patch adds layers golden tests for conv1d.
conv1d is also added to the list of transpose layers while saving data
from tensorflow.

Signed-off-by: Parichay Kapoor <pk.kapoor@samsung.com>

diff --git a/packaging/unittest_layers_v2.tar.gz b/packaging/unittest_layers_v2.tar.gz
index 3abae0e..faa0d6f 100644 (file)
Binary files a/packaging/unittest_layers_v2.tar.gz and b/packaging/unittest_layers_v2.tar.gz differ

diff --git a/test/input_gen/genLayerTests.py b/test/input_gen/genLayerTests.py
index f1291b6..cdc36b2 100644 (file)
--- a/test/input_gen/genLayerTests.py
+++ b/test/input_gen/genLayerTests.py
@@ -56,28 +56,28 @@ if __name__ == "__main__":
     record_single(bn, (2, 10), "bn_width_inference", {"training": False})
 
     conv = K.layers.Conv2D(3, 2)
-    record_single(conv, (1, 1, 4, 4), "conv_sb_minimum")
-    record_single(conv, (3, 1, 4, 4), "conv_mb_minimum")
+    record_single(conv, (1, 1, 4, 4), "conv2d_sb_minimum")
+    record_single(conv, (3, 1, 4, 4), "conv2d_mb_minimum")
 
     conv = K.layers.Conv2D(2, 3, padding="same")
-    record_single(conv, (1, 1, 4, 4), "conv_sb_same_remain")
-    record_single(conv, (3, 1, 4, 4), "conv_mb_same_remain")
+    record_single(conv, (1, 1, 4, 4), "conv2d_sb_same_remain")
+    record_single(conv, (3, 1, 4, 4), "conv2d_mb_same_remain", input_type='float')
 
     conv = K.layers.Conv2D(2, 3, strides=2, padding="same")
-    record_single(conv, (1, 3, 4, 4), "conv_sb_same_uneven_remain")
-    record_single(conv, (3, 3, 4, 4), "conv_mb_same_uneven_remain")
+    record_single(conv, (1, 3, 4, 4), "conv2d_sb_same_uneven_remain")
+    record_single(conv, (3, 3, 4, 4), "conv2d_mb_same_uneven_remain")
 
     conv = K.layers.Conv2D(2, 3, strides=2, padding="valid")
-    record_single(conv, (1, 3, 7, 7), "conv_sb_valid_drop_last")
-    record_single(conv, (3, 3, 7, 7), "conv_mb_valid_drop_last")
+    record_single(conv, (1, 3, 7, 7), "conv2d_sb_valid_drop_last")
+    record_single(conv, (3, 3, 7, 7), "conv2d_mb_valid_drop_last")
 
     conv = K.layers.Conv2D(3, 2, strides=3)
-    record_single(conv, (1, 2, 5, 5), "conv_sb_no_overlap")
-    record_single(conv, (3, 2, 5, 5), "conv_mb_no_overlap")
+    record_single(conv, (1, 2, 5, 5), "conv2d_sb_no_overlap")
+    record_single(conv, (3, 2, 5, 5), "conv2d_mb_no_overlap")
 
     conv = K.layers.Conv2D(3, 1, strides=2)
-    record_single(conv, (1, 2, 5, 5), "conv_sb_1x1_kernel")
-    record_single(conv, (3, 2, 5, 5), "conv_mb_1x1_kernel")
+    record_single(conv, (1, 2, 5, 5), "conv2d_sb_1x1_kernel")
+    record_single(conv, (3, 2, 5, 5), "conv2d_mb_1x1_kernel")
 
     # use float data to generate input here
     attention = K.layers.Attention()
@@ -146,5 +146,29 @@ if __name__ == "__main__":
     dropout = K.layers.Dropout(rate=0.9999)
     record_single(dropout, (2, 3, 2, 3), "dropout_100_training", {"training": True})
 
+    conv = K.layers.Conv1D(3, 2)
+    record_single(conv, (1, 1, 1, 4), "conv1d_sb_minimum")
+    record_single(conv, (3, 1, 1, 4), "conv1d_mb_minimum")
+
+    conv = K.layers.Conv1D(2, 3, padding="same")
+    record_single(conv, (1, 1, 1, 4), "conv1d_sb_same_remain")
+    record_single(conv, (3, 1, 1, 4), "conv1d_mb_same_remain")
+
+    conv = K.layers.Conv1D(2, 3, strides=2, padding="same")
+    record_single(conv, (1, 3, 1, 4), "conv1d_sb_same_uneven_remain")
+    record_single(conv, (3, 3, 1, 4), "conv1d_mb_same_uneven_remain")
+
+    conv = K.layers.Conv1D(2, 3, strides=2, padding="valid")
+    record_single(conv, (1, 3, 1, 7), "conv1d_sb_valid_drop_last")
+    record_single(conv, (3, 3, 1, 7), "conv1d_mb_valid_drop_last")
+
+    conv = K.layers.Conv1D(3, 2, strides=3)
+    record_single(conv, (1, 2, 1, 5), "conv1d_sb_no_overlap")
+    record_single(conv, (3, 2, 1, 5), "conv1d_mb_no_overlap")
+
+    conv = K.layers.Conv1D(3, 1, strides=2)
+    record_single(conv, (1, 2, 1, 5), "conv1d_sb_1x1_kernel")
+    record_single(conv, (3, 2, 1, 5), "conv1d_mb_1x1_kernel")
+
 inspect_file("dropout_20_training.nnlayergolden")
 

diff --git a/test/input_gen/transLayer.py b/test/input_gen/transLayer.py
index 4e8e659..d252ee7 100644 (file)
--- a/test/input_gen/transLayer.py
+++ b/test/input_gen/transLayer.py
@@ -106,7 +106,9 @@ class ChannelLastTransLayer(AbstractTransLayer):
     # TO_CHANNELS_LAST = (0, 2, 3, 1)
     TO_CHANNELS_LAST = (2, 3, 1)
     # height, width, channel, filter_size -> filter_size, channel, height, width
-    TO_NNTR_KERNEL = (3, 2, 0, 1)
+    TO_NNTR_KERNEL_4D = (3, 2, 0, 1)
+    # width, channel, filter_size -> filter_size, channel, width
+    TO_NNTR_KERNEL_3D = (2, 1, 0)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -138,7 +140,9 @@ class ChannelLastTransLayer(AbstractTransLayer):
     @classmethod
     def _nntr_kernel(cls, tensor):
         if tf.rank(tensor).numpy() == 4:
-            return tf.transpose(tensor, perm=cls.TO_NNTR_KERNEL)
+            return tf.transpose(tensor, perm=cls.TO_NNTR_KERNEL_4D)
+        elif tf.rank(tensor).numpy() == 3:
+            return tf.transpose(tensor, perm=cls.TO_NNTR_KERNEL_3D)
         return tensor
 
     def to_nntr_trainable_weights(self, weights):
@@ -150,6 +154,7 @@ class ChannelLastTransLayer(AbstractTransLayer):
 
 CHANNEL_LAST_LAYERS = (
     K.layers.Conv2D,
+    K.layers.Conv1D,
     K.layers.AveragePooling2D,
     K.layers.AvgPool2D,
     K.layers.MaxPooling2D,

diff --git a/test/unittest/layers/layers_golden_tests.cpp b/test/unittest/layers/layers_golden_tests.cpp
index ec77ea4..5e71009 100644 (file)
--- a/test/unittest/layers/layers_golden_tests.cpp
+++ b/test/unittest/layers/layers_golden_tests.cpp
@@ -153,8 +153,10 @@ static void compareRunContext(RunLayerContext &rc, std::ifstream &file,
   file.seekg(0, std::ios::beg);
   auto compare_percentage_tensors = [](const Tensor &t1, const Tensor &t2,
                                        unsigned int match_percentage) -> bool {
-    if (match_percentage == 100)
+    if (match_percentage == 100) {
+      EXPECT_EQ(t1, t2);
       return t1 == t2;
+    }
 
     if (t1.getDim() != t2.getDim())
       return false;

diff --git a/test/unittest/layers/meson.build b/test/unittest/layers/meson.build
index 820b703..2b0d2c3 100644 (file)
--- a/test/unittest/layers/meson.build
+++ b/test/unittest/layers/meson.build
@@ -36,6 +36,7 @@ test_target = [
   'unittest_layers_fully_connected.cpp',
   'unittest_layers_batch_normalization.cpp',
   'unittest_layers_convolution2d.cpp',
+  'unittest_layers_convolution1d.cpp',
   'unittest_layers_pooling2d.cpp',
   'unittest_layers_flatten.cpp',
   'unittest_layers_activation.cpp',

diff --git a/test/unittest/layers/unittest_layers_convolution1d.cpp b/test/unittest/layers/unittest_layers_convolution1d.cpp
new file mode 100644 (file)
index 0000000..6a91258
--- /dev/null
+++ b/test/unittest/layers/unittest_layers_convolution1d.cpp
@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Copyright (C) 2021 Parichay Kapoor <pk.kapoor@samsung.com>
+ *
+ * @file unittest_layers_convolution.cpp
+ * @date 18 October 2021
+ * @brief Conv1d Layer Test
+ * @see        https://github.com/nnstreamer/nntrainer
+ * @author Parichay Kapoor <pk.kapoor@samsung.com>
+ * @bug No known bugs except for NYI items
+ */
+#include <tuple>
+
+#include <gtest/gtest.h>
+
+#include <conv1d_layer.h>
+#include <layers_common_tests.h>
+
+auto semantic_conv1d = LayerSemanticsParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>, nntrainer::Conv1DLayer::type,
+  {"filters=1", "kernel_size=1", "padding=1"}, 0, false, 1);
+
+INSTANTIATE_TEST_CASE_P(Convolution1D, LayerSemantics,
+                        ::testing::Values(semantic_conv1d));
+
+auto conv1d_sb_minimum = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {"filters=3", "kernel_size=2"}, "1:1:1:4", "conv1d_sb_minimum.nnlayergolden",
+  LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_minimum = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {"filters=3", "kernel_size=2"}, "3:1:1:4", "conv1d_mb_minimum.nnlayergolden",
+  LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_sb_same_remain = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {"filters=2", "kernel_size=3", "padding=same"}, "1:1:1:4",
+  "conv1d_sb_same_remain.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_same_remain = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {"filters=2", "kernel_size=3", "padding=same"}, "3:1:1:4",
+  "conv1d_mb_same_remain.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_sb_same_uneven_remain_1 = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {
+    "filters=2",
+    "kernel_size=3",
+    "stride=2",
+    "padding=same",
+  },
+  "1:3:1:4", "conv1d_sb_same_uneven_remain.nnlayergolden",
+  LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_sb_same_uneven_remain_2 = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {
+    "filters=2",
+    "kernel_size=3",
+    "stride=2",
+    "padding=0,0,0,1",
+  },
+  "1:3:1:4", "conv1d_sb_same_uneven_remain.nnlayergolden",
+  LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_same_uneven_remain_1 = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {
+    "filters=2",
+    "kernel_size=3",
+    "stride=2",
+    "padding=same",
+  },
+  "3:3:1:4", "conv1d_mb_same_uneven_remain.nnlayergolden",
+  LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_same_uneven_remain_2 = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {
+    "filters=2",
+    "kernel_size=3",
+    "stride=2",
+    "padding=0,0,0,1",
+  },
+  "3:3:1:4", "conv1d_mb_same_uneven_remain.nnlayergolden",
+  LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_sb_valid_drop_last =
+  LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv1DLayer>,
+                           {
+                             "filters=2",
+                             "kernel_size=3",
+                             "stride=2",
+                             "padding=valid",
+                           },
+                           "1:3:1:7", "conv1d_sb_valid_drop_last.nnlayergolden",
+                           LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_valid_drop_last =
+  LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv1DLayer>,
+                           {
+                             "filters=2",
+                             "kernel_size=3",
+                             "stride=2",
+                             "padding=valid",
+                           },
+                           "3:3:1:7", "conv1d_mb_valid_drop_last.nnlayergolden",
+                           LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_sb_no_overlap = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {"filters=3", "kernel_size=2", "stride=3"}, "1:2:1:5",
+  "conv1d_sb_no_overlap.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_no_overlap =
+  LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv1DLayer>,
+                           {
+                             "filters=3",
+                             "kernel_size=2",
+                             "stride=3",
+                           },
+                           "3:2:1:5", "conv1d_mb_no_overlap.nnlayergolden",
+                           LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_sb_1x1_kernel = LayerGoldenTestParamType(
+  nntrainer::createLayer<nntrainer::Conv1DLayer>,
+  {"filters=3", "kernel_size=1", "stride=2"}, "1:2:1:5",
+  "conv1d_sb_1x1_kernel.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+
+auto conv1d_mb_1x1_kernel =
+  LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv1DLayer>,
+                           {
+                             "filters=3",
+                             "kernel_size=1",
+                             "stride=2",
+                           },
+                           "3:2:1:5", "conv1d_mb_1x1_kernel.nnlayergolden",
+                           LayerGoldenTestParamOptions::DEFAULT);
+
+INSTANTIATE_TEST_CASE_P(
+  Convolution1D, LayerGoldenTest,
+  ::testing::Values(conv1d_sb_minimum, conv1d_mb_minimum, conv1d_sb_same_remain,
+                    conv1d_mb_same_remain, conv1d_sb_same_uneven_remain_1,
+                    conv1d_sb_same_uneven_remain_2,
+                    conv1d_mb_same_uneven_remain_1,
+                    conv1d_mb_same_uneven_remain_2, conv1d_sb_valid_drop_last,
+                    conv1d_mb_valid_drop_last, conv1d_sb_no_overlap,
+                    conv1d_mb_no_overlap, conv1d_sb_1x1_kernel,
+                    conv1d_mb_1x1_kernel));

diff --git a/test/unittest/layers/unittest_layers_convolution2d.cpp b/test/unittest/layers/unittest_layers_convolution2d.cpp
index ea29530..e79e9ce 100644 (file)
--- a/test/unittest/layers/unittest_layers_convolution2d.cpp
+++ b/test/unittest/layers/unittest_layers_convolution2d.cpp
@@ -23,27 +23,27 @@ auto semantic_conv2d = LayerSemanticsParamType(
 INSTANTIATE_TEST_CASE_P(Convolution2D, LayerSemantics,
                         ::testing::Values(semantic_conv2d));
 
-auto conv_sb_minimum = LayerGoldenTestParamType(
+auto conv2d_sb_minimum = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
-  {"filters=3", "kernel_size=2,2"}, "1:1:4:4", "conv_sb_minimum.nnlayergolden",
-  LayerGoldenTestParamOptions::DEFAULT);
+  {"filters=3", "kernel_size=2,2"}, "1:1:4:4",
+  "conv2d_sb_minimum.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_minimum = LayerGoldenTestParamType(
+auto conv2d_mb_minimum = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
-  {"filters=3", "kernel_size=2,2"}, "3:1:4:4", "conv_mb_minimum.nnlayergolden",
-  LayerGoldenTestParamOptions::DEFAULT);
+  {"filters=3", "kernel_size=2,2"}, "3:1:4:4",
+  "conv2d_mb_minimum.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_sb_same_remain = LayerGoldenTestParamType(
+auto conv2d_sb_same_remain = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {"filters=2", "kernel_size=3,3", "padding=same"}, "1:1:4:4",
-  "conv_sb_same_remain.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+  "conv2d_sb_same_remain.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_same_remain = LayerGoldenTestParamType(
+auto conv2d_mb_same_remain = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {"filters=2", "kernel_size=3,3", "padding=same"}, "3:1:4:4",
-  "conv_mb_same_remain.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+  "conv2d_mb_same_remain.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_sb_same_uneven_remain_1 = LayerGoldenTestParamType(
+auto conv2d_sb_same_uneven_remain_1 = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {
     "filters=2",
@@ -51,10 +51,10 @@ auto conv_sb_same_uneven_remain_1 = LayerGoldenTestParamType(
     "stride=2,2",
     "padding=same",
   },
-  "1:3:4:4", "conv_sb_same_uneven_remain.nnlayergolden",
+  "1:3:4:4", "conv2d_sb_same_uneven_remain.nnlayergolden",
   LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_sb_same_uneven_remain_2 = LayerGoldenTestParamType(
+auto conv2d_sb_same_uneven_remain_2 = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {
     "filters=2",
@@ -62,10 +62,10 @@ auto conv_sb_same_uneven_remain_2 = LayerGoldenTestParamType(
     "stride=2,2",
     "padding=0,1,0,1",
   },
-  "1:3:4:4", "conv_sb_same_uneven_remain.nnlayergolden",
+  "1:3:4:4", "conv2d_sb_same_uneven_remain.nnlayergolden",
   LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_same_uneven_remain_1 = LayerGoldenTestParamType(
+auto conv2d_mb_same_uneven_remain_1 = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {
     "filters=2",
@@ -73,10 +73,10 @@ auto conv_mb_same_uneven_remain_1 = LayerGoldenTestParamType(
     "stride=2,2",
     "padding=same",
   },
-  "3:3:4:4", "conv_mb_same_uneven_remain.nnlayergolden",
+  "3:3:4:4", "conv2d_mb_same_uneven_remain.nnlayergolden",
   LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_same_uneven_remain_2 = LayerGoldenTestParamType(
+auto conv2d_mb_same_uneven_remain_2 = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {
     "filters=2",
@@ -84,10 +84,10 @@ auto conv_mb_same_uneven_remain_2 = LayerGoldenTestParamType(
     "stride=2,2",
     "padding=0,1,0,1",
   },
-  "3:3:4:4", "conv_mb_same_uneven_remain.nnlayergolden",
+  "3:3:4:4", "conv2d_mb_same_uneven_remain.nnlayergolden",
   LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_sb_valid_drop_last =
+auto conv2d_sb_valid_drop_last =
   LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv2DLayer>,
                            {
                              "filters=2",
@@ -95,10 +95,10 @@ auto conv_sb_valid_drop_last =
                              "stride=2,2",
                              "padding=valid",
                            },
-                           "1:3:7:7", "conv_sb_valid_drop_last.nnlayergolden",
+                           "1:3:7:7", "conv2d_sb_valid_drop_last.nnlayergolden",
                            LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_valid_drop_last =
+auto conv2d_mb_valid_drop_last =
   LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv2DLayer>,
                            {
                              "filters=2",
@@ -106,45 +106,46 @@ auto conv_mb_valid_drop_last =
                              "stride=2,2",
                              "padding=valid",
                            },
-                           "3:3:7:7", "conv_mb_valid_drop_last.nnlayergolden",
+                           "3:3:7:7", "conv2d_mb_valid_drop_last.nnlayergolden",
                            LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_sb_no_overlap = LayerGoldenTestParamType(
+auto conv2d_sb_no_overlap = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {"filters=3", "kernel_size=2,2", "stride=3,3"}, "1:2:5:5",
-  "conv_sb_no_overlap.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+  "conv2d_sb_no_overlap.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_no_overlap =
+auto conv2d_mb_no_overlap =
   LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv2DLayer>,
                            {
                              "filters=3",
                              "kernel_size=2,2",
                              "stride=3,3",
                            },
-                           "3:2:5:5", "conv_mb_no_overlap.nnlayergolden",
+                           "3:2:5:5", "conv2d_mb_no_overlap.nnlayergolden",
                            LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_sb_1x1_kernel = LayerGoldenTestParamType(
+auto conv2d_sb_1x1_kernel = LayerGoldenTestParamType(
   nntrainer::createLayer<nntrainer::Conv2DLayer>,
   {"filters=3", "kernel_size=1,1", "stride=2,2"}, "1:2:5:5",
-  "conv_sb_1x1_kernel.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
+  "conv2d_sb_1x1_kernel.nnlayergolden", LayerGoldenTestParamOptions::DEFAULT);
 
-auto conv_mb_1x1_kernel =
+auto conv2d_mb_1x1_kernel =
   LayerGoldenTestParamType(nntrainer::createLayer<nntrainer::Conv2DLayer>,
                            {
                              "filters=3",
                              "kernel_size=1,1",
                              "stride=2,2",
                            },
-                           "3:2:5:5", "conv_mb_1x1_kernel.nnlayergolden",
+                           "3:2:5:5", "conv2d_mb_1x1_kernel.nnlayergolden",
                            LayerGoldenTestParamOptions::DEFAULT);
 
 INSTANTIATE_TEST_CASE_P(
   Convolution2D, LayerGoldenTest,
-  ::testing::Values(conv_sb_minimum, conv_mb_minimum, conv_sb_same_remain,
-                    conv_mb_same_remain, conv_sb_same_uneven_remain_1,
-                    conv_sb_same_uneven_remain_2, conv_mb_same_uneven_remain_1,
-                    conv_mb_same_uneven_remain_2, conv_sb_valid_drop_last,
-                    conv_mb_valid_drop_last, conv_sb_no_overlap,
-                    conv_mb_no_overlap, conv_sb_1x1_kernel,
-                    conv_mb_1x1_kernel));
+  ::testing::Values(conv2d_sb_minimum, conv2d_mb_minimum, conv2d_sb_same_remain,
+                    conv2d_mb_same_remain, conv2d_sb_same_uneven_remain_1,
+                    conv2d_sb_same_uneven_remain_2,
+                    conv2d_mb_same_uneven_remain_1,
+                    conv2d_mb_same_uneven_remain_2, conv2d_sb_valid_drop_last,
+                    conv2d_mb_valid_drop_last, conv2d_sb_no_overlap,
+                    conv2d_mb_no_overlap, conv2d_sb_1x1_kernel,
+                    conv2d_mb_1x1_kernel));