def check_sgd_optimizer(optimizer_attr): init_program = framework.Program() program = framework.Program() block = program.global_block() mul_x = block.create_parameter(dtype="float32", shape=[5, 10], lod_level=0, name="mul.x", optimize_attr=optimizer_attr) mul_y = block.create_var(dtype="float32", shape=[10, 8], lod_level=0, name="mul.y") mul_out = block.create_var(dtype="float32", shape=[5, 8], lod_level=0, name="mul.out") mean_out = block.create_var(dtype="float32", shape=[1], lod_level=0, name="mean.out") block.append_op(type="mul", inputs={ "X": mul_x, "Y": mul_y }, outputs={"Out": mul_out}, attrs={"x_num_col_dims": 1}) block.append_op(type="mean", inputs={"X": mul_out}, outputs={"Out": mean_out}) sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.01) opts, _ = sgd_optimizer.minimize(mean_out, init_program) return opts
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 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)
def setUp(self): self._init_config() self.optimizer = optimizer.SGDOptimizer(learning_rate=0.001) self.attr = {}