def test_concrete_program(self):
with fluid.dygraph.guard(fluid.CPUPlace()):
x = to_variable(np.ones([4, 10]).astype('float32'))
y = to_variable(np.ones([4, 10]).astype('float32') * 2)
int_val = 4.
net = SimpleNet()
# We can get concrete_program by specificing InputSpec information. Faking input is no need.
net.add_func = declarative(net.add_func,
input_spec=[
InputSpec([-1, 10]),
InputSpec([-1, 10], name='y')
])
cp1 = net.add_func.concrete_program
self.assertTrue(cp1.inputs[-1].shape == (-1, 10))
self.assertTrue(cp1.inputs[-1].name == 'y')
# generate another program
net.add_func = declarative(
net.add_func,
input_spec=[InputSpec([10]),
InputSpec([10], name='label')])
cp2 = net.add_func.concrete_program
self.assertTrue(cp2.inputs[-1].shape == (10, ))
self.assertTrue(cp2.inputs[-1].name == 'label')
# Note(Aurelius84): New instance will be returned if we use `declarative(foo)` every time.
# So number of cache program is 1.
self.assertTrue(len(net.add_func.program_cache) == 1)
self.assertTrue(cp1 != cp2)
def test_input_spec(self):
net = SimpleNet()
net = declarative(net, input_spec=[InputSpec([None, 8, 10])])
self.assertTrue(len(net.forward.inputs) == 1)
self.assertTrue(len(net.forward.program_cache) == 1)
input_shape = net.forward.inputs[0].shape
self.assertListEqual(list(input_shape), [-1, 8, 10])
# redecorate
net = declarative(net, input_spec=[InputSpec([None, 16, 10])])
input_shape = net.forward.inputs[0].shape
self.assertListEqual(list(input_shape), [-1, 16, 10])
def test_with_different_input(self):
with fluid.dygraph.guard(fluid.CPUPlace()):
x_data = np.ones([16, 10]).astype('float32')
y_data = np.ones([10]).astype('float32') * 2
z_data = np.ones([10]).astype('float32') * 2.2
foo = declarative(foo_func)
# [16, 10] + [10] (varbase)
out_1 = foo(to_variable(x_data), to_variable(y_data))
self.assertTrue(np.allclose(x_data + y_data, out_1.numpy()))
self.assertTrue(len(foo.program_cache) == 1)
self.assertTrue(len(foo.program_cache.concrete_programs()) == 1)
# [16, 10] + [10] (numpy)
out_2 = foo(to_variable(x_data), y_data)
self.assertTrue(np.allclose(x_data + y_data, out_2.numpy()))
self.assertTrue(len(foo.program_cache) == 1)
# [16, 10] + [10] (numpy)
out_3 = foo(to_variable(x_data), z_data)
self.assertTrue(np.allclose(x_data + z_data, out_3.numpy()))
# hit cache program
self.assertTrue(len(foo.program_cache) == 1)
# [16, 10] + [10] (numpy) with other different arguments (c=3)
out_4 = foo(to_variable(x_data), z_data, 3)
self.assertTrue(np.allclose(x_data + z_data, out_4.numpy()))
# create a new program
self.assertTrue(len(foo.program_cache) == 2)
def test_with_input_spec(self):
with fluid.dygraph.guard(fluid.CPUPlace()):
x = to_variable(np.ones([4, 10]).astype('float32'))
y = to_variable(np.ones([4, 10]).astype('float32') * 2)
int_val = 4.
net = SimpleNet()
# 1. each method holds independent program cache
out = net(x)
self.assertTrue(len(net.forward.program_cache) == 1)
# 2. test save load
net.inner_function(x)
jit.save(net, './simple_net')
infer_net = fluid.dygraph.jit.load('./simple_net')
pred = infer_net(x)
self.assertTrue(np.allclose(out.numpy(), pred.numpy()))
# 3. we can decorate any method
x_2 = to_variable(np.ones([4, 20]).astype('float32'))
# uses `declarative(func)` instead of `@declarative`
net.add_func = declarative(net.add_func)
out = net.add_func(x_2, np.ones([20]).astype('float32'))
self.assertTrue(len(net.add_func.program_cache) == 1)
# 5. test input with list
out = net.func_with_list([x, y], int_val)
# 6. test input with dict
out = net.func_with_dict({'x': x, 'y': y})
# 7. test input with lits contains dict
int_np = np.ones([1]).astype('float32')
out = net.func_with_list_dict([int_np, {'x': x, 'y': y}])
def test_get_concrete_program(self):
foo = declarative(foo_func)
# 1. specific InputSpec for `x`/`y`
concrete_program_1 = foo.get_concrete_program(
InputSpec([None, 10]), InputSpec([10]))
self.assertTrue(len(foo.program_cache) == 1)
# 2. specific `c`/`d` explicitly with same default value
concrete_program_2 = foo.get_concrete_program(
InputSpec([None, 10]), InputSpec([10]), 1, 2)
self.assertTrue(concrete_program_2 == concrete_program_1)
self.assertTrue(len(foo.program_cache) == 1)
# 3. specific `c` = 2
concrete_program_3 = foo.get_concrete_program(
InputSpec([None, 10]), InputSpec([10]), c=2)
self.assertTrue(concrete_program_3 != concrete_program_1)
self.assertTrue(len(foo.program_cache) == 2)
# 4. specific x.shape = [10]
concrete_program_4 = foo.get_concrete_program(
InputSpec([10]), InputSpec([10]))
self.assertTrue(concrete_program_4 != concrete_program_1)
self.assertTrue(len(foo.program_cache) == 3)
# 5. only specific InputSpec of x
with self.assertRaises(ValueError):
concrete_program_5 = foo.get_concrete_program(InputSpec([10]))
# 6. specific unknown kwargs `e`=4
with self.assertRaises(TypeError):
concrete_program_5 = foo.get_concrete_program(
InputSpec([10]), InputSpec([10]), e=4)
def run_dygraph(self, func, to_static=False):
with fluid.dygraph.guard(self.place):
x_v = fluid.dygraph.to_variable(self.x)
if to_static:
ret = declarative(func)(x_v)
else:
ret = func(x_v)
return ret.numpy()
def _run(self, to_static):
with fluid.dygraph.guard(self.place):
if to_static:
out = declarative(self.func)(self.x_data)
else:
out = self.func(self.x_data)
if isinstance(out, fluid.core.VarBase):
out = out.numpy()
return out
def _run(self, to_static):
with fluid.dygraph.guard():
if self.x is None or self.y is None:
self.fake_input()
if to_static:
out = declarative(nested_input)(self.x, self.y)
else:
out = nested_input(self.x, self.y)
return out.numpy()
def _run(self, to_static):
with fluid.dygraph.guard():
if self.x is None or self.y is None:
self.x = fake_data([10, 16])
self.y = fake_data([10, 16])
if to_static:
out = declarative(nested_output)(self.x, self.y)
else:
out = nested_output(self.x, self.y)
return out
def test_error(self):
func = declarative(dyfunc_to_variable)
paddle.enable_static()
# Failed to run the callable object decorated by '@paddle.jit.to_static'
# if it does NOT in dynamic mode.
with self.assertRaises(RuntimeError):
func(np.ones(5).astype("int32"))
program_trans.enable(False)
with self.assertRaises(AssertionError):
# AssertionError: We Only support to_variable in imperative mode,
# please use fluid.dygraph.guard() as context to run it in imperative Mode
func(np.ones(5).astype("int32"))
def test_nest_output(self):
x = fluid.dygraph.to_variable(
np.random.random((4, 8)).astype('float32'))
net = LinearNetWithNestOut(8, 8)
dy_outs = flatten(net(x))
net = declarative(net, input_spec=[InputSpec([None, 8], name='x')])
model_path = "net_with_nest_out/model"
paddle.jit.save(net, model_path)
load_net = paddle.jit.load(model_path)
load_outs = flatten(load_net(x))
self.assertTrue(len(dy_outs) == 4)
for dy_out, load_out in zip(dy_outs, load_outs):
self.assertTrue(np.allclose(dy_out.numpy(), load_out.numpy()))
def test_with_error(self):
with fluid.dygraph.guard(fluid.CPUPlace()):
x = to_variable(np.ones([4, 10]).astype('float32'))
y = to_variable(np.ones([4, 10]).astype('float32') * 2)
int_val = 4.
net = SimpleNet()
# 1. kwargs and input_spec should not be specificed in same time
with self.assertRaises(ValueError):
net(x, a=1, other_kwarg=2)
# 2. requires len(input_spec) <= len(args)
with self.assertRaises(ValueError):
net.add_func = declarative(net.add_func,
input_spec=[
InputSpec([-1, 10]),
InputSpec([-1, 10]),
InputSpec([10])
])
net.add_func(x, y)
def test_with_input_spec(self):
net = LinearNetReturnLoss(8, 8)
# set x.shape = [None, 8]
net.forward = declarative(net.forward,
input_spec=[InputSpec([None, 8], name='x')])
model_path = "input_spec.output_spec/model"
# check inputs and outputs
self.assertTrue(len(net.forward.inputs) == 1)
input_x = net.forward.inputs[0]
self.assertTrue(input_x.shape == (-1, 8))
self.assertTrue(input_x.name == 'x')
# 1. prune loss
output_spec = net.forward.outputs[:1]
paddle.jit.save(net, model_path, output_spec=output_spec)
# 2. load to infer
infer_layer = paddle.jit.load(model_path)
x = fluid.dygraph.to_variable(
np.random.random((4, 8)).astype('float32'))
pred = infer_layer(x)
def test_fake_input(self):
net = SimpleNet()
net = declarative(net)
y = net(self.x)
self.assertTrue(len(net.forward.program_cache) == 1)
