Add functional convolutions in paddle.nn.functional (#23408)

* add functional conv

* add test and doc for function convs, test=develop

* update ConvTransposeOp's InferShape and error message, test=develop

paddle/fluid/operators/conv_transpose_op.cc

@@ -109,14 +109,30 @@ void ConvTransposeOp::InferShape(framework::InferShapeContext* ctx) const {
   const int offset = (data_layout != DataLayout::kNHWC ? 2 : 1);
   for (size_t i = 0; i < strides.size(); ++i) {
     auto filter_extent = dilations[i] * (filter_dims[i + 2] - 1) + 1;
-    auto infer_shape = (in_dims[i + offset] - 1) * strides[i] -
-                       paddings[2 * i] - paddings[2 * i + 1] + filter_extent;
+    auto infer_shape = (ctx->IsRuntime() || in_dims[i + offset] > 0)
+                           ? (in_dims[i + offset] - 1) * strides[i] -
+                                 paddings[2 * i] - paddings[2 * i + 1] +
+                                 filter_extent
+                           : -1;
     if (output_size.size()) {
-      PADDLE_ENFORCE_EQ((output_size[i] >= infer_shape &&
-                         output_size[i] < infer_shape + strides[i]),
-                        true,
-                        "output_size of Op(ConvTransposeOp) should be "
-                        "in appropriate range.");
+      if (ctx->IsRuntime()) {
+        PADDLE_ENFORCE_GE(
+            output_size[i], infer_shape,
+            platform::errors::InvalidArgument(
+                "output_size of Op(ConvTransposeOp) should not be "
+                "less than the infered output size. But received output_size = "
+                "[%s], whose dim %d is less than the infered output size [%s]",
+                framework::make_ddim(output_size), i, infer_shape));
+        PADDLE_ENFORCE_LT(
+            output_size[i], infer_shape + strides[i],
+            platform::errors::InvalidArgument(
+                "output_size of Op(ConvTransposeOp) should be less "
+                "than infered size + stride. But received output_size = [%s], "
+                "whose dim %d is not less than the infered output size (%d) + "
+                "stride (%d) = %d",
+                framework::make_ddim(output_size), i, infer_shape, strides[i],
+                infer_shape + strides[i]));
+      }
       output_shape.push_back(output_size[i]);
     } else {
       output_shape.push_back(infer_shape);

python/paddle/fluid/layers/nn.py

@@ -3857,10 +3857,10 @@ def conv2d_transpose(input,
 
     if output_size is None:
         output_size = []
-    elif isinstance(output_size, list) or isinstance(output_size, int):
+    elif isinstance(output_size, (list, tuple, int)):
         output_size = utils.convert_to_list(output_size, 2, 'output_size')
     else:
-        raise ValueError("output_size should be list or int")
+        raise ValueError("output_size should be int, list[int] or tuple[int]")
     groups = 1 if groups is None else groups
     filter_shape = [input_channel, num_filters // groups] + filter_size
 
@@ -4129,7 +4129,7 @@ def conv3d_transpose(input,
         if output_size is None:
             raise ValueError("output_size must be set when filter_size is None")
         if isinstance(output_size, int):
-            output_size = [output_size, output_size]
+            output_size = [output_size, output_size, output_size]
 
         d_in = input.shape[2] if data_format == 'NCDHW' else input.shape[1]
         h_in = input.shape[3] if data_format == 'NCDHW' else input.shape[2]
@@ -4149,6 +4149,13 @@ def conv3d_transpose(input,
     if len(padding) == 6 and utils._is_symmetric_padding(padding, 3):
         padding = [padding[0], padding[2], padding[4]]
 
+    if output_size is None:
+        output_size = []
+    elif isinstance(output_size, (list, tuple, int)):
+        output_size = utils.convert_to_list(output_size, 3, 'output_size')
+    else:
+        raise ValueError("output_size should be int, list[int] or tuple[int]")
+
     groups = 1 if groups is None else groups
     filter_shape = [input_channel, num_filters // groups] + filter_size
     img_filter = helper.create_parameter(
@@ -4166,6 +4173,7 @@ def conv3d_transpose(input,
                 'Filter': [img_filter]},
         outputs={'Output': pre_bias},
         attrs={
+            'output_size': output_size,
             'strides': stride,
             'paddings': padding,
             'padding_algorithm': padding_algorithm,

python/paddle/fluid/tests/unittests/test_functional_conv2d.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import paddle.nn.functional as F
+from paddle import fluid
+import paddle.fluid.dygraph as dg
+import paddle.fluid.initializer as I
+import numpy as np
+import unittest
+from unittest import TestCase
+
+
+class TestFunctionalConv2D(TestCase):
+    batch_size = 4
+    spatial_shape = (16, 16)
+    dtype = "float32"
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 2
+        else:
+            filter_shape = tuple(self.filter_shape)
+
+        self.weight = np.random.uniform(
+            -1, 1, (self.out_channels, self.in_channels // self.groups
+                    ) + filter_shape).astype(self.dtype)
+        if not self.no_bias:
+            self.bias = np.random.uniform(-1, 1, (
+                self.out_channels, )).astype(self.dtype)
+
+        self.channel_last = (self.data_format == "NHWC")
+        if self.channel_last:
+            self.input_shape = (self.batch_size, ) + self.spatial_shape + (
+                self.in_channels, )
+        else:
+            self.input_shape = (self.batch_size, self.in_channels
+                                ) + self.spatial_shape
+
+        self.input = np.random.uniform(-1, 1,
+                                       self.input_shape).astype(self.dtype)
+
+    def static_graph_case_1(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = fluid.data(
+                        "input", (-1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1),
+                        dtype=self.dtype)
+                y = fluid.layers.conv2d(
+                    x,
+                    self.out_channels,
+                    self.filter_shape,
+                    stride=self.stride,
+                    padding=self.padding,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    param_attr=I.NumpyArrayInitializer(self.weight),
+                    bias_attr=False
+                    if self.no_bias else I.NumpyArrayInitializer(self.bias),
+                    use_cudnn=self.use_cudnn,
+                    act=self.act,
+                    data_format=self.data_format)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        out, = exe.run(main, feed={"input": self.input}, fetch_list=[y])
+        return out
+
+    def static_graph_case_2(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight.shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias.shape, dtype=self.dtype)
+                y = F.conv2d(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        feed_dict = {"input": self.input, "weight": self.weight}
+        if not self.no_bias:
+            feed_dict["bias"] = self.bias
+        out, = exe.run(main, feed=feed_dict, fetch_list=[y])
+        return out
+
+    def dygraph_case(self):
+        with dg.guard(self.place):
+            x = dg.to_variable(self.input)
+            weight = dg.to_variable(self.weight)
+            bias = None if self.no_bias else dg.to_variable(self.bias)
+            y = F.conv2d(
+                x,
+                weight,
+                bias,
+                padding=self.padding,
+                stride=self.stride,
+                dilation=self.dilation,
+                act=self.act,
+                groups=self.groups,
+                data_format=self.data_format,
+                use_cudnn=self.use_cudnn)
+            out = y.numpy()
+        return out
+
+    def _test_identity(self):
+        self.prepare()
+        out1 = self.static_graph_case_1()
+        out2 = self.static_graph_case_2()
+        out3 = self.dygraph_case()
+        np.testing.assert_array_almost_equal(out1, out2)
+        np.testing.assert_array_almost_equal(out2, out3)
+
+    def test_identity_cpu(self):
+        self.place = fluid.CPUPlace()
+        self._test_identity()
+
+    @unittest.skipIf(not fluid.core.is_compiled_with_cuda(),
+                     "core is not compiled with CUDA")
+    def test_identity_gpu(self):
+        self.place = fluid.CUDAPlace(0)
+        self._test_identity()
+
+
+class TestFunctionalConv2DError(TestCase):
+    batch_size = 4
+    spatial_shape = (16, 16)
+    dtype = "float32"
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "not_valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+    def test_exception(self):
+        self.prepare()
+        with self.assertRaises(ValueError):
+            self.static_graph_case()
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 2
+        else:
+            filter_shape = tuple(self.filter_shape)
+        self.weight_shape = (self.out_channels, self.in_channels // self.groups
+                             ) + filter_shape
+        self.bias_shape = (self.out_channels, )
+
+    def static_graph_case(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                self.channel_last = self.data_format == "NHWC"
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight_shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias_shape, dtype=self.dtype)
+                y = F.conv2d(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+
+
+class TestFunctionalConv2DCase2(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase3(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 3, 1]
+        self.stride = 2
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase4(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 1, 2, 2]
+        self.stride = 1
+        self.dilation = 2
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase5(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 1], [2, 2], [0, 0]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase6(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [1, 1], [2, 2]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DCase7(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 6
+        self.out_channels = 8
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DCase8(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 6
+        self.out_channels = 12
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 6
+        self.no_bias = True
+        self.act = None
+        self.use_cudnn = False
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase2(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 2], [3, 4], [5, 6]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase3(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "not_valid"
+
+
+class TestFunctionalConv2DErrorCase4(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 3
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase6(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = "not_valid"
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase7(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "not_valid"
+
+
+class TestFunctionalConv2DErrorCase8(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 1, 2, 1]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase9(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = -5
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [3, 2], [1, 2]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase10(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NHWC"
+
+
+if __name__ == "__main__":
+    unittest.main()

python/paddle/fluid/tests/unittests/test_functional_conv2d_transpose.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import paddle.nn.functional as F
+from paddle import fluid
+import paddle.fluid.dygraph as dg
+import paddle.fluid.initializer as I
+import numpy as np
+import unittest
+from unittest import TestCase
+
+
+class TestFunctionalConv2D(TestCase):
+    batch_size = 4
+    spatial_shape = (16, 16)
+    dtype = "float32"
+    output_size = None
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 2
+        else:
+            filter_shape = tuple(self.filter_shape)
+
+        self.weight = np.random.uniform(
+            -1, 1, (self.in_channels, self.out_channels // self.groups
+                    ) + filter_shape).astype(self.dtype)
+        if not self.no_bias:
+            self.bias = np.random.uniform(-1, 1, (
+                self.out_channels, )).astype(self.dtype)
+
+        self.channel_last = (self.data_format == "NHWC")
+        if self.channel_last:
+            self.input_shape = (self.batch_size, ) + self.spatial_shape + (
+                self.in_channels, )
+        else:
+            self.input_shape = (self.batch_size, self.in_channels
+                                ) + self.spatial_shape
+
+        self.input = np.random.uniform(-1, 1,
+                                       self.input_shape).astype(self.dtype)
+
+    def static_graph_case_1(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = fluid.data(
+                        "input", (-1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1),
+                        dtype=self.dtype)
+                y = fluid.layers.conv2d_transpose(
+                    x,
+                    self.out_channels,
+                    output_size=self.output_size,
+                    filter_size=self.filter_shape,
+                    stride=self.stride,
+                    padding=self.padding,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    param_attr=I.NumpyArrayInitializer(self.weight),
+                    bias_attr=False
+                    if self.no_bias else I.NumpyArrayInitializer(self.bias),
+                    use_cudnn=self.use_cudnn,
+                    act=self.act,
+                    data_format=self.data_format)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        out, = exe.run(main, feed={"input": self.input}, fetch_list=[y])
+        return out
+
+    def static_graph_case_2(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight.shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias.shape, dtype=self.dtype)
+                y = F.conv2d_transpose(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    output_size=self.output_size,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        feed_dict = {"input": self.input, "weight": self.weight}
+        if not self.no_bias:
+            feed_dict["bias"] = self.bias
+        out, = exe.run(main, feed=feed_dict, fetch_list=[y])
+        return out
+
+    def dygraph_case(self):
+        with dg.guard(self.place):
+            x = dg.to_variable(self.input)
+            weight = dg.to_variable(self.weight)
+            bias = None if self.no_bias else dg.to_variable(self.bias)
+            y = F.conv2d_transpose(
+                x,
+                weight,
+                bias,
+                output_size=self.output_size,
+                padding=self.padding,
+                stride=self.stride,
+                dilation=self.dilation,
+                act=self.act,
+                groups=self.groups,
+                data_format=self.data_format,
+                use_cudnn=self.use_cudnn)
+            out = y.numpy()
+        return out
+
+    def _test_identity(self):
+        self.prepare()
+        out1 = self.static_graph_case_1()
+        out2 = self.static_graph_case_2()
+        out3 = self.dygraph_case()
+        np.testing.assert_array_almost_equal(out1, out2)
+        np.testing.assert_array_almost_equal(out2, out3)
+
+    def test_identity_cpu(self):
+        self.place = fluid.CPUPlace()
+        self._test_identity()
+
+    @unittest.skipIf(not fluid.core.is_compiled_with_cuda(),
+                     "core is not compiled with CUDA")
+    def test_identity_gpu(self):
+        self.place = fluid.CUDAPlace(0)
+        self._test_identity()
+
+
+class TestFunctionalConv2DError(TestCase):
+    batch_size = 4
+    spatial_shape = (16, 16)
+    dtype = "float32"
+    output_size = None
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "not_valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+    def test_exception(self):
+        self.prepare()
+        with self.assertRaises(ValueError):
+            self.static_graph_case()
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 2
+        else:
+            filter_shape = tuple(self.filter_shape)
+        self.weight_shape = (self.in_channels, self.out_channels // self.groups
+                             ) + filter_shape
+        self.bias_shape = (self.out_channels, )
+
+    def static_graph_case(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                self.channel_last = self.data_format == "NHWC"
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight_shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias_shape, dtype=self.dtype)
+                y = F.conv2d_transpose(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    output_size=self.output_size,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+
+
+class TestFunctionalConv2DCase2(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase3(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = True
+        self.act = None
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DCase4(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase5(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase6(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.stride = (1, 2)
+        self.dilation = (2, 1)
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase7(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.stride = (1, 2)
+        self.dilation = 1
+        self.groups = 4
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase8(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.output_size = [18, 34]
+        self.stride = (1, 2)
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DCase9(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 2], [2, 1], [0, 0]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DCase10(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [1, 1], [2, 2]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DCase11(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [1, 1, 2, 2]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DCase12(TestFunctionalConv2D):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [1, 2]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase2(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 2, 1, 3]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DErrorCase3(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [1, 2], [2, 1]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NHWC"
+
+
+class TestFunctionalConv2DErrorCase4(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 2], [0, 0], [2, 1]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase5(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = -2
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase6(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = "not_valid"
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase7(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.output_size = "not_valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+class TestFunctionalConv2DErrorCase8(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "not_valid"
+
+
+class TestFunctionalConv2DErrorCase9(TestFunctionalConv2DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCHW"
+
+
+if __name__ == "__main__":
+    unittest.main()

python/paddle/fluid/tests/unittests/test_functional_conv3d.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import paddle.nn.functional as F
+from paddle import fluid
+import paddle.fluid.dygraph as dg
+import paddle.fluid.initializer as I
+import numpy as np
+import unittest
+from unittest import TestCase
+
+
+class TestFunctionalConv3D(TestCase):
+    batch_size = 4
+    spatial_shape = (8, 8, 8)
+    dtype = "float32"
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 3
+        else:
+            filter_shape = tuple(self.filter_shape)
+
+        self.weight = np.random.uniform(
+            -1, 1, (self.out_channels, self.in_channels // self.groups
+                    ) + filter_shape).astype(self.dtype)
+        if not self.no_bias:
+            self.bias = np.random.uniform(-1, 1, (
+                self.out_channels, )).astype(self.dtype)
+
+        self.channel_last = (self.data_format == "NDHWC")
+        if self.channel_last:
+            self.input_shape = (self.batch_size, ) + self.spatial_shape + (
+                self.in_channels, )
+        else:
+            self.input_shape = (self.batch_size, self.in_channels
+                                ) + self.spatial_shape
+
+        self.input = np.random.uniform(-1, 1,
+                                       self.input_shape).astype(self.dtype)
+
+    def static_graph_case_1(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = fluid.data(
+                        "input", (-1, -1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1, -1),
+                        dtype=self.dtype)
+                y = fluid.layers.conv3d(
+                    x,
+                    self.out_channels,
+                    self.filter_shape,
+                    stride=self.stride,
+                    padding=self.padding,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    param_attr=I.NumpyArrayInitializer(self.weight),
+                    bias_attr=False
+                    if self.no_bias else I.NumpyArrayInitializer(self.bias),
+                    use_cudnn=self.use_cudnn,
+                    act=self.act,
+                    data_format=self.data_format)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        out, = exe.run(main, feed={"input": self.input}, fetch_list=[y])
+        return out
+
+    def static_graph_case_2(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight.shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias.shape, dtype=self.dtype)
+                y = F.conv3d(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        feed_dict = {"input": self.input, "weight": self.weight}
+        if not self.no_bias:
+            feed_dict["bias"] = self.bias
+        out, = exe.run(main, feed=feed_dict, fetch_list=[y])
+        return out
+
+    def dygraph_case(self):
+        with dg.guard(self.place):
+            x = dg.to_variable(self.input)
+            weight = dg.to_variable(self.weight)
+            bias = None if self.no_bias else dg.to_variable(self.bias)
+            y = F.conv3d(
+                x,
+                weight,
+                bias,
+                padding=self.padding,
+                stride=self.stride,
+                dilation=self.dilation,
+                act=self.act,
+                groups=self.groups,
+                data_format=self.data_format,
+                use_cudnn=self.use_cudnn)
+            out = y.numpy()
+        return out
+
+    def _test_identity(self):
+        self.prepare()
+        out1 = self.static_graph_case_1()
+        out2 = self.static_graph_case_2()
+        out3 = self.dygraph_case()
+        np.testing.assert_array_almost_equal(out1, out2)
+        np.testing.assert_array_almost_equal(out2, out3)
+
+    def test_identity_cpu(self):
+        self.place = fluid.CPUPlace()
+        self._test_identity()
+
+    @unittest.skipIf(not fluid.core.is_compiled_with_cuda(),
+                     "core is not compiled with CUDA")
+    def test_identity_gpu(self):
+        self.place = fluid.CUDAPlace(0)
+        self._test_identity()
+
+
+class TestFunctionalConv3DError(TestCase):
+    batch_size = 4
+    spatial_shape = (8, 8, 8)
+    dtype = "float32"
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "not_valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+    def test_exception(self):
+        self.prepare()
+        with self.assertRaises(ValueError):
+            self.static_graph_case()
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 3
+        else:
+            filter_shape = tuple(self.filter_shape)
+        self.weight_shape = (self.out_channels, self.in_channels // self.groups
+                             ) + filter_shape
+        self.bias_shape = (self.out_channels, )
+
+    def static_graph_case(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                self.channel_last = self.data_format == "NDHWC"
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight_shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias_shape, dtype=self.dtype)
+                y = F.conv3d(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+
+
+class TestFunctionalConv3DCase2(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 1]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DCase3(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 3, 1, 2, 3]
+        self.stride = 2
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DCase4(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 1, 2, 2, 3, 3]
+        self.stride = 1
+        self.dilation = 2
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DCase5(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 1], [2, 2], [1, 1], [0, 0]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DCase6(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [1, 1], [2, 2], [2, 2]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DCase7(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 6
+        self.out_channels = 8
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DCase8(TestFunctionalConv3D):
+    def setUp(self):
+        self.in_channels = 6
+        self.out_channels = 12
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 6
+        self.no_bias = True
+        self.act = None
+        self.use_cudnn = False
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DErrorCase2(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 1], [1, 2], [3, 4], [5, 6]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DErrorCase3(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "not_valid"
+
+
+class TestFunctionalConv3DErrorCase4(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 3
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DErrorCase6(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = "not_valid"
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DErrorCase7(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "not_valid"
+
+
+class TestFunctionalConv3DErrorCase8(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 1, 2, 1]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DErrorCase9(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = -5
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [3, 2], [1, 2], [1, 1]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DErrorCase10(TestFunctionalConv3DError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NDHWC"
+
+
+if __name__ == "__main__":
+    unittest.main()

python/paddle/fluid/tests/unittests/test_functional_conv3d_transpose.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import paddle.nn.functional as F
+from paddle import fluid
+import paddle.fluid.dygraph as dg
+import paddle.fluid.initializer as I
+import numpy as np
+import unittest
+from unittest import TestCase
+
+
+class TestFunctionalConv3DTranspose(TestCase):
+    batch_size = 4
+    spatial_shape = (8, 8, 8)
+    dtype = "float32"
+    output_size = None
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 3
+        else:
+            filter_shape = tuple(self.filter_shape)
+
+        self.weight = np.random.uniform(
+            -1, 1, (self.in_channels, self.out_channels // self.groups
+                    ) + filter_shape).astype(self.dtype)
+        if not self.no_bias:
+            self.bias = np.random.uniform(-1, 1, (
+                self.out_channels, )).astype(self.dtype)
+
+        self.channel_last = (self.data_format == "NDHWC")
+        if self.channel_last:
+            self.input_shape = (self.batch_size, ) + self.spatial_shape + (
+                self.in_channels, )
+        else:
+            self.input_shape = (self.batch_size, self.in_channels
+                                ) + self.spatial_shape
+
+        self.input = np.random.uniform(-1, 1,
+                                       self.input_shape).astype(self.dtype)
+
+    def static_graph_case_1(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = fluid.data(
+                        "input", (-1, -1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1, -1),
+                        dtype=self.dtype)
+                y = fluid.layers.conv3d_transpose(
+                    x,
+                    self.out_channels,
+                    output_size=self.output_size,
+                    filter_size=self.filter_shape,
+                    stride=self.stride,
+                    padding=self.padding,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    param_attr=I.NumpyArrayInitializer(self.weight),
+                    bias_attr=False
+                    if self.no_bias else I.NumpyArrayInitializer(self.bias),
+                    use_cudnn=self.use_cudnn,
+                    act=self.act,
+                    data_format=self.data_format)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        out, = exe.run(main, feed={"input": self.input}, fetch_list=[y])
+        return out
+
+    def static_graph_case_2(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight.shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias.shape, dtype=self.dtype)
+                y = F.conv3d_transpose(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    output_size=self.output_size,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+        exe = fluid.Executor(self.place)
+        exe.run(start)
+        feed_dict = {"input": self.input, "weight": self.weight}
+        if not self.no_bias:
+            feed_dict["bias"] = self.bias
+        out, = exe.run(main, feed=feed_dict, fetch_list=[y])
+        return out
+
+    def dygraph_case(self):
+        with dg.guard(self.place):
+            x = dg.to_variable(self.input)
+            weight = dg.to_variable(self.weight)
+            bias = None if self.no_bias else dg.to_variable(self.bias)
+            y = F.conv3d_transpose(
+                x,
+                weight,
+                bias,
+                output_size=self.output_size,
+                padding=self.padding,
+                stride=self.stride,
+                dilation=self.dilation,
+                act=self.act,
+                groups=self.groups,
+                data_format=self.data_format,
+                use_cudnn=self.use_cudnn)
+            out = y.numpy()
+        return out
+
+    def _test_identity(self):
+        self.prepare()
+        out1 = self.static_graph_case_1()
+        out2 = self.static_graph_case_2()
+        out3 = self.dygraph_case()
+        np.testing.assert_array_almost_equal(out1, out2)
+        np.testing.assert_array_almost_equal(out2, out3)
+
+    def test_identity_cpu(self):
+        self.place = fluid.CPUPlace()
+        self._test_identity()
+
+    @unittest.skipIf(not fluid.core.is_compiled_with_cuda(),
+                     "core is not compiled with CUDA")
+    def test_identity_gpu(self):
+        self.place = fluid.CUDAPlace(0)
+        self._test_identity()
+
+
+class TestFunctionalConv3DTransposeError(TestCase):
+    batch_size = 4
+    spatial_shape = (8, 8, 8)
+    dtype = "float32"
+    output_size = None
+
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = "not_valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+    def test_exception(self):
+        self.prepare()
+        with self.assertRaises(ValueError):
+            self.static_graph_case()
+
+    def prepare(self):
+        if isinstance(self.filter_shape, int):
+            filter_shape = (self.filter_shape, ) * 3
+        else:
+            filter_shape = tuple(self.filter_shape)
+        self.weight_shape = (self.in_channels, self.out_channels // self.groups
+                             ) + filter_shape
+        self.bias_shape = (self.out_channels, )
+
+    def static_graph_case(self):
+        main = fluid.Program()
+        start = fluid.Program()
+        with fluid.unique_name.guard():
+            with fluid.program_guard(main, start):
+                self.channel_last = self.data_format == "NDHWC"
+                if self.channel_last:
+                    x = x = fluid.data(
+                        "input", (-1, -1, -1, -1, self.in_channels),
+                        dtype=self.dtype)
+                else:
+                    x = fluid.data(
+                        "input", (-1, self.in_channels, -1, -1, -1),
+                        dtype=self.dtype)
+                weight = fluid.data(
+                    "weight", self.weight_shape, dtype=self.dtype)
+                if not self.no_bias:
+                    bias = fluid.data("bias", self.bias_shape, dtype=self.dtype)
+                y = F.conv3d_transpose(
+                    x,
+                    weight,
+                    None if self.no_bias else bias,
+                    output_size=self.output_size,
+                    padding=self.padding,
+                    stride=self.stride,
+                    dilation=self.dilation,
+                    groups=self.groups,
+                    act=self.act,
+                    data_format=self.data_format,
+                    use_cudnn=self.use_cudnn)
+
+
+class TestFunctionalConv3DTransposeCase2(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeCase3(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeCase4(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = "same"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = True
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeCase5(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.stride = (1, 2, 1)
+        self.dilation = (2, 1, 1)
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeCase6(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.stride = (1, 2, 1)
+        self.dilation = 1
+        self.groups = 4
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = False
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeCase7(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = "valid"
+        self.output_size = (10, 17, 10)
+        self.stride = (1, 2, 1)
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeCase8(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 2], [1, 2], [2, 1], [0, 0]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeCase9(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [1, 1], [1, 1], [2, 2]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeCase10(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [1, 1, 2, 2, 1, 1]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeCase11(TestFunctionalConv3DTranspose):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 6
+        self.filter_shape = 3
+        self.padding = [1, 2, 1]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeErrorCase2(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [1, 2, 2, 1, 3]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeErrorCase3(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [0, 0], [1, 1], [1, 2], [2, 1]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NDHWC"
+
+
+class TestFunctionalConv3DTransposeErrorCase4(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = [[0, 0], [1, 2], [1, 1], [0, 0], [2, 1]]
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeErrorCase5(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = -2
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeErrorCase6(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = "not_valid"
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeErrorCase7(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.output_size = "not_valid"
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+class TestFunctionalConv3DTransposeErrorCase8(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 4
+        self.out_channels = 5
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 1
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "not_valid"
+
+
+class TestFunctionalConv3DTransposeErrorCase9(
+        TestFunctionalConv3DTransposeError):
+    def setUp(self):
+        self.in_channels = 3
+        self.out_channels = 4
+        self.filter_shape = 3
+        self.padding = 0
+        self.stride = 1
+        self.dilation = 1
+        self.groups = 2
+        self.no_bias = False
+        self.act = "sigmoid"
+        self.use_cudnn = True
+        self.data_format = "NCDHW"
+
+
+if __name__ == "__main__":
+    unittest.main()

python/paddle/nn/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# TODO: import all neural network related api under this directory, 
+# TODO: import all neural network related api under this directory,
 # including layers, linear, conv, rnn etc.
 __all__ = []
 
@@ -85,10 +85,10 @@ from .layer import loss  #DEFINE_ALIAS
 # from .layer.common import Embedding   #DEFINE_ALIAS
 # from .layer.common import Linear   #DEFINE_ALIAS
 # from .layer.common import UpSample   #DEFINE_ALIAS
-# from .functional.conv import conv2d   #DEFINE_ALIAS
-# from .functional.conv import conv2d_transpose   #DEFINE_ALIAS
-# from .functional.conv import conv3d   #DEFINE_ALIAS
-# from .functional.conv import conv3d_transpose   #DEFINE_ALIAS
+from .functional.conv import conv2d  #DEFINE_ALIAS
+from .functional.conv import conv2d_transpose  #DEFINE_ALIAS
+from .functional.conv import conv3d  #DEFINE_ALIAS
+from .functional.conv import conv3d_transpose  #DEFINE_ALIAS
 # from .functional.loss import bpr_loss   #DEFINE_ALIAS
 # from .functional.loss import center_loss   #DEFINE_ALIAS
 # from .functional.loss import cross_entropy   #DEFINE_ALIAS

python/paddle/nn/functional/__init__.py

@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# TODO: import all neural network related api under this directory, 
+# TODO: import all neural network related api under this directory,
 # including layers, linear, conv, rnn etc.
 # __all__ = [ ]
 
 # TODO: define alias in functional directory
-# from .conv import conv2d   #DEFINE_ALIAS
-# from .conv import conv2d_transpose   #DEFINE_ALIAS
-# from .conv import conv3d   #DEFINE_ALIAS
-# from .conv import conv3d_transpose   #DEFINE_ALIAS
+from .conv import conv2d  #DEFINE_ALIAS
+from .conv import conv2d_transpose  #DEFINE_ALIAS
+from .conv import conv3d  #DEFINE_ALIAS
+from .conv import conv3d_transpose  #DEFINE_ALIAS
 # from .loss import bpr_loss   #DEFINE_ALIAS
 # from .loss import center_loss   #DEFINE_ALIAS
 # from .loss import cross_entropy   #DEFINE_ALIAS

python/setup.py.in

@@ -146,7 +146,10 @@ packages=['paddle',
           'paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler',
           'paddle.fluid.incubate.fleet.parameter_server.pslib',
           'paddle.fluid.incubate.fleet.collective',
-          'paddle.fluid.incubate.fleet.utils']
+          'paddle.fluid.incubate.fleet.utils',
+          'paddle.nn',
+          'paddle.nn.functional',
+          'paddle.nn.layer']
 
 with open('@PADDLE_SOURCE_DIR@/python/requirements.txt') as f:
     setup_requires = f.read().splitlines()