def test_register_buffer_with_error(self):
with fluid.dygraph.guard():
net = fluid.Layer()
var = to_variable(np.zeros([1]))
with self.assertRaisesRegexp(TypeError,
"name of buffer should be a string"):
net.register_buffer(12, var)
with self.assertRaisesRegexp(TypeError,
"buffer should be a core.VarBase"):
net.register_buffer("buffer_name", ParamBase([2, 2],
'float32'))
with self.assertRaisesRegexp(KeyError,
"name of buffer can not contain"):
net.register_buffer("buffer.name", var)
with self.assertRaisesRegexp(KeyError,
"name of buffer can not be empty"):
net.register_buffer("", var)
net.attr_name = 10
with self.assertRaisesRegexp(KeyError, "already exists"):
net.register_buffer("attr_name", var)
del net.attr_name
net.attr_name = ParamBase([2, 2], 'float32')
with self.assertRaisesRegexp(KeyError, "already exists"):
net.register_buffer("attr_name", var)
def _VarBaseWrapper(param):
varbase = param.fw_storage
tmp_param = ParamBase(shape=varbase.shape,
dtype=varbase.dtype,
name="slice@" + param.name)
varbase._share_buffer_to(tmp_param)
tmp_param.regularizer = param.regularizer
tmp_param.optimize_attr['learning_rate'] = param.optimize_attr[
'learning_rate']
varbase._clear()
return tmp_param
def flatten_dense_tensors(parameters):
"""
flatten dense tensors
"""
_buffer_size = 0
_param2align = {}
dtype = parameters[0].dtype
stop_gradient = parameters[0].stop_gradient
state = copy.deepcopy(parameters[0].__dict__)
for param in parameters:
assert str(state) == str(param.__dict__)
size = np.prod(param.shape) * align[dtype]
remaining = size % alignment["gpu"]
ali = 0 if remaining == 0 else alignment["gpu"] - remaining
align_ = ali // align[dtype]
_buffer_size += np.prod(param.shape) + align_
_param2align[param.name] = align_
param_storage = ParamStorage(size=_buffer_size, dtype=dtype, device="gpu")
param_storage.add_rank_params(parameters, _param2align)
# process gradient
# grad_storage = None
grad_storage = GradStorage(size=_buffer_size,
dtype=dtype,
device="gpu",
destination="0",
parm2align=_param2align)
for param in parameters:
grad_storage.add_grad(param, _param2align[param.name])
fused_param = ParamBase(shape=param_storage.buffer.shape,
dtype=dtype,
name=unique_name.generate('fused_param'))
param_storage.buffer._share_buffer_to(fused_param)
fused_param._copy_gradient_from(grad_storage.buffer)
fused_param.__dict__.update(state)
fused_param.stop_gradient = stop_gradient
return fused_param
def func_test_register_buffer_with_error(self):
with fluid.dygraph.guard():
net = fluid.Layer()
var = to_variable(np.zeros([1]))
with self.assertRaisesRegexp(TypeError,
"name of buffer should be a string"):
net.register_buffer(12, var)
with self.assertRaisesRegexp(TypeError,
"buffer should be a Paddle.Tensor"):
if in_dygraph_mode():
net.register_buffer("buffer_name",
EagerParamBase([2, 2], 'float32'))
else:
net.register_buffer("buffer_name",
ParamBase([2, 2], 'float32'))
with self.assertRaisesRegexp(KeyError,
"name of buffer can not contain"):
net.register_buffer("buffer.name", var)
with self.assertRaisesRegexp(KeyError,
"name of buffer can not be empty"):
net.register_buffer("", var)
net.attr_name = 10
with self.assertRaisesRegexp(KeyError, "already exists"):
net.register_buffer("attr_name", var)
del net.attr_name
if in_dygraph_mode():
net.attr_name = EagerParamBase([2, 2], 'float32')
else:
net.attr_name = ParamBase([2, 2], 'float32')
with self.assertRaisesRegexp(KeyError, "already exists"):
net.register_buffer("attr_name", var)
def test_buffer_not_persistable_assign(self):
with fluid.dygraph.guard():
net = fluid.Layer()
var1 = to_variable(np.zeros([1]))
net.register_buffer("buffer_name", var1, persistable=False)
# Assigning Nones will remove the buffer, but allow to re-assign
# to remark it as buffer.
net.buffer_name = None
self.assertEqual(len(net.buffers()), 0)
self.assertEqual(len(net.state_dict()), 0)
net.buffer_name = var1
self.assertEqual(len(net.buffers()), 1)
self.assertEqual(len(net.state_dict()), 0)
# Re-assign a ParamBase will remove the buffer.
net.buffer_name = ParamBase([2, 2], 'float32')
self.assertEqual(len(net.buffers()), 0)
self.assertEqual(len(net.state_dict()), 1)