fix comment

Author: zhwesky2010

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

@@ -89,18 +89,20 @@ def test_exception(self):
 
  def test_parambase_to_vector(self):
  with guard():
- linear1 = paddle.nn.Linear(
- 10,
- 15,
- paddle.ParamAttr(
- initializer=paddle.nn.initializer.Constant(3.)))
+ initializer = paddle.ParamAttr(
+ initializer=paddle.nn.initializer.Constant(3.))
+ linear1 = paddle.nn.Linear(10, 15, initializer)
 
  vec = paddle.nn.utils.parameters_to_vector(linear1.parameters())
+ self.assertEqual(linear1.weight.shape, [10, 15])
+ self.assertEqual(linear1.bias.shape, [15])
  self.assertTrue(isinstance(vec, Variable))
  self.assertTrue(vec.shape, [165])
 
  linear2 = paddle.nn.Linear(10, 15)
  paddle.nn.utils.vector_to_parameters(vec, linear2.parameters())
+ self.assertEqual(linear2.weight.shape, [10, 15])
+ self.assertEqual(linear2.bias.shape, [15])
  self.assertTrue(
  np.array_equal(linear1.weight.numpy(), linear2.weight.numpy()),
  True)
@@ -110,30 +112,6 @@ def test_parambase_to_vector(self):
  self.assertTrue(linear2.weight.is_leaf, True)
  self.assertTrue(linear2.bias.is_leaf, True)
 
- def test_parameter_to_vector(self):
- main_program = paddle.static.Program()
- start_program = paddle.static.Program()
- with paddle.static.program_guard(main_program, start_program):
- linear1 = paddle.nn.Linear(
- 10,
- 15,
- paddle.ParamAttr(
- initializer=paddle.nn.initializer.Constant(3.)))
-
- vec = paddle.nn.utils.parameters_to_vector(linear1.parameters())
- self.assertTrue(isinstance(vec, Variable))
- self.assertTrue(vec.shape, [165])
-
- linear2 = paddle.nn.Linear(10, 15)
- paddle.nn.utils.vector_to_parameters(vec, linear2.parameters())
-
- exe = paddle.static.Executor()
- exe.run(start_program)
- outs = exe.run(main_program,
- fetch_list=[linear1.parameters(), linear2.parameters()])
- self.assertTrue(np.array_equal(outs[0], outs[2]))
- self.assertTrue(np.array_equal(outs[1], outs[3]))
-
 
 if __name__ == '__main__':
  unittest.main()

python/paddle/nn/utils/transform_parameters.py

@@ -15,12 +15,23 @@
 from functools import reduce
 
 import paddle
-from paddle.fluid.framework import Variable, in_dygraph_mode
-from paddle.fluid.layer_helper import LayerHelper
-from paddle.fluid.data_feeder import check_variable_and_dtype
+from paddle.fluid.framework import dygraph_only, _dygraph_tracer, _varbase_creator
 from paddle import _C_ops
 
 
+#input==output, inplace strategy of reshape has no cost almostly
+def _inplace_reshape_dygraph(x, shape):
+ x_shape = _varbase_creator(dtype=x.dtype)
+ _dygraph_tracer().trace_op(
+ type="reshape2",
+ inputs={'X': x},
+ outputs={'Out': x,
+ 'XShape': x_shape},
+ attrs={'shape': shape},
+ stop_gradient=True)
+
+
+@dygraph_only
 def parameters_to_vector(parameters, name=None):
  """
  Flatten parameters to a 1-D Tensor.
@@ -44,44 +55,25 @@ def parameters_to_vector(parameters, name=None):
  # 1-D Tensor: [165]
 
  """
- vec_list = []
- if in_dygraph_mode():
- for param in parameters:
- vec, _ = _C_ops.reshape2(param, None, 'shape', [-1])
- vec_list.append(vec)
- return _C_ops.concat(vec_list, 'axis', 0)
-
- helper = LayerHelper("parameters_to_vector", **locals())
- param_dtype = parameters[0].dtype
- for id, param in enumerate(parameters):
- check_variable_and_dtype(
- param, 'parameters[{}]'.format(id),
- ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
- "parameters_to_vector")
- if param.dtype != param_dtype:
- raise TypeError(
- "All the Tensors in the parameters must have the same data type."
- )
- vec = helper.create_variable_for_type_inference(dtype=param_dtype)
- x_shape = helper.create_variable_for_type_inference(dtype=param_dtype)
- # use View strategy that don't have Tensor Copy
- helper.append_op(
- type='reshape2',
- inputs={'X': param},
- outputs={'Out': vec,
- 'XShape': x_shape},
- attrs={'shape': [-1]})
- vec_list.append(vec)
-
- param_vec = helper.create_variable_for_type_inference(dtype=param_dtype)
- helper.append_op(
+ dtype = parameters[0].dtype
+ origin_shapes = []
+ for param in parameters:
+ origin_shapes.append(param.shape)
+ _inplace_reshape_dygraph(param, [-1])
+
+ out = _varbase_creator(dtype=dtype)
+ _dygraph_tracer().trace_op(
  type='concat',
- inputs={'X': vec_list},
- outputs={'Out': param_vec},
- attrs={'axis': 0})
- return param_vec
+ inputs={'X': parameters},
+ outputs={'Out': [out]},
+ attrs={'axis': 0},
+ stop_gradient=True)
+ for i, param in enumerate(parameters):
+ _inplace_reshape_dygraph(param, origin_shapes[i])
+ return out
 
 
+@dygraph_only
 def vector_to_parameters(vec, parameters, name=None):
  """
  Transform a Tensor with 1-D shape to the parameters.
@@ -109,61 +101,22 @@ def vector_to_parameters(vec, parameters, name=None):
  # [..., ..., ...],
  # [3. , ..., 3. ]])
  """
- start = 0
- helper = LayerHelper("vector_to_parameters", **locals())
- if in_dygraph_mode():
- with paddle.no_grad():
- for param in parameters:
- shape = param.shape
- numel = reduce(lambda x, y: x * y, shape)
- end = start + numel
- slice_data = _C_ops.slice(vec, None, None, 'axes', [0],
- 'infer_flags', [1], 'starts',
- [start], 'ends', [end])
- _C_ops.reshape2_(slice_data, None, 'shape', shape)
- helper.append_op(
- type='assign',
- inputs={'X': slice_data},
- outputs={'Out': param})
- start += numel
- return
-
- check_variable_and_dtype(
- vec, 'x', ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
- "vector_to_parameters")
- assert len(vec.shape) == 1, "'vec' must be a Tensor with 1-D shape."
-
+ origin_shapes = []
+ sections = []
  for param in parameters:
  shape = param.shape
+ origin_shapes.append(shape)
  numel = reduce(lambda x, y: x * y, shape)
- end = start + numel
-
- slice_data = helper.create_variable_for_type_inference(
- dtype=param.dtype)
- helper.append_op(
- type='slice',
- inputs={'Input': vec},
- outputs={'Out': slice_data},
- attrs={
- 'axes': [0],
- 'infer_flags': [1],
- 'starts': [start],
- 'ends': [end]
- })
-
- # avoid backward for parameters
- slice_data.stop_gradient = True
- x_shape = helper.create_variable_for_type_inference(dtype=param.dtype)
- out = helper.create_variable_for_type_inference(dtype=param.dtype)
-
- # use Inplace strategy that don't have Tensor Copy
- helper.append_op(
- type='reshape2',
- inputs={'X': slice_data},
- outputs={'Out': slice_data,
- 'XShape': x_shape},
- attrs={'shape': shape})
-
- helper.append_op(
- type='assign', inputs={'X': slice_data}, outputs={'Out': param})
- start += numel
+ sections.append(numel)
+
+ _dygraph_tracer().trace_op(
+ type='split',
+ inputs={'X': [vec]},
+ outputs={'Out': parameters},
+ attrs={'axis': 0,
+ 'sections': sections},
+ stop_gradient=True)
+
+ for i, param in enumerate(parameters):
+ _inplace_reshape_dygraph(param, origin_shapes[i])
+ return