Add unit test

python/paddle/v2/framework/tests/test_conv3d_op.py

+import unittest
+import numpy as np
+from op_test import OpTest
+
+
+class TestConv3dOp(OpTest):
+    def setUp(self):
+        self.init_groups()
+        self.op_type = "conv3d"
+        batch_size = 2
+        input_channels = 3
+        input_depth = 5
+        input_height = 5
+        input_width = 5
+        output_channels = 6
+        filter_depth = 3
+        filter_height = 3
+        filter_width = 3
+        stride = 1
+        padding = 0
+        output_depth = (input_depth - filter_depth + 2 * padding) / stride + 1
+        output_height = (input_height - filter_height + 2 * padding
+                         ) / stride + 1
+        output_width = (input_width - filter_width + 2 * padding) / stride + 1
+        input = np.random.random((batch_size, input_channels, input_depth,
+                                  input_height, input_width)).astype("float32")
+
+        filter = np.random.random(
+            (output_channels, input_channels / self.groups, filter_depth,
+             filter_height, filter_width)).astype("float32")
+        output = np.ndarray((batch_size, output_channels, output_depth,
+                             output_height, output_width))
+
+        self.inputs = {'Input': input, 'Filter': filter}
+        self.attrs = {
+            'strides': [1, 1, 1],
+            'paddings': [0, 0, 0],
+            'groups': self.groups
+        }
+
+        output_group_channels = output_channels / self.groups
+        input_group_channels = input_channels / self.groups
+        for batchid in xrange(batch_size):
+            for group in xrange(self.groups):
+                for outchannelid in range(group * output_group_channels,
+                                          (group + 1) * output_group_channels):
+                    for deepid in xrange(output_depth):
+                        for rowid in xrange(output_height):
+                            for colid in xrange(output_width):
+                                start_d = (deepid * stride) - padding
+                                start_h = (rowid * stride) - padding
+                                start_w = (colid * stride) - padding
+                                output_value = 0.0
+                                for inchannelid in range(
+                                        group * input_group_channels,
+                                    (group + 1) * input_group_channels):
+                                    for fdeepid in xrange(filter_depth):
+                                        for frowid in xrange(filter_height):
+                                            for fcolid in xrange(filter_width):
+                                                input_value = 0.0
+                                                indeepid = start_d + fdeepid
+                                                inrowid = start_h + frowid
+                                                incolid = start_w + fcolid
+                                                if ((indeepid >= 0 and
+                                                     indeepid < input_depth) and
+                                                    (inrowid >= 0 and
+                                                     inrowid < input_height) and
+                                                    (incolid >= 0 and
+                                                     incolid < input_width)):
+
+                                                    input_value = input[
+                                                        batchid][inchannelid][
+                                                            indeepid][inrowid][
+                                                                incolid]
+                                                filter_value = filter[
+                                                    outchannelid][
+                                                        inchannelid %
+                                                        input_group_channels][
+                                                            fdeepid][frowid][
+                                                                fcolid]
+                                                output_value += input_value * filter_value
+                                output[batchid][outchannelid][deepid][rowid][
+                                    colid] = output_value
+
+        self.outputs = {'Output': output}
+
+    def test_check_output(self):
+        self.check_output()
+
+    def test_check_grad(self):
+        self.check_grad(
+            set(['Input', 'Filter']), 'Output', max_relative_error=0.05)
+
+    def test_check_grad_no_filter(self):
+        self.check_grad(
+            ['Input'],
+            'Output',
+            max_relative_error=0.05,
+            no_grad_set=set(['Filter']))
+
+    def test_check_grad_no_input(self):
+        self.check_grad(
+            ['Filter'],
+            'Output',
+            max_relative_error=0.05,
+            no_grad_set=set(['Input']))
+
+    def init_groups(self):
+        self.groups = 1
+
+
+class TestWithGroup(TestConv3dOp):
+    def init_groups(self):
+        self.groups = 3
+
+
+if __name__ == '__main__':
+    unittest.main()