def test_test_batch(self): dim = 20 data = np.random.random(size=(4, dim)).astype(np.float32) def get_expect(): fluid.enable_dygraph(fluid.CPUPlace()) self.set_seed() m = MyModel() m.eval() output = m(to_tensor(data)) fluid.disable_dygraph() return output.numpy() ref = get_expect() for dynamic in [True, False]: device = paddle.set_device('cpu') fluid.enable_dygraph(device) if dynamic else None self.set_seed() net = MyModel() inputs = [InputSpec([None, dim], 'float32', 'x')] model = Model(net, inputs) model.prepare() out, = model.predict_batch([data]) np.testing.assert_allclose(out, ref, rtol=1e-6) fluid.disable_dygraph() if dynamic else None
def test_dynamic_load(self): mnist_data = MnistDataset(mode='train') path = os.path.join(tempfile.mkdtemp(), '.cache_dynamic_load') if not os.path.exists(path): os.makedirs(path) for new_optimizer in [True, False]: paddle.disable_static() net = LeNet() inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] if new_optimizer: optim = paddle.optimizer.Adam( learning_rate=0.001, parameters=net.parameters()) else: optim = fluid.optimizer.Adam( learning_rate=0.001, parameter_list=net.parameters()) model = Model(net, inputs, labels) model.prepare( optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) model.fit(mnist_data, batch_size=64, verbose=0) model.save(path) model.load(path) paddle.enable_static() shutil.rmtree(path)
def test_accumulate(self, ): dim = 20 data = np.random.random(size=(4, dim)).astype(np.float32) label = np.random.randint(0, 10, size=(4, 1)).astype(np.int64) net = MyModel() optim = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=net.parameters()) inputs = [InputSpec([None, dim], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] for amp_cfg in [None, 'O1']: model = Model(net, inputs, labels) model.prepare( optim, loss=CrossEntropyLoss(reduction="sum"), amp_configs=amp_cfg) losses, grads = [], [] for stat in [False, False, True]: loss, = model.train_batch([data], [label], update=stat) losses.append(loss) grads.append([p.grad.numpy() for p in net.parameters()]) for grad1, grad2, grad3 in zip(*grads): np.testing.assert_almost_equal(grad1 * 2, grad2, decimal=4) np.testing.assert_almost_equal( grad3, np.zeros_like(grad3), decimal=4) np.testing.assert_almost_equal(losses[0], losses[1], decimal=4) np.testing.assert_almost_equal(losses[0], losses[2], decimal=4)
def run_callback(self): epochs = 2 steps = 50 freq = 2 eval_steps = 20 inputs = [InputSpec([None, 1, 28, 28], 'float32', 'image')] lenet = Model(LeNet(), inputs) lenet.prepare() cbks = config_callbacks(model=lenet, batch_size=128, epochs=epochs, steps=steps, log_freq=freq, verbose=self.verbose, metrics=['loss', 'acc'], save_dir=self.save_dir) cbks.on_begin('train') logs = {'loss': 50.341673, 'acc': 0.00256} for epoch in range(epochs): cbks.on_epoch_begin(epoch) for step in range(steps): cbks.on_batch_begin('train', step, logs) logs['loss'] -= random.random() * 0.1 logs['acc'] += random.random() * 0.1 time.sleep(0.005) cbks.on_batch_end('train', step, logs) cbks.on_epoch_end(epoch, logs) eval_logs = {'eval_loss': 20.341673, 'eval_acc': 0.256} params = { 'steps': eval_steps, 'metrics': ['eval_loss', 'eval_acc'], } cbks.on_begin('eval', params) for step in range(eval_steps): cbks.on_batch_begin('eval', step, eval_logs) eval_logs['eval_loss'] -= random.random() * 0.1 eval_logs['eval_acc'] += random.random() * 0.1 eval_logs['batch_size'] = 2 time.sleep(0.005) cbks.on_batch_end('eval', step, eval_logs) cbks.on_end('eval', eval_logs) test_logs = {} params = {'steps': eval_steps} cbks.on_begin('test', params) for step in range(eval_steps): cbks.on_batch_begin('test', step, test_logs) test_logs['batch_size'] = 2 time.sleep(0.005) cbks.on_batch_end('test', step, test_logs) cbks.on_end('test', test_logs) cbks.on_end('train')
def test_save_infer_model_without_inputs_and_run_in_dygraph(self): paddle.disable_static() net = MyModel() save_dir = tempfile.mkdtemp() if not os.path.exists(save_dir): os.makedirs(save_dir) with self.assertRaises(RuntimeError): model = Model(net) model.save(save_dir, training=False) paddle.enable_static()
def predict(self, dynamic): fluid.enable_dygraph(self.device) if dynamic else None model = Model(LeNet(), self.inputs) model.prepare() model.load(self.weight_path) output = model.predict(self.test_dataset, batch_size=64, stack_outputs=True) np.testing.assert_equal(output[0].shape[0], len(self.test_dataset)) acc = compute_acc(output[0], self.val_dataset.labels) np.testing.assert_allclose(acc, self.acc1) sampler = DistributedBatchSampler(self.test_dataset, batch_size=64, shuffle=False) test_loader = fluid.io.DataLoader(self.test_dataset, batch_sampler=sampler, places=self.device, return_list=True) model.evaluate(test_loader) fluid.disable_dygraph() if dynamic else None
def test_static_multiple_gpus(self): device = set_device('gpu') im_shape = (-1, 1, 28, 28) batch_size = 128 inputs = [Input(im_shape, 'float32', 'image')] labels = [Input([None, 1], 'int64', 'label')] model = Model(LeNet(), inputs, labels) optim = fluid.optimizer.Momentum( learning_rate=0.001, momentum=.9, parameter_list=model.parameters()) model.prepare(optim, CrossEntropyLoss(), Accuracy()) train_dataset = MnistDataset(mode='train') val_dataset = MnistDataset(mode='test') test_dataset = MnistDataset(mode='test', return_label=False) cbk = paddle.callbacks.ProgBarLogger(50) model.fit(train_dataset, val_dataset, epochs=2, batch_size=batch_size, callbacks=cbk) eval_result = model.evaluate(val_dataset, batch_size=batch_size) output = model.predict( test_dataset, batch_size=batch_size, stack_outputs=True) np.testing.assert_equal(output[0].shape[0], len(test_dataset)) acc = compute_accuracy(output[0], val_dataset.labels) np.testing.assert_allclose(acc, eval_result['acc'])
def get_model(self, amp_config): net = LeNet() inputs = InputSpec([None, 1, 28, 28], "float32", 'x') labels = InputSpec([None, 1], "int64", "y") model = Model(net, inputs, labels) optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum"), amp_configs=amp_config) return model
def test_parameters(self): for dynamic in [True, False]: device = paddle.set_device('cpu') fluid.enable_dygraph(device) if dynamic else None net = MyModel() inputs = [InputSpec([None, 20], 'float32', 'x')] model = Model(net, inputs) model.prepare() params = model.parameters() self.assertTrue(params[0].shape[0] == 20) self.assertTrue(params[0].shape[1] == 10) fluid.disable_dygraph() if dynamic else None
def test_input_without_name(self): net = MyModel(classifier_activation=None) inputs = [InputSpec([None, 10], 'float32')] labels = [InputSpec([None, 1], 'int64', 'label')] with self.assertRaises(ValueError): model = Model(net, inputs, labels)
def test_static_check_input(self): paddle.enable_static() amp_configs = {"level": "O2", "use_pure_fp16": True} if not fluid.is_compiled_with_cuda(): self.skipTest('module not tested when ONLY_CPU compling') paddle.set_device('gpu') net = LeNet() inputs = InputSpec([None, 1, 28, 28], "float32", 'x') labels = InputSpec([None, 1], "int64", "y") model = Model(net, inputs, labels) optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) loss = CrossEntropyLoss(reduction="sum") with self.assertRaises(ValueError): model.prepare(optimizer=optim, loss=loss, amp_configs=amp_configs)
def test_predict_without_inputs(self): fluid.enable_dygraph(self.device) model = Model(LeNet()) model.prepare() model.load(self.weight_path) model._inputs = None output = model.predict( self.test_dataset, batch_size=64, stack_outputs=True) np.testing.assert_equal(output[0].shape[0], len(self.test_dataset)) fluid.disable_dygraph()
def test_export_deploy_model(self): for dynamic in [True, False]: fluid.enable_dygraph() if dynamic else None # paddle.disable_static() if dynamic else None prog_translator = ProgramTranslator() prog_translator.enable(False) if not dynamic else None net = LeNetDeclarative() inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')] model = Model(net, inputs) model.prepare() save_dir = tempfile.mkdtemp() if not os.path.exists(save_dir): os.makedirs(save_dir) tensor_img = np.array(np.random.random((1, 1, 28, 28)), dtype=np.float32) ori_results = model.test_batch(tensor_img) model.save(save_dir, training=False) fluid.disable_dygraph() if dynamic else None place = fluid.CPUPlace( ) if not fluid.is_compiled_with_cuda() else fluid.CUDAPlace(0) new_scope = fluid.Scope() with fluid.scope_guard(new_scope): exe = fluid.Executor(place) [inference_program, feed_target_names, fetch_targets ] = (fluid.io.load_inference_model(dirname=save_dir, executor=exe)) results = exe.run(inference_program, feed={feed_target_names[0]: tensor_img}, fetch_list=fetch_targets) np.testing.assert_allclose(results, ori_results, rtol=1e-5, atol=1e-7) shutil.rmtree(save_dir)
def func_warn_or_error(self): with self.assertRaises(ValueError): paddle.callbacks.ReduceLROnPlateau(factor=2.0) # warning paddle.callbacks.ReduceLROnPlateau(mode='1', patience=3, verbose=1) transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])]) train_dataset = CustomMnist(mode='train', transform=transform) val_dataset = CustomMnist(mode='test', transform=transform) net = LeNet() optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=net.parameters()) inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] model = Model(net, inputs=inputs, labels=labels) model.prepare(optim, loss=CrossEntropyLoss(), metrics=[Accuracy()]) callbacks = paddle.callbacks.ReduceLROnPlateau(monitor='miou', patience=3, verbose=1) model.fit(train_dataset, val_dataset, batch_size=8, log_freq=1, save_freq=10, epochs=1, callbacks=[callbacks]) optim = paddle.optimizer.Adam( learning_rate=paddle.optimizer.lr.PiecewiseDecay([0.001, 0.0001], [5, 10]), parameters=net.parameters()) model.prepare(optim, loss=CrossEntropyLoss(), metrics=[Accuracy()]) callbacks = paddle.callbacks.ReduceLROnPlateau(monitor='acc', mode='max', patience=3, verbose=1, cooldown=1) model.fit(train_dataset, val_dataset, batch_size=8, log_freq=1, save_freq=10, epochs=3, callbacks=[callbacks])
def fit_with_tuple_input(self, dynamic, num_replicas=None, rank=None): fluid.enable_dygraph(self.device) if dynamic else None seed = 333 paddle.seed(seed) paddle.framework.random._manual_program_seed(seed) net = LeNet() optim_new = fluid.optimizer.Adam( learning_rate=0.001, parameter_list=net.parameters()) model = Model(net, inputs=tuple(self.inputs), labels=tuple(self.labels)) model.prepare( optim_new, loss=CrossEntropyLoss(reduction="sum"), metrics=Accuracy()) model.fit(self.train_dataset, batch_size=64, shuffle=False) result = model.evaluate(self.val_dataset, batch_size=64) np.testing.assert_allclose(result['acc'], self.acc1) train_sampler = DistributedBatchSampler( self.train_dataset, batch_size=64, shuffle=False, num_replicas=num_replicas, rank=rank) val_sampler = DistributedBatchSampler( self.val_dataset, batch_size=64, shuffle=False, num_replicas=num_replicas, rank=rank) train_loader = fluid.io.DataLoader( self.train_dataset, batch_sampler=train_sampler, places=self.device, return_list=True) val_loader = fluid.io.DataLoader( self.val_dataset, batch_sampler=val_sampler, places=self.device, return_list=True) model.fit(train_loader, val_loader) fluid.disable_dygraph() if dynamic else None
def test_train_batch(self, dynamic=True): dim = 20 data = np.random.random(size=(4, dim)).astype(np.float32) label = np.random.randint(0, 10, size=(4, 1)).astype(np.int64) def get_expect(): fluid.enable_dygraph(fluid.CPUPlace()) self.set_seed() m = MyModel() optim = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=m.parameters()) m.train() output = m(to_tensor(data)) loss = CrossEntropyLoss(reduction='sum')(output, to_tensor(label)) avg_loss = fluid.layers.reduce_sum(loss) avg_loss.backward() optim.minimize(avg_loss) m.clear_gradients() fluid.disable_dygraph() return avg_loss.numpy() ref = get_expect() for dynamic in [True, False]: device = paddle.set_device('cpu') fluid.enable_dygraph(device) if dynamic else None self.set_seed() net = MyModel() optim2 = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=net.parameters()) inputs = [InputSpec([None, dim], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] model = Model(net, inputs, labels) model.prepare(optim2, loss=CrossEntropyLoss(reduction="sum")) loss, = model.train_batch([data], [label]) np.testing.assert_allclose(loss.flatten(), ref.flatten()) fluid.disable_dygraph() if dynamic else None
def evaluate(self, dynamic): fluid.enable_dygraph(self.device) if dynamic else None model = Model(LeNet(), self.inputs, self.labels) model.prepare(metrics=Accuracy()) model.load(self.weight_path) result = model.evaluate(self.val_dataset, batch_size=64) np.testing.assert_allclose(result['acc'], self.acc1) sampler = DistributedBatchSampler( self.val_dataset, batch_size=64, shuffle=False) val_loader = fluid.io.DataLoader( self.val_dataset, batch_sampler=sampler, places=self.device, return_list=True) model.evaluate(val_loader) fluid.disable_dygraph() if dynamic else None
def test_save_load(self): path = tempfile.mkdtemp() for dynamic in [True, False]: device = paddle.set_device('cpu') fluid.enable_dygraph(device) if dynamic else None net = MyModel(classifier_activation=None) inputs = [InputSpec([None, 20], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] optim = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=net.parameters()) model = Model(net, inputs, labels) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) model.save(path + '/test') model.load(path + '/test') shutil.rmtree(path) fluid.disable_dygraph() if dynamic else None
def test_save_infer_model_without_file_prefix(self): paddle.enable_static() net = LeNet() inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')] model = Model(net, inputs) model.prepare() path = "" tensor_img = np.array( np.random.random((1, 1, 28, 28)), dtype=np.float32) with self.assertRaises(ValueError): model.save(path, training=False)
def main(args): print('download training data and load training data') train_dataset = MnistDataset(mode='train', ) val_dataset = MnistDataset(mode='test', ) test_dataset = MnistDataset(mode='test', return_label=False) im_shape = (-1, 1, 28, 28) batch_size = 64 inputs = [Input(im_shape, 'float32', 'image')] labels = [Input([None, 1], 'int64', 'label')] model = Model(LeNet(), inputs, labels) optim = paddle.optimizer.SGD(learning_rate=0.001) if args.bf16: optim = amp.bf16.decorate_bf16( optim, amp_lists=amp.bf16.AutoMixedPrecisionListsBF16( custom_bf16_list={ 'matmul_v2', 'pool2d', 'relu', 'scale', 'elementwise_add', 'reshape2', 'slice', 'reduce_mean', 'conv2d' }, )) # Configuration model model.prepare(optim, paddle.nn.CrossEntropyLoss(), Accuracy()) # Training model # if args.bf16: print('Training BF16') else: print('Training FP32') model.fit(train_dataset, epochs=2, batch_size=batch_size, verbose=1) eval_result = model.evaluate(val_dataset, batch_size=batch_size, verbose=1) output = model.predict( test_dataset, batch_size=batch_size, stack_outputs=True) np.testing.assert_equal(output[0].shape[0], len(test_dataset)) acc = compute_accuracy(output[0], val_dataset.labels) print("acc", acc) print("eval_result['acc']", eval_result['acc']) np.testing.assert_allclose(acc, eval_result['acc'])
def _calc_output(self, place, mode="test", dygraph=True): if dygraph: fluid.enable_dygraph(place) else: fluid.disable_dygraph() gen = paddle.seed(self._random_seed) paddle.framework.random._manual_program_seed(self._random_seed) scope = fluid.core.Scope() with fluid.scope_guard(scope): layer = self.model_cls(**self.attrs) if isinstance( self.attrs, dict) else self.model_cls(*self.attrs) model = Model(layer, inputs=self.make_inputs()) model.prepare() if self.param_states: model.load(self.param_states, optim_state=None) return model.predict_batch(self.inputs)
def test_dynamic_check_input(self): paddle.disable_static() amp_configs_list = [ { "level": "O3" }, { "level": "O1", "test": 0 }, { "level": "O1", "use_fp16_guard": True }, "O3", ] if not fluid.is_compiled_with_cuda(): self.skipTest('module not tested when ONLY_CPU compling') paddle.set_device('gpu') net = LeNet() model = Model(net) optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) loss = CrossEntropyLoss(reduction="sum") with self.assertRaises(ValueError): for amp_configs in amp_configs_list: model.prepare(optimizer=optim, loss=loss, amp_configs=amp_configs) model.prepare(optimizer=optim, loss=loss, amp_configs="O2") model.prepare(optimizer=optim, loss=loss, amp_configs={ "custom_white_list": {"matmul"}, "init_loss_scaling": 1.0 })
def test_amp_training_purefp16(self): if not fluid.is_compiled_with_cuda(): self.skipTest('module not tested when ONLY_CPU compling') data = np.random.random(size=(4, 1, 28, 28)).astype(np.float32) label = np.random.randint(0, 10, size=(4, 1)).astype(np.int64) paddle.enable_static() paddle.set_device('gpu') net = LeNet() amp_level = "O2" inputs = InputSpec([None, 1, 28, 28], "float32", 'x') labels = InputSpec([None, 1], "int64", "y") model = Model(net, inputs, labels) optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters(), multi_precision=True) amp_configs = {"level": amp_level, "use_fp16_guard": False} model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum"), amp_configs=amp_configs) model.train_batch([data], [label])
def func_reduce_lr_on_plateau(self): transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])]) train_dataset = CustomMnist(mode='train', transform=transform) val_dataset = CustomMnist(mode='test', transform=transform) net = LeNet() optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=net.parameters()) inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] model = Model(net, inputs=inputs, labels=labels) model.prepare(optim, loss=CrossEntropyLoss(), metrics=[Accuracy()]) callbacks = paddle.callbacks.ReduceLROnPlateau(patience=1, verbose=1, cooldown=1) model.fit(train_dataset, val_dataset, batch_size=8, log_freq=1, save_freq=10, epochs=10, callbacks=[callbacks])
def test_fit_by_epoch(self): base_lr = 1e-3 boundaries = [5, 8] epochs = 10 wamup_epochs = 4 def make_optimizer(parameters=None): momentum = 0.9 weight_decay = 5e-4 values = [base_lr * (0.1**i) for i in range(len(boundaries) + 1)] learning_rate = paddle.optimizer.lr.PiecewiseDecay( boundaries=boundaries, values=values) learning_rate = paddle.optimizer.lr.LinearWarmup( learning_rate=learning_rate, warmup_steps=wamup_epochs, start_lr=base_lr / 5., end_lr=base_lr, verbose=True) optimizer = paddle.optimizer.Momentum( learning_rate=learning_rate, weight_decay=weight_decay, momentum=momentum, parameters=parameters) return optimizer # dynamic test device = paddle.set_device('cpu') fluid.enable_dygraph(device) net = MyModel() inputs = [InputSpec([None, 20], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] optim = make_optimizer(net.parameters()) model = Model(net, inputs, labels) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) dataset = MyDataset() lr_scheduler_callback = paddle.callbacks.LRScheduler( by_step=False, by_epoch=True) model.fit(dataset, dataset, batch_size=4, epochs=epochs, num_workers=0, callbacks=lr_scheduler_callback) cnt = 0 for b in boundaries: if b + wamup_epochs <= epochs: cnt += 1 np.testing.assert_allclose(model._optimizer._learning_rate.last_lr, base_lr * (0.1**cnt)) # static test paddle.enable_static() net = MyModel() inputs = [InputSpec([None, 20], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] optim = make_optimizer(net.parameters()) model = Model(net, inputs, labels) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) dataset = MyDataset() lr_scheduler_callback = paddle.callbacks.LRScheduler( by_step=False, by_epoch=True) model.fit(dataset, dataset, batch_size=4, epochs=epochs, num_workers=0, callbacks=lr_scheduler_callback) cnt = 0 for b in boundaries: if b + wamup_epochs <= epochs: cnt += 1 np.testing.assert_allclose(model._optimizer._learning_rate.last_lr, base_lr * (0.1**cnt))
def test_earlystopping(self): paddle.seed(2020) for dynamic in [True, False]: paddle.enable_static if not dynamic else None device = paddle.set_device('cpu') sample_num = 100 train_dataset = MnistDataset(mode='train', sample_num=sample_num) val_dataset = MnistDataset(mode='test', sample_num=sample_num) net = LeNet() optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=net.parameters()) inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] model = Model(net, inputs=inputs, labels=labels) model.prepare(optim, loss=CrossEntropyLoss(reduction="sum"), metrics=[Accuracy()]) callbacks_0 = paddle.callbacks.EarlyStopping('loss', mode='min', patience=1, verbose=1, min_delta=0, baseline=None, save_best_model=True) callbacks_1 = paddle.callbacks.EarlyStopping('acc', mode='auto', patience=1, verbose=1, min_delta=0, baseline=0, save_best_model=True) callbacks_2 = paddle.callbacks.EarlyStopping('loss', mode='auto_', patience=1, verbose=1, min_delta=0, baseline=None, save_best_model=True) callbacks_3 = paddle.callbacks.EarlyStopping('acc_', mode='max', patience=1, verbose=1, min_delta=0, baseline=0, save_best_model=True) model.fit( train_dataset, val_dataset, batch_size=64, save_freq=10, save_dir=self.save_dir, epochs=10, verbose=0, callbacks=[callbacks_0, callbacks_1, callbacks_2, callbacks_3]) # Test for no val_loader model.fit(train_dataset, batch_size=64, save_freq=10, save_dir=self.save_dir, epochs=10, verbose=0, callbacks=[callbacks_0])
def test_dygraph_export_deploy_model_about_inputs(self): self.set_seed() np.random.seed(201) mnist_data = MnistDataset(mode='train') paddle.disable_static() # without inputs save_dir = os.path.join(tempfile.mkdtemp(), '.cache_test_dygraph_export_deploy') if not os.path.exists(save_dir): os.makedirs(save_dir) for initial in ["fit", "train_batch", "eval_batch", "predict_batch"]: net = LeNet() model = Model(net) optim = fluid.optimizer.Adam( learning_rate=0.001, parameter_list=model.parameters()) model.prepare( optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) if initial == "fit": model.fit(mnist_data, batch_size=64, verbose=0) else: img = np.array( np.random.random((1, 1, 28, 28)), dtype=np.float32) label = np.array(np.random.rand(1, 1), dtype=np.int64) if initial == "train_batch": model.train_batch([img], [label]) elif initial == "eval_batch": model.eval_batch([img], [label]) else: model.predict_batch([img]) model.save(save_dir, training=False) shutil.rmtree(save_dir) # with inputs, and the type of inputs is InputSpec save_dir = os.path.join(tempfile.mkdtemp(), '.cache_test_dygraph_export_deploy_2') if not os.path.exists(save_dir): os.makedirs(save_dir) net = LeNet() inputs = InputSpec([None, 1, 28, 28], 'float32', 'x') model = Model(net, inputs) optim = fluid.optimizer.Adam( learning_rate=0.001, parameter_list=model.parameters()) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) model.save(save_dir, training=False) shutil.rmtree(save_dir)
def test_summary(self): def _get_param_from_state_dict(state_dict): params = 0 for k, v in state_dict.items(): params += np.prod(v.numpy().shape) return params for dynamic in [True, False]: device = paddle.set_device('cpu') fluid.enable_dygraph(device) if dynamic else None net = MyModel() inputs = [InputSpec([None, 20], 'float32', 'x')] model = Model(net, inputs) model.prepare() params_info = model.summary() gt_params = _get_param_from_state_dict(net.state_dict()) np.testing.assert_allclose(params_info['total_params'], gt_params) print(params_info) model.summary(input_size=(20)) model.summary(input_size=[(20)]) model.summary(input_size=(20), dtype='float32')
def test_static_save_dynamic_load(self): path = os.path.join(tempfile.mkdtemp(), '.cache_test_static_save_dynamic_load') if not os.path.exists(path): os.makedirs(path) net = MyModel() inputs = [InputSpec([None, 20], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] optim = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=net.parameters()) model = Model(net, inputs, labels) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) model.save(path) device = paddle.set_device('cpu') fluid.enable_dygraph(device) #if dynamic else None net = MyModel() inputs = [InputSpec([None, 20], 'float32', 'x')] labels = [InputSpec([None, 1], 'int64', 'label')] optim = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=net.parameters()) model = Model(net, inputs, labels) model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum")) model.load(path) shutil.rmtree(path) fluid.disable_dygraph()
def test_static_without_inputs(self): paddle.enable_static() net = MyModel() with self.assertRaises(TypeError): model = Model(net)