def test_square_error_cost(self):
input_val = np.random.uniform(0.1, 0.5, (2, 3)).astype("float32")
label_val = np.random.uniform(0.1, 0.5, (2, 3)).astype("float32")
sub = input_val - label_val
np_result = sub * sub
input_var = layers.create_tensor(dtype="float32", name="input")
label_var = layers.create_tensor(dtype="float32", name="label")
layers.assign(input=input_val, output=input_var)
layers.assign(input=label_val, output=label_var)
output = layers.square_error_cost(input=input_var, label=label_var)
for use_cuda in ([False, True]
if core.is_compiled_with_cuda() else [False]):
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
exe = Executor(place)
result = exe.run(fluid.default_main_program(),
feed={
"input": input_var,
"label": label_var
},
fetch_list=[output])
self.assertTrue(np.isclose(np_result, result).all())
def test_save_inference_model(self):
MODEL_DIR = "./tmp/inference_model3"
init_program = Program()
program = Program()
# fake program without feed/fetch
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
# will print warning message
cp_prog = CompiledProgram(program).with_data_parallel(
loss_name=avg_cost.name)
save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, cp_prog)
self.assertRaises(TypeError, save_inference_model,
[MODEL_DIR, ["x", "y"], [avg_cost], [], cp_prog])
def train_program():
scale_infer = inference_program()
label = layers.data(name='score', shape=[1], dtype='float32')
square_cost = layers.square_error_cost(input=scale_infer, label=label)
avg_cost = layers.mean(square_cost)
return [avg_cost, scale_infer]
def train_program():
scale_infer = inference_program()
label = layers.data(name='score', shape=[1], dtype='float32')
square_cost = layers.square_error_cost(input=scale_infer, label=label)
avg_cost = layers.mean(square_cost)
return [avg_cost, scale_infer]
def test_fit_line_inference_model(self):
MODEL_DIR = "./tmp/inference_model"
init_program = Program()
program = Program()
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
sgd_optimizer.minimize(avg_cost, init_program)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
for i in xrange(100):
tensor_x = np.array(
[[1, 1], [1, 2], [3, 4], [5, 2]]).astype("float32")
tensor_y = np.array([[-2], [-3], [-7], [-7]]).astype("float32")
exe.run(program,
feed={'x': tensor_x,
'y': tensor_y},
fetch_list=[avg_cost])
save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, program)
expected = exe.run(program,
feed={'x': tensor_x,
'y': tensor_y},
fetch_list=[avg_cost])[0]
reload(executor) # reload to build a new scope
exe = executor.Executor(place)
[infer_prog, feed_var_names, fetch_vars] = load_inference_model(
MODEL_DIR, exe)
outs = exe.run(
infer_prog,
feed={feed_var_names[0]: tensor_x,
feed_var_names[1]: tensor_y},
fetch_list=fetch_vars)
actual = outs[0]
self.assertEqual(feed_var_names, ["x", "y"])
self.assertEqual(len(fetch_vars), 1)
self.assertEqual(str(fetch_vars[0]), str(avg_cost))
self.assertEqual(expected, actual)
def test_fit_a_line(self):
program = Program()
with program_guard(program, startup_program=Program()):
x = layers.data(name='x', shape=[13], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
y = layers.data(name='y', shape=[1], dtype='float32')
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
self.assertIsNotNone(avg_cost)
print(str(program))
def test_fit_a_line(self):
program = Program()
with program_guard(program, startup_program=Program()):
x = layers.data(name='x', shape=[13], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
y = layers.data(name='y', shape=[1], dtype='float32')
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
self.assertIsNotNone(avg_cost)
print(str(program))
def setUp(self):
program = Program()
with program_guard(program, startup_program=Program()):
x = layers.data(name='x', shape=[13], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
y = layers.data(name='y', shape=[1], dtype='float32')
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
opt = optimizer.SGD(learning_rate=0.001)
opt = opt.minimize(avg_cost)
self.program = program
def setUp(self):
program = Program()
with program_guard(program, startup_program=Program()):
x = layers.data(name='x', shape=[13], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
y = layers.data(name='y', shape=[1], dtype='float32')
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
opt = optimizer.SGD(learning_rate=0.001)
opt = opt.minimize(avg_cost)
self.program = program
def inference_program():
usr_combined_features = get_usr_combined_features()
mov_combined_features = get_mov_combined_features()
inference = layers.cos_sim(X=usr_combined_features,
Y=mov_combined_features)
scale_infer = layers.scale(x=inference, scale=5.0)
label = layers.data(name='score', shape=[1], dtype='float32')
square_cost = layers.square_error_cost(input=scale_infer, label=label)
avg_cost = layers.mean(square_cost)
return usr_combined_features, mov_combined_features, scale_infer, avg_cost
def model():
usr_combined_features = get_usr_combined_features()
mov_combined_features = get_mov_combined_features()
# need cos sim
inference = layers.cos_sim(X=usr_combined_features, Y=mov_combined_features)
scale_infer = layers.scale(x=inference, scale=5.0)
label = layers.data(name='score', shape=[1], dtype='float32')
square_cost = layers.square_error_cost(input=scale_infer, label=label)
avg_cost = layers.mean(square_cost)
return scale_infer, avg_cost
def setUp(self):
program = Program()
with program_guard(program, startup_program=Program()):
x = layers.data(name='x', shape=[13], dtype='float32')
fc = layers.fc(input=x, size=10, act=None)
reshape = layers.reshape(x=fc, shape=[-1, 2, 5])
fc = layers.reshape(x=reshape, shape=[-1, 5, 2])
y_predict = layers.fc(input=fc, size=1, act=None)
y = layers.data(name='y', shape=[1], dtype='float32')
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
opt = optimizer.SGD(learning_rate=0.001)
opt.minimize(avg_cost)
self.skip_set = set([cost.name, fc.name])
self.program = program
def test_normalize_program(self):
init_program = fluid.default_startup_program()
program = fluid.default_main_program()
# fake program without feed/fetch
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
sgd_optimizer.minimize(avg_cost, init_program)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
tensor_x = np.array([[1, 1], [1, 2], [5, 2]]).astype("float32")
tensor_y = np.array([[-2], [-3], [-7]]).astype("float32")
for i in six.moves.xrange(3):
exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])
# test if return type of serialize_program is bytes
res = paddle.static.normalize_program(program, [x, y], [avg_cost])
self.assertTrue(isinstance(res, Program))
# test program type
self.assertRaises(TypeError, paddle.static.normalize_program, None,
[x, y], [avg_cost])
# test feed_vars type
self.assertRaises(TypeError, paddle.static.normalize_program, program,
'x', [avg_cost])
# test fetch_vars type
self.assertRaises(TypeError, paddle.static.normalize_program, program,
[x, y], 'avg_cost')
def __model_dataflow(self):
user_id = layers.data(name='user_id', shape=[1], dtype='int64')
user_gender_id = layers.data(name='user_gender_id', shape=[1], dtype='int64')
user_age_id = layers.data(name='user_age_id', shape=[1], dtype='int64')
user_occupation_id = layers.data(name='user_occupation_id', shape=[1], dtype='int64')
item_id = layers.data(name='item_id', shape=[1], dtype='int64')
item_category_one_hot = layers.data(name='item_category_one_hot', shape=[19], dtype='float32')
user_emb = layers.embedding(input=user_id, dtype='float32', size=[self.user_num + 1, 16],
param_attr='user_table', is_sparse=True)
user_gender_emb = layers.embedding(input=user_gender_id, dtype='float32', size=[2, 16],
param_attr='user_gender_table', is_sparse=True)
user_age_emb = layers.embedding(input=user_age_id, dtype='float32', size=[10, 16],
param_attr='user_age_table', is_sparse=True)
user_occupation_emb = layers.embedding(input=user_occupation_id, dtype='float32', size=[self.user_occupation_num, 16],
param_attr='user_occupation_table', is_sparse=True)
item_emb = layers.embedding(input=item_id, dtype='float32', size=[self.item_num + 1, 16],
param_attr='item_table', is_sparse=True)
item_category_emb = layers.fc(input=item_category_one_hot, size=16)
user_fc = layers.fc(input=user_emb, size=32)
user_gender_fc = layers.fc(input=user_gender_emb, size=16)
user_age_fc = layers.fc(input=user_age_emb, size=16)
user_occupation_fc = layers.fc(input=user_occupation_emb, size=16)
item_fc = layers.fc(input=item_emb, size=32)
item_category_fc = layers.fc(input=item_category_emb, size=16)
user_concat_embed = layers.concat(
input=[user_fc, user_gender_fc, user_age_fc, user_occupation_fc], axis=1)
item_concat_embed = layers.concat(
input=[item_fc, item_category_fc], axis=1)
user_conbined_features = layers.fc(input=user_concat_embed, size=200, act="tanh")
item_conbined_features = layers.fc(input=item_concat_embed, size=200, act="tanh")
inference = layers.cos_sim(X=user_conbined_features, Y=item_conbined_features)
scale_infer = layers.scale(x=inference, scale=5.0)
rating = layers.data(name='rating', shape=[1], dtype='float32')
square_cost = layers.square_error_cost(input=scale_infer, label=rating)
avg_cost = layers.mean(square_cost)
return scale_infer, avg_cost
def test_save_inference_model(self):
MODEL_DIR = "./tmp/inference_model2"
init_program = Program()
program = Program()
# fake program without feed/fetch
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, program)
def test_fit_line_inference_model(self):
MODEL_DIR = "./tmp/inference_model"
UNI_MODEL_DIR = "./tmp/inference_model1"
init_program = Program()
program = Program()
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
sgd_optimizer.minimize(avg_cost, init_program)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
for i in six.moves.xrange(100):
tensor_x = np.array([[1, 1], [1, 2], [3, 4],
[5, 2]]).astype("float32")
tensor_y = np.array([[-2], [-3], [-7], [-7]]).astype("float32")
exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])
# Separated model and unified model
save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, program)
save_inference_model(UNI_MODEL_DIR, ["x", "y"], [avg_cost], exe,
program, 'model', 'params')
main_program = program.clone()._prune_with_input(
feeded_var_names=["x", "y"], targets=[avg_cost])
params_str = save_persistables(exe, None, main_program, None)
expected = exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])[0]
six.moves.reload_module(executor) # reload to build a new scope
model_0 = InferModel(load_inference_model(MODEL_DIR, exe))
with open(os.path.join(UNI_MODEL_DIR, 'model'), "rb") as f:
model_str = f.read()
model_1 = InferModel(
load_inference_model(None, exe, model_str, params_str))
for model in [model_0, model_1]:
outs = exe.run(model.program,
feed={
model.feed_var_names[0]: tensor_x,
model.feed_var_names[1]: tensor_y
},
fetch_list=model.fetch_vars)
actual = outs[0]
self.assertEqual(model.feed_var_names, ["x", "y"])
self.assertEqual(len(model.fetch_vars), 1)
print("fetch %s" % str(model.fetch_vars[0]))
self.assertEqual(expected, actual)
self.assertRaises(ValueError, fluid.io.load_inference_model, None, exe,
model_str, None)
def test_save_and_load_inference_model(self):
MODEL_DIR = "./tmp/inference_model5"
init_program = fluid.default_startup_program()
program = fluid.default_main_program()
# fake program without feed/fetch
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
sgd_optimizer.minimize(avg_cost, init_program)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
tensor_x = np.array([[1, 1], [1, 2], [5, 2]]).astype("float32")
tensor_y = np.array([[-2], [-3], [-7]]).astype("float32")
for i in six.moves.xrange(3):
exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])
self.assertRaises(ValueError, paddle.static.save_inference_model, None,
['x', 'y'], [avg_cost], exe)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR + "/", [x, y], [avg_cost], exe)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR, ['x', 'y'], [avg_cost], exe)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR, 'x', [avg_cost], exe)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR, [x, y], ['avg_cost'], exe)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR, [x, y], 'avg_cost', exe)
model_path = MODEL_DIR + "_isdir.pdmodel"
os.makedirs(model_path)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR + "_isdir", [x, y], [avg_cost], exe)
os.rmdir(model_path)
params_path = MODEL_DIR + "_isdir.pdmodel"
os.makedirs(params_path)
self.assertRaises(ValueError, paddle.static.save_inference_model,
MODEL_DIR + "_isdir", [x, y], [avg_cost], exe)
os.rmdir(params_path)
paddle.static.io.save_inference_model(MODEL_DIR, [x, y], [avg_cost],
exe)
self.assertTrue(os.path.exists(MODEL_DIR + ".pdmodel"))
self.assertTrue(os.path.exists(MODEL_DIR + ".pdiparams"))
expected = exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])[0]
six.moves.reload_module(executor) # reload to build a new scope
self.assertRaises(ValueError, paddle.static.load_inference_model, None,
exe)
self.assertRaises(ValueError, paddle.static.load_inference_model,
MODEL_DIR + "/", exe)
self.assertRaises(ValueError, paddle.static.load_inference_model,
[MODEL_DIR], exe)
self.assertRaises(ValueError,
paddle.static.load_inference_model,
MODEL_DIR,
exe,
pserver_endpoints=None)
self.assertRaises(ValueError,
paddle.static.load_inference_model,
MODEL_DIR,
exe,
unsupported_param=None)
self.assertRaises((TypeError, ValueError),
paddle.static.load_inference_model,
None,
exe,
model_filename="illegal",
params_filename="illegal")
model = InferModel(
paddle.static.io.load_inference_model(MODEL_DIR, exe))
outs = exe.run(model.program,
feed={
model.feed_var_names[0]: tensor_x,
model.feed_var_names[1]: tensor_y
},
fetch_list=model.fetch_vars)
actual = outs[0]
self.assertEqual(model.feed_var_names, ["x", "y"])
self.assertEqual(len(model.fetch_vars), 1)
self.assertEqual(expected, actual)
# test save_to_file content type should be bytes
self.assertRaises(ValueError, paddle.static.io.save_to_file, '', 123)
# test _get_valid_program
self.assertRaises(TypeError, paddle.static.io._get_valid_program, 0)
p = Program()
cp = CompiledProgram(p)
paddle.static.io._get_valid_program(cp)
self.assertTrue(paddle.static.io._get_valid_program(cp) is p)
cp._program = None
self.assertRaises(TypeError, paddle.static.io._get_valid_program, cp)
def test_fit_line_inference_model(self):
MODEL_DIR = "./tmp/inference_model"
init_program = Program()
program = Program()
with program_guard(program, init_program):
x = layers.data(name='x', shape=[2], dtype='float32')
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.fc(input=x, size=1, act=None)
cost = layers.square_error_cost(input=y_predict, label=y)
avg_cost = layers.mean(cost)
sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
sgd_optimizer.minimize(avg_cost, init_program)
place = core.CPUPlace()
exe = executor.Executor(place)
exe.run(init_program, feed={}, fetch_list=[])
for i in six.moves.xrange(100):
tensor_x = np.array([[1, 1], [1, 2], [3, 4],
[5, 2]]).astype("float32")
tensor_y = np.array([[-2], [-3], [-7], [-7]]).astype("float32")
exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])
save_inference_model(MODEL_DIR, ["x", "y"], [avg_cost], exe, program)
expected = exe.run(program,
feed={
'x': tensor_x,
'y': tensor_y
},
fetch_list=[avg_cost])[0]
six.moves.reload_module(executor) # reload to build a new scope
exe = executor.Executor(place)
[infer_prog, feed_var_names,
fetch_vars] = load_inference_model(MODEL_DIR, exe)
outs = exe.run(infer_prog,
feed={
feed_var_names[0]: tensor_x,
feed_var_names[1]: tensor_y
},
fetch_list=fetch_vars)
actual = outs[0]
self.assertEqual(feed_var_names, ["x", "y"])
self.assertEqual(len(fetch_vars), 1)
print("fetch %s" % str(fetch_vars[0]))
self.assertTrue("scale" in str(fetch_vars[0]))
self.assertEqual(expected, actual)
