Merge pull request #5651 from emailweixu/fix_conv_bias

Fix conv2d bias

python/paddle/v2/fluid/io.py

@@ -165,7 +165,7 @@ def save_inference_model(dirname,
     :param target_vars: Variables from which we can get inference results.
     :param executor: executor that save inference model
     :param main_program: original program, which will be pruned to build the inference model.
-    Default g_program.
+    Default g_main_program.
 
     :return: None
     """
@@ -234,3 +234,35 @@ def load_inference_model(dirname, executor):
     fetch_vars = [program.global_block().var(name) for name in fetch_var_names]
 
     return [program, feed_var_names, fetch_vars]
+
+
+def get_parameter_value(para, executor):
+    """
+    Get the LoDTensor for the parameter
+
+    :param executor: executor for retrieving the value
+    :param para: the given parameter
+    :return: the LoDTensor for the parameter
+    """
+    assert is_parameter(para)
+
+    get_program = Program()
+    block = get_program.global_block()
+    new_var = _clone_var_in_block_(block, para)
+    return executor.run(get_program, feed={}, fetch_list=[new_var])[0]
+
+
+def get_parameter_value_by_name(name, executor, program=None):
+    """
+    Get the LoDTensor for paramter with the given name
+
+    :param executor: executor for retrieving the value
+    :param name: the name of the parameter
+    :param program: the program where the variable is found
+    Default g_main_program.
+    :return: the LoDTensor for the variable
+    """
+    if program is None:
+        program = g_main_program
+    var = program.global_block().var(name)
+    return get_parameter_value(var, executor)

python/paddle/v2/fluid/layer_helper.py

@@ -72,7 +72,7 @@ class LayerHelper(object):
 
     @property
     def bias_attr(self):
-        default = {'name': None, 'initializer': XavierInitializer()}
+        default = {'name': None, 'initializer': ConstantInitializer()}
         bias_attr = self.kwargs.get('bias_attr', None)
         if bias_attr is None:
             bias_attr = default
@@ -149,24 +149,19 @@ class LayerHelper(object):
             persistable=True,
             initializer=initializer)
 
-    def append_bias_op(self, input_var, num_flatten_dims=None):
+    def append_bias_op(self, input_var, dim_start=1, dim_end=None):
         """
         Append bias operator and return its output. If the user does not set
         bias_attr, append_bias_op will return input_var
 
         :param input_var: the input variable. The len(input_var.shape) is larger
         or equal than 2.
-        :param num_flatten_dims: The input tensor will be flatten as a matrix 
-        when adding bias.
-        `matrix.shape = product(input_var.shape[0:num_flatten_dims]), product(
-                input_var.shape[num_flatten_dims:])`
+        :param dim_start:
+        :param dim_end: the shape of the bias will be
+        input_var.shape[dim_start:dim_end]. The bias is broadcasted to other
+        dimensions and added to input_var to get the output
         """
-        if num_flatten_dims is None:
-            num_flatten_dims = self.kwargs.get('num_flatten_dims', None)
-            if num_flatten_dims is None:
-                num_flatten_dims = 1
-
-        size = list(input_var.shape[num_flatten_dims:])
+        size = list(input_var.shape[dim_start:dim_end])
         bias_attr = self.bias_attr
         if not bias_attr:
             return input_var
@@ -178,7 +173,8 @@ class LayerHelper(object):
             type='elementwise_add',
             inputs={'X': [input_var],
                     'Y': [b]},
-            outputs={'Out': [tmp]})
+            outputs={'Out': [tmp]},
+            attrs={'axis': dim_start})
         return tmp
 
     def append_activation(self, input_var):

python/paddle/v2/fluid/layers.py

@@ -694,7 +694,7 @@ def conv2d(input,
                'paddings': padding,
                'groups': groups})
 
-    pre_act = helper.append_bias_op(pre_bias, 1)
+    pre_act = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
 
     return helper.append_activation(pre_act)
 

python/paddle/v2/fluid/tests/test_parameter.py

 import unittest
 from paddle.v2.fluid.framework import g_main_program
 import paddle.v2.fluid.core as core
+from paddle.v2.fluid.executor import Executor
+import paddle.v2.fluid.io as io
+from paddle.v2.fluid.initializer import ConstantInitializer
+import numpy as np
 
 
 class TestParameter(unittest.TestCase):
     def test_param(self):
-        b = g_main_program.create_block()
+        shape = [784, 100]
+        val = 1.0625
+        b = g_main_program.global_block()
         param = b.create_parameter(
             name='fc.w',
-            shape=[784, 100],
+            shape=shape,
             dtype='float32',
-            initialize_attr={
-                'type': 'uniform_random',
-                'seed': 13,
-                'min': -5.0,
-                'max': 5.0
-            })
+            initializer=ConstantInitializer(val))
         self.assertIsNotNone(param)
         self.assertEqual('fc.w', param.name)
         self.assertEqual((784, 100), param.shape)
         self.assertEqual(core.DataType.FP32, param.data_type)
         self.assertEqual(0, param.block.idx)
+        exe = Executor(core.CPUPlace())
+        p = exe.run(g_main_program, fetch_list=[param])[0]
+        self.assertTrue(np.allclose(np.array(p), np.ones(shape) * val))
+        p = io.get_parameter_value_by_name('fc.w', exe, g_main_program)
+        self.assertTrue(np.allclose(np.array(p), np.ones(shape) * val))
 
 
 if __name__ == '__main__':