implementation of simple conv2d layer (#4868)

* Implement FC layer with helper

* Update LayerHelper

* Add debug string for Python ProtoBuf

and Rename `Sync` to `Flush`

* Add check of ProtoBuf initialization

* Layer wrapper for FC

* Fix unittest

* Fix CI

* Add code generator

* AttributeChecker Better error log and speicalize bool

Since lots of types can be cast to bool

* Complete mlp, fit_a_line

* Implementation of simple conv_2d layer

* Fix bugs

* Remove debug code

python/paddle/v2/framework/framework.py

@@ -232,7 +232,7 @@ class Operator(object):
         if attrs is not None:
             for attr in proto.attrs:
                 attr_name = attr.name
-                if not attr_name in attrs:
+                if (not attr_name in attrs) or (attrs[attr_name] is None):
                     continue
                 if not isinstance(attrs[attr_name], Block):
                     self.desc.set_attr(attr_name, attrs[attr_name])

python/paddle/v2/framework/layer_helper.py

@@ -66,15 +66,15 @@ class LayerHelper(object):
         actual = self.kwargs.get('param_attr', None)
         return actual if actual is not None else default
 
-    def bias_attr(self, size, dtype):
-        bias_attr = self.kwargs.get('bias_attr', False)
-        if bias_attr is None or bias_attr:
+    def bias_attr(self, shape, dtype):
+        bias_attr = self.kwargs.get('bias_attr', None)
+        if bias_attr is True:
             bias_attr = {
                 'name': None,
                 'init_attr': {
                     'type': 'fill_constant',
                     'value': 0.0,
-                    'shape': [size],
+                    'shape': shape,
                     'dataType': dtype
                 }
             }
@@ -127,15 +127,13 @@ class LayerHelper(object):
         return self.program.global_block().create_var(*args, **kwargs)
 
     def append_bias_op(self, input_var):
-        bias_attr = self.bias_attr(
-            self.kwargs['size'], dtype=input_var.data_type)
+        size = list(input_var.shape[1:])
+        bias_attr = self.bias_attr(size, dtype=input_var.data_type)
         if not bias_attr:
             return input_var
+
         b = self.create_parameter(
-            attr=bias_attr,
-            shape=[self.kwargs['size']],
-            dtype=input_var.data_type,
-            suffix='b')
+            attr=bias_attr, shape=size, dtype=input_var.data_type, suffix='b')
         tmp = self.create_tmp_variable(dtype=input_var.data_type)
         self.append_op(
             type='elementwise_add',

python/paddle/v2/framework/layers.py

@@ -3,7 +3,7 @@ import paddle.v2.framework.core as core
 from paddle.v2.framework.framework import OpProtoHolder, Variable
 import re
 
-__all__ = ['fc_layer', 'data_layer', 'cross_entropy']
+__all__ = ['fc_layer', 'data_layer', 'cross_entropy', 'conv2d_layer']
 
 
 def fc_layer(input,
@@ -24,6 +24,7 @@ def fc_layer(input,
     for input_var, param_attr in helper.iter_inputs_and_params():
         input_shape = input_var.shape
         param_shape = list(input_shape[num_flatten_dims:]) + [size]
+
         w = helper.create_parameter(
             attr=param_attr, shape=param_shape, dtype=dtype)
         tmp = helper.create_tmp_variable(dtype)
@@ -111,6 +112,7 @@ def _create_op_func_(op_type):
 
 
 _create_op_func_('mean')
+_create_op_func_('pool2d')
 
 
 def cross_entropy(input, label, **kwargs):
@@ -141,3 +143,47 @@ def square_error_cost(input, label, **kwargs):
         outputs={'Y': [square_out]},
         attrs={'factor': 2.0})
     return square_out
+
+
+def conv2d_layer(input,
+                 num_filters,
+                 name=None,
+                 filter_size=[1, 1],
+                 act=None,
+                 groups=None,
+                 stride=[1, 1],
+                 padding=None,
+                 bias_attr=None,
+                 param_attr=None,
+                 program=None):
+    helper = LayerHelper('conv2d', **locals())
+    dtype = helper.input_dtype()
+
+    num_channels = input.shape[1]
+    if groups is None:
+        num_filter_channels = num_channels
+    else:
+        if num_channels % groups is not 0:
+            raise ValueError("num_channels must be divisible by groups.")
+        num_filter_channels = num_channels / groups
+
+    input_shape = input.shape
+    filter_shape = [num_filters, num_filter_channels] + filter_size
+    filter = helper.create_parameter(
+        attr=helper.param_attr, shape=filter_shape, dtype=dtype)
+    pre_bias = helper.create_tmp_variable(dtype)
+
+    helper.append_op(
+        type='conv2d',
+        inputs={
+            'Input': input,
+            'Filter': filter,
+        },
+        outputs={"Output": pre_bias},
+        attrs={'strides': stride,
+               'paddings': padding,
+               'groups': groups})
+
+    pre_act = helper.append_bias_op(pre_bias)
+
+    return helper.append_activation(pre_act)

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

-from paddle.v2.framework.layers import fc_layer, data_layer, cross_entropy, mean, square_error_cost
+from paddle.v2.framework.layers import fc_layer, data_layer, cross_entropy, mean, square_error_cost, conv2d_layer
 from paddle.v2.framework.framework import Program, g_program
 import paddle.v2.framework.core as core
 import unittest
@@ -38,6 +38,16 @@ class TestBook(unittest.TestCase):
         self.assertIsNotNone(avg_cost)
         print str(program)
 
+    def test_simple_conv2d(self):
+        pd = core.ProgramDesc.__create_program_desc__()
+        program = Program(desc=pd)
+        images = data_layer(
+            name='pixel', shape=[3, 48, 48], data_type='int32', program=program)
+        conv2d_layer(
+            input=images, num_filters=3, filter_size=[4, 4], program=program)
+
+        print str(program)
+
 
 if __name__ == '__main__':
     unittest.main()