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_visualdl_callback(self): # visualdl not support python2 if sys.version_info < (3, ): return inputs = [InputSpec([-1, 1, 28, 28], 'float32', 'image')] labels = [InputSpec([None, 1], 'int64', 'label')] transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])]) train_dataset = MnistDataset(mode='train', transform=transform) eval_dataset = MnistDataset(mode='test', transform=transform) net = paddle.vision.models.LeNet() model = paddle.Model(net, inputs, labels) optim = paddle.optimizer.Adam(0.001, parameters=net.parameters()) model.prepare(optimizer=optim, loss=paddle.nn.CrossEntropyLoss(), metrics=paddle.metric.Accuracy()) callback = paddle.callbacks.VisualDL(log_dir='visualdl_log_dir') model.fit(train_dataset, eval_dataset, batch_size=64, callbacks=callback)
def dygraph_to_static(model, save_dir, cfg): if not os.path.exists(save_dir): os.makedirs(save_dir) image_shape = None if 'inputs_def' in cfg['TestReader']: inputs_def = cfg['TestReader']['inputs_def'] image_shape = inputs_def.get('image_shape', None) if image_shape is None: image_shape = [3, None, None] # Save infer cfg dump_infer_config(cfg, os.path.join(save_dir, 'infer_cfg.yml'), image_shape, model) input_spec = [{ "image": InputSpec(shape=[None] + image_shape, name='image'), "im_shape": InputSpec(shape=[None, 2], name='im_shape'), "scale_factor": InputSpec(shape=[None, 2], name='scale_factor') }] export_model = to_static(model, input_spec=input_spec) # save Model paddle.jit.save(export_model, os.path.join(save_dir, 'model'))
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 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_save_dynamic_load(self): path = tempfile.mkdtemp() 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') 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.load(path + '/test') shutil.rmtree(path) fluid.disable_dygraph()
def export(self, output_dir='output_inference'): self.model.eval() model_name = os.path.splitext(os.path.split(self.cfg.filename)[-1])[0] save_dir = os.path.join(output_dir, model_name) if not os.path.exists(save_dir): os.makedirs(save_dir) image_shape = None if 'inputs_def' in self.cfg['TestReader']: inputs_def = self.cfg['TestReader']['inputs_def'] image_shape = inputs_def.get('image_shape', None) if image_shape is None: image_shape = [3, None, None] # Save infer cfg _dump_infer_config(self.cfg, os.path.join(save_dir, 'infer_cfg.yml'), image_shape, self.model) input_spec = [{ "image": InputSpec( shape=[None] + image_shape, name='image'), "im_shape": InputSpec( shape=[None, 2], name='im_shape'), "scale_factor": InputSpec( shape=[None, 2], name='scale_factor') }] # dy2st and save model static_model = paddle.jit.to_static(self.model, input_spec=input_spec) paddle.jit.save(static_model, os.path.join(save_dir, 'model')) logger.info("Export model and saved in {}".format(save_dir))
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)
class ExportModel(nn.Layer): def __init__(self, model): super(ExportModel, self).__init__() self.model = model @to_static(input_spec=[ { 'image': InputSpec( shape=[None] + image_shape, name='image') }, { 'im_shape': InputSpec( shape=[None, 2], name='im_shape') }, { 'scale_factor': InputSpec( shape=[None, 2], name='scale_factor') }, ]) def forward(self, image, im_shape, scale_factor): inputs = {} inputs_tensor = [image, im_shape, scale_factor] for t in inputs_tensor: inputs.update(t) outs = self.model.get_export_model(inputs) return outs
def test_jit_save_compatible_input_sepc(self): layer = InputSepcLayer() save_dir = "jit_save_compatible_input_spec" path = save_dir + "/model" paddle.jit.save(layer=layer, path=path) no_input_spec_layer = paddle.jit.load(path) self._assert_input_spec_layer_return(layer, no_input_spec_layer) shutil.rmtree(save_dir) paddle.jit.save(layer=layer, path=path, input_spec=[ InputSpec(shape=[None, 8], dtype='float32', name='x'), InputSpec(shape=[None, 1], dtype='float64', name='y') ]) same_input_spec_layer = paddle.jit.load(path) self._assert_input_spec_layer_return(layer, same_input_spec_layer) shutil.rmtree(save_dir) paddle.jit.save(layer=layer, path=path, input_spec=[ InputSpec(shape=[8, 8], dtype='float32'), InputSpec(shape=[8, -1], dtype='float64') ]) compatible_input_spec_layer = paddle.jit.load(path) self._assert_input_spec_layer_return(layer, compatible_input_spec_layer) shutil.rmtree(save_dir)
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 infer(args): paddle.set_device(args.device) # create dataset. infer_dataset = LacDataset(args.data_dir, mode='infer') batchify_fn = lambda samples, fn=Tuple( Pad(axis=0, pad_val=0, dtype='int64'), # word_ids Stack(dtype='int64'), # length ): fn(samples) # Create sampler for dataloader infer_sampler = paddle.io.BatchSampler( dataset=infer_dataset, batch_size=args.batch_size, shuffle=False, drop_last=False) infer_loader = paddle.io.DataLoader( dataset=infer_dataset, batch_sampler=infer_sampler, return_list=True, collate_fn=batchify_fn) # Define the model network network = BiGruCrf(args.emb_dim, args.hidden_size, infer_dataset.vocab_size, infer_dataset.num_labels) inputs = InputSpec(shape=(-1, ), dtype="int64", name='inputs') lengths = InputSpec(shape=(-1, ), dtype="int64", name='lengths') model = paddle.Model(network, inputs=[inputs, lengths]) model.prepare() # Load the model and start predicting model.load(args.init_checkpoint) emissions, lengths, crf_decodes = model.predict( test_data=infer_loader, batch_size=args.batch_size) # Post-processing the lexical analysis results lengths = np.array([l for lens in lengths for l in lens]).reshape([-1]) preds = np.array( [pred for batch_pred in crf_decodes for pred in batch_pred]) results = parse_lac_result(infer_dataset.word_ids, preds, lengths, infer_dataset.word_vocab, infer_dataset.label_vocab) sent_tags = [] for sent, tags in results: sent_tag = ['(%s, %s)' % (ch, tag) for ch, tag in zip(sent, tags)] sent_tags.append(''.join(sent_tag)) file_path = "results.txt" with open(file_path, "w", encoding="utf8") as fout: fout.write("\n".join(sent_tags)) # Print some examples print( "The results have been saved in the file: %s, some examples are shown below: " % file_path) print("\n".join(sent_tags[:10]))
def export(self, output_dir='output_inference'): self.model.eval() model_name = os.path.splitext(os.path.split(self.cfg.filename)[-1])[0] save_dir = os.path.join(output_dir, model_name) if not os.path.exists(save_dir): os.makedirs(save_dir) image_shape = None if self.cfg.architecture in MOT_ARCH: test_reader_name = 'TestMOTReader' else: test_reader_name = 'TestReader' if 'inputs_def' in self.cfg[test_reader_name]: inputs_def = self.cfg[test_reader_name]['inputs_def'] image_shape = inputs_def.get('image_shape', None) # set image_shape=[3, -1, -1] as default if image_shape is None: image_shape = [3, -1, -1] self.model.eval() if hasattr(self.model, 'deploy'): self.model.deploy = True # Save infer cfg _dump_infer_config(self.cfg, os.path.join(save_dir, 'infer_cfg.yml'), image_shape, self.model) input_spec = [{ "image": InputSpec( shape=[None] + image_shape, name='image'), "im_shape": InputSpec( shape=[None, 2], name='im_shape'), "scale_factor": InputSpec( shape=[None, 2], name='scale_factor') }] if self.cfg.architecture == 'DeepSORT': input_spec[0].update({ "crops": InputSpec( shape=[None, 3, 192, 64], name='crops') }) static_model = paddle.jit.to_static(self.model, input_spec=input_spec) # NOTE: dy2st do not pruned program, but jit.save will prune program # input spec, prune input spec here and save with pruned input spec pruned_input_spec = self._prune_input_spec( input_spec, static_model.forward.main_program, static_model.forward.outputs) # dy2st and save model if 'slim' not in self.cfg or self.cfg['slim_type'] != 'QAT': paddle.jit.save( static_model, os.path.join(save_dir, 'model'), input_spec=pruned_input_spec) else: self.cfg.slim.save_quantized_model( self.model, os.path.join(save_dir, 'model'), input_spec=pruned_input_spec) logger.info("Export model and saved in {}".format(save_dir))
def test_verify_input_spec(self): a_spec = InputSpec([None, 10], name='a') b_spec = InputSpec([10], name='b') # type(input_spec) should be list or tuple with self.assertRaises(TypeError): foo_spec = FunctionSpec(foo_func, input_spec=a_spec) foo_spec = FunctionSpec(foo_func, input_spec=[a_spec, b_spec]) self.assertTrue(len(foo_spec.flat_input_spec) == 2)
class InputSepcLayer(paddle.nn.Layer): ''' A layer with InputSpec to test InputSpec compatibility ''' @paddle.jit.to_static(input_spec=[ InputSpec(shape=[None, 8], dtype='float32', name='x'), InputSpec(shape=[None, 1], dtype='float64', name='y') ]) def forward(self, x, y): return x, y
def test_from_tensor(self): x_bool = fluid.layers.fill_constant(shape=[1], dtype='bool', value=True) bool_spec = InputSpec.from_tensor(x_bool) self.assertEqual(bool_spec.dtype, x_bool.dtype) self.assertEqual(list(bool_spec.shape), list(x_bool.shape)) self.assertEqual(bool_spec.name, x_bool.name) bool_spec2 = InputSpec.from_tensor(x_bool, name='bool_spec') self.assertEqual(bool_spec2.name, bool_spec2.name)
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
class LinerNetWithUselessInput(paddle.nn.Layer): def __init__(self, in_size, out_size): super(LinerNetWithUselessInput, self).__init__() self._linear = Linear(in_size, out_size) @declarative(input_spec=[ InputSpec(shape=[None, 784], dtype='float32', name="image"), InputSpec(shape=[None, 1], dtype='int64', name="label") ]) def forward(self, x, label): out = self._linear(x) return out
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_shape_raise_error(self): # 1. shape should only contain int and None. with self.assertRaises(ValueError): tensor_spec = InputSpec(['None', 4, None], dtype='int8') # 2. shape should be type `list` or `tuple` with self.assertRaises(TypeError): tensor_spec = InputSpec(4, dtype='int8') # 3. len(shape) should be greater than 0. with self.assertRaises(ValueError): tensor_spec = InputSpec([], dtype='int8')
class TestLayer(paddle.nn.Layer): def __init__(self): super(TestLayer, self).__init__() @paddle.jit.to_static(input_spec=[ InputSpec(shape=[1], dtype='float32', name='x'), InputSpec(shape=[1], dtype='float32', name='y'), InputSpec(shape=[1], dtype='float32', name='z') ]) def forward(self, x, y, z): result = x + y return result
def test_fit_by_step(self): base_lr = 1e-3 boundaries = [5, 8] 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=4, 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() model.fit(dataset, dataset, batch_size=4, epochs=10, num_workers=0) np.testing.assert_allclose(model._optimizer._learning_rate.last_lr, base_lr * (0.1**len(boundaries))) # 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() model.fit(dataset, dataset, batch_size=4, epochs=10, num_workers=0) np.testing.assert_allclose(model._optimizer._learning_rate.last_lr, base_lr * (0.1**len(boundaries)))
class LinearNetMultiInput1(fluid.dygraph.Layer): def __init__(self, in_size, out_size): super(LinearNetMultiInput1, self).__init__() self._linear1 = Linear(in_size, out_size) self._linear2 = Linear(in_size, out_size) @declarative(input_spec=(InputSpec([None, 8], dtype='float32'), InputSpec([None, 8], dtype='float32'))) def forward(self, x, y): x_out = self._linear1(x) y_out = self._linear2(y) loss = fluid.layers.mean(x_out + y_out) return x_out, y_out, loss
def test_from_numpy(self): x_numpy = np.ones([10, 12]) x_np_spec = InputSpec.from_numpy(x_numpy) self.assertEqual(x_np_spec.dtype, convert_np_dtype_to_dtype_(x_numpy.dtype)) self.assertEqual(x_np_spec.shape, x_numpy.shape) self.assertEqual(x_np_spec.name, None) x_numpy2 = np.array([1, 2, 3, 4]).astype('int64') x_np_spec2 = InputSpec.from_numpy(x_numpy2, name='x_np_int64') self.assertEqual(x_np_spec2.dtype, convert_np_dtype_to_dtype_(x_numpy2.dtype)) self.assertEqual(x_np_spec2.shape, x_numpy2.shape) self.assertEqual(x_np_spec2.name, 'x_np_int64')
class LinerNetWithLabel(paddle.nn.Layer): def __init__(self, in_size, out_size): super(LinerNetWithLabel, self).__init__() self._linear = Linear(in_size, out_size) @paddle.jit.to_static(input_spec=[ InputSpec(shape=[None, 784], dtype='float32', name="image"), InputSpec(shape=[None, 1], dtype='int64', name="label") ]) def forward(self, x, label): out = self._linear(x) loss = fluid.layers.cross_entropy(out, label) avg_loss = fluid.layers.mean(loss) return out
def test_eq_and_hash(self): tensor_spec_1 = InputSpec([10, 16], dtype='float32') tensor_spec_2 = InputSpec([10, 16], dtype='float32') tensor_spec_3 = InputSpec([10, 16], dtype='float32', name='x') tensor_spec_4 = InputSpec([16], dtype='float32', name='x') # override ``__eq__`` according to [shape, dtype, name] self.assertTrue(tensor_spec_1 == tensor_spec_2) self.assertTrue(tensor_spec_1 != tensor_spec_3) # different name self.assertTrue(tensor_spec_3 != tensor_spec_4) # different shape # override ``__hash__`` according to [shape, dtype] self.assertTrue(hash(tensor_spec_1) == hash(tensor_spec_2)) self.assertTrue(hash(tensor_spec_1) == hash(tensor_spec_3)) self.assertTrue(hash(tensor_spec_3) != hash(tensor_spec_4))
class LinearNet(nn.Layer): def __init__(self): super(LinearNet, self).__init__() self._linear = nn.Linear(IMAGE_SIZE, CLASS_NUM) @paddle.jit.to_static( input_spec=[InputSpec(shape=[None, 784], dtype='float32')]) def forward(self, x): return self._linear(x) @paddle.jit.to_static( input_spec=[InputSpec(shape=[None, 784], dtype='float32')]) def another_forward(self, x): tmp = self._linear(x) return self._linear(tmp)
def StartLearning(): messagebox.showinfo("Message title", "已经成功运行请耐心等待") predict_dataset = predict.ZodiacDataset(mode='test') # print('测试数据集样本量:{}'.format(len(predict_dataset))) # 网络结构示例化 network = paddle.vision.models.resnet50(num_classes=get('num_classes')) # 模型封装 model_2 = paddle.Model(network, inputs=[ InputSpec(shape=[-1] + get('image_shape'), dtype='float32', name='image') ]) # 训练好的模型加载 model_2.load(get('model_save_dir')) # 模型配置 model_2.prepare() # 执行预测 result = model_2.predict(predict_dataset) #print(result) # 样本映射 LABEL_MAP = get('LABEL_MAP') a = end.a() lbl1.configure(text="测试结果:" + a)
def infer(self, arch): path = tempfile.mkdtemp() x = np.array(np.random.random((2, 3, 224, 224)), dtype=np.float32) res = {} for dygraph in [True, False]: if not dygraph: paddle.enable_static() net = models.__dict__[arch](pretrained=True) inputs = [InputSpec([None, 3, 224, 224], 'float32', 'image')] model = paddle.Model(network=net, inputs=inputs) model.prepare() if dygraph: model.save(path) res['dygraph'] = model.predict_batch(x) else: model.load(path) res['static'] = model.predict_batch(x) if not dygraph: paddle.disable_static() shutil.rmtree(path) np.testing.assert_allclose(res['dygraph'], res['static'])
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