Mobilenet gpu implementation

paddle/function/ConvOpTest.cpp

@@ -177,6 +177,156 @@ class ConvolutionTest2 {
   }
 };
 
+template <DeviceType DType1, DeviceType DType2>
+class DepthwiseConvolutionTest {
+public:
+  DepthwiseConvolutionTest(const std::string& conv1,
+                           const std::string& conv2,
+                           TestType type,
+                           std::string algo = "auto") {
+    for (size_t batchSize : {1, 32}) {
+      for (size_t inputSize : {7, 14, 54}) {
+        for (size_t filterSize : {1, 3, 5}) {
+          for (size_t inputChannels : {64, 128}) {
+            size_t outputChannels = inputChannels;
+            for (size_t stride : {1, 2}) {
+              for (size_t padding : {0, 1}) {
+                if (padding >= filterSize) break;
+                size_t outputSize =
+                    (inputSize - filterSize + 2 * padding + stride) / stride;
+                VLOG(3) << " batchSize=" << batchSize
+                        << " inputChannels=" << inputChannels
+                        << " inputHeight=" << inputSize
+                        << " inputWidth=" << inputSize
+                        << " outputChannels=" << outputChannels
+                        << " filterHeight=" << filterSize
+                        << " filterWidth=" << filterSize
+                        << " outputHeight=" << outputSize
+                        << " outputWidth=" << outputSize << " stride=" << stride
+                        << " padding=" << padding;
+
+                std::vector<size_t> paddings = {padding, padding};
+                std::vector<size_t> strides = {stride, stride};
+                size_t groups = inputChannels;
+                Compare2Function<DType1, DType2> test(
+                    conv1,
+                    conv2,
+                    FuncConfig()
+                        .set("paddings", paddings)
+                        .set("strides", strides)
+                        .set("groups", groups)
+                        .set("algo", algo));
+
+                TensorShape input{
+                    batchSize, inputChannels, inputSize, inputSize};
+                TensorShape filter{inputChannels, 1, 1, filterSize, filterSize};
+                TensorShape output{
+                    batchSize, outputChannels, outputSize, outputSize};
+
+                if (type == kForwardTest) {
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
+                  test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, output));
+                  test.run();
+                } else if (type == kBackwardInputTest) {
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
+                  test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, input), ADD_TO);
+                  test.run();
+                } else if (type == kBackwardFilterTest) {
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
+                  test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, filter));
+                  test.run();
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// Mainly used to test cases where the height and width (input, filter)
+// are not equal.
+template <DeviceType DType1, DeviceType DType2>
+class DepthwiseConvolutionTest2 {
+public:
+  DepthwiseConvolutionTest2(const std::string& conv1,
+                            const std::string& conv2,
+                            TestType type,
+                            std::string algo = "auto") {
+    for (size_t batchSize : {16}) {
+      for (size_t inputHeight : {7, 31}) {
+        for (size_t inputWidth : {10, 54}) {
+          for (size_t filterHeight : {1, 5}) {
+            for (size_t filterWidth : {3, 7}) {
+              for (size_t inputChannels : {32}) {
+                size_t outputChannels = inputChannels;
+                size_t stride = 1;
+                size_t padding = 0;
+                size_t outputHeight =
+                    (inputHeight - filterHeight + 2 * padding + stride) /
+                    stride;
+                size_t outputWidth =
+                    (inputWidth - filterWidth + 2 * padding + stride) / stride;
+                VLOG(3) << " batchSize=" << batchSize
+                        << " inputChannels=" << inputChannels
+                        << " inputHeight=" << inputHeight
+                        << " inputWidth=" << inputWidth
+                        << " outputChannels=" << outputChannels
+                        << " filterHeight=" << filterHeight
+                        << " filterWidth=" << filterWidth
+                        << " outputHeight=" << outputHeight
+                        << " outputWidth=" << outputWidth
+                        << " stride=" << stride << " padding=" << padding;
+
+                std::vector<size_t> paddings = {padding, padding};
+                std::vector<size_t> strides = {stride, stride};
+                size_t groups = inputChannels;
+                Compare2Function<DType1, DType2> test(
+                    conv1,
+                    conv2,
+                    FuncConfig()
+                        .set("paddings", paddings)
+                        .set("strides", strides)
+                        .set("groups", groups)
+                        .set("algo", algo));
+
+                TensorShape input{
+                    batchSize, inputChannels, inputHeight, inputWidth};
+                TensorShape filter{
+                    inputChannels, 1, 1, filterHeight, filterWidth};
+                TensorShape output{
+                    batchSize, outputChannels, outputHeight, outputWidth};
+
+                if (type == kForwardTest) {
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
+                  test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, output));
+                  test.run();
+                } else if (type == kBackwardInputTest) {
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, filter));
+                  test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, input), ADD_TO);
+                  test.run();
+                } else if (type == kBackwardFilterTest) {
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, output));
+                  test.addInputs(BufferArg(VALUE_TYPE_FLOAT, input));
+                  test.addOutputs(BufferArg(VALUE_TYPE_FLOAT, filter));
+                  test.run();
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// ======Start Convolution TEST======
 TEST(Forward, GEMM) {
   ConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_CPU> test(
       "NaiveConv-CPU", "GemmConv-CPU", kForwardTest);
@@ -206,5 +356,49 @@ TEST(BackwardFilter, GEMM) {
       "GemmConvGradFilter-CPU", "GemmConvGradFilter-GPU", kBackwardFilterTest);
 }
 #endif
+// ======End Convolution TEST======
+
+// ======Start DepthwiseConvolution TEST======
+// TODO(zhaolong) The depthwise convolution cpu test will be added when the cpu
+// version of depthwiseConv is implemented.
+
+#ifndef PADDLE_ONLY_CPU
+TEST(DepthwiseConvForward, GEMM) {
+  DepthwiseConvolutionTest<DEVICE_TYPE_GPU, DEVICE_TYPE_GPU> test(
+      "GemmConv-GPU", "DepthwiseConv-GPU", kForwardTest);
+  DepthwiseConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
+      "GemmConv-GPU", "DepthwiseConv-GPU", kForwardTest);
+}
+
+TEST(DepthwiseConvForward, GEMM2) {
+  DepthwiseConvolutionTest<DEVICE_TYPE_GPU, DEVICE_TYPE_GPU> test(
+      "DepthwiseConv-GPU", "DepthwiseConv-GPU", kForwardTest);
+  DepthwiseConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
+      "DepthwiseConv-GPU", "DepthwiseConv-GPU", kForwardTest);
+}
+
+TEST(DepthwiseConvBackwardInput, GEMM) {
+  DepthwiseConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
+      "DepthwiseConvGradInput-GPU",
+      "DepthwiseConvGradInput-GPU",
+      kBackwardInputTest);
+  DepthwiseConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
+      "DepthwiseConvGradInput-GPU",
+      "DepthwiseConvGradInput-GPU",
+      kBackwardInputTest);
+}
+
+TEST(DepthwiseConvBackwardFilter, GEMM) {
+  DepthwiseConvolutionTest<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test(
+      "DepthwiseConvGradFilter-GPU",
+      "DepthwiseConvGradFilter-GPU",
+      kBackwardFilterTest);
+  DepthwiseConvolutionTest2<DEVICE_TYPE_CPU, DEVICE_TYPE_GPU> test2(
+      "DepthwiseConvGradFilter-GPU",
+      "DepthwiseConvGradFilter-GPU",
+      kBackwardFilterTest);
+}
+#endif
+// ======End DepthwiseConvolution TEST======
 
 }  // namespace paddle