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 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 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)