def main(args): place = paddle.set_device(args.device) fluid.enable_dygraph(place) if args.dynamic else None inputs = [ Input( [None, None], 'int64', name='words'), Input( [None], 'int64', name='length'), Input( [None, None], 'int64', name='target') ] labels = [Input([None, None], 'int64', name='labels')] dataset = LacDataset(args) eval_dataset = LacDataLoader(args, place, phase="test") vocab_size = dataset.vocab_size num_labels = dataset.num_labels model = paddle.Model( SeqTagging( args, vocab_size, num_labels, mode="test"), inputs=inputs, labels=labels) model.mode = "test" model.prepare(metrics=ChunkEval(num_labels)) model.load(args.init_from_checkpoint, skip_mismatch=True) eval_result = model.evaluate( eval_dataset.dataloader, batch_size=args.batch_size) print("precison: %.5f" % (eval_result["precision"][0])) print("recall: %.5f" % (eval_result["recall"][0])) print("F1: %.5f" % (eval_result["F1"][0]))
def infer(): tar_id2vocab, BOS_ID, EOS_ID = get_vocab(args.dataset, args.batch_size) vocab_size = len(tar_id2vocab) print(args) net = VAESeq2SeqInferModel(args.embed_dim, args.hidden_size, args.latent_size, vocab_size) model = paddle.Model(net) model.prepare() model.load(args.init_from_ckpt) infer_output = paddle.ones((args.batch_size, 1), dtype='int64') * BOS_ID space_token = ' ' line_token = '\n' with io.open(args.infer_output_file, 'w', encoding='utf-8') as out_file: predict_lines = model.predict_batch(infer_output)[0] for line in predict_lines: end_id = -1 if EOS_ID in line: end_id = np.where(line == EOS_ID)[0][0] new_line = [tar_id2vocab[e[0]] for e in line[:end_id]] out_file.write(space_token.join(new_line)) out_file.write(line_token)
def main(_): transform = T.Compose([T.ToTensor(), T.Normalize(mean=0.5, std=0.5)]) train_img_path = [] train_label = [] train_dataset = MyDataset(image=train_img_path, lable=train_label, transform=transform) train_loader = paddle.io.DataLoader(train_dataset, places=paddle.CPUPlace(), batch_size=2, shuffle=True) model = resnet18(pretrained=True, num_classes=102, with_pool=True) model = paddle.Model(model) optim = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) """Train or evaluates the model.""" if FLAGS.mode == 'train': model.prepare( optimizer=optim, loss=paddle.nn.MSELoss(), metric=Accuracy() # topk计算准确率的top个数,默认是1 ) model.fit( train_loader, epochs=2, verbose=1, ) model.evaluate(train_dataset, batch_size=2, verbose=1) model.save('inference_model', training=False) elif FLAGS.mode == 'eval_rollout': metadata = _read_metadata(FLAGS.data_path)
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_sen(self): paddle.disable_static() net = paddle.vision.models.LeNet() optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=net.parameters()) inputs = [Input([None, 1, 28, 28], 'float32', name='image')] labels = [Input([None, 1], 'int64', name='label')] model = paddle.Model(net, inputs, labels) model.prepare(optimizer, paddle.nn.CrossEntropyLoss(), paddle.metric.Accuracy(topk=(1, 5))) model.fit(self.train_dataset, epochs=1, batch_size=128, verbose=1) result = model.evaluate(self.val_dataset, batch_size=128, verbose=1) pruner = None if self._pruner == 'l1norm': pruner = L1NormFilterPruner(net, [1, 1, 28, 28]) elif self._pruner == 'fpgm': pruner = FPGMFilterPruner(net, [1, 1, 28, 28]) def eval_fn(): result = model.evaluate(self.val_dataset, batch_size=128) return result['acc_top1'] sen = pruner.sensitive( eval_func=eval_fn, sen_file="_".join(["./dygraph_sen_", str(time.time())]), #sen_file="sen.pickle", target_vars=self._param_names) params = {} for param in net.parameters(): params[param.name] = np.array(param.value().get_tensor()) print(f'dygraph sen: {sen}') return sen, params
def test(): if args.use_gpu: paddle.set_device("gpu") else: paddle.set_device("cpu") test_dataset = CovidDataset(args.data_path, args.test_data_size, args.seq_length, mode="test") network = TCNNetwork(input_size=1) model = paddle.Model(network) model.prepare() model.load(args.init_checkpoint) preds = model.predict(test_dataset) file_path = "results.txt" with open(file_path, "w", encoding="utf8") as fout: for pred in test_dataset.postprocessing(preds): fout.write("%s\n" % str(pred)) print("The prediction has been saved in %s" % file_path)
def do_train(args): device = paddle.set_device(args.select_device) # Define dataloader train_loader, eval_loader, src_vocab_size, tgt_vocab_size, eos_id = create_train_loader( args) model = paddle.Model( Seq2SeqAttnModel(src_vocab_size, tgt_vocab_size, args.hidden_size, args.hidden_size, args.num_layers, args.dropout, eos_id)) grad_clip = nn.ClipGradByGlobalNorm(args.max_grad_norm) optimizer = paddle.optimizer.Adam(learning_rate=args.learning_rate, parameters=model.parameters(), grad_clip=grad_clip) ppl_metric = Perplexity() model.prepare(optimizer, CrossEntropyCriterion(), ppl_metric) print(args) if args.init_from_ckpt: model.load(args.init_from_ckpt) print("Loaded checkpoint from %s" % args.init_from_ckpt) model.fit(train_data=train_loader, eval_data=eval_loader, epochs=args.max_epoch, eval_freq=1, save_freq=1, save_dir=args.model_path, log_freq=args.log_freq)
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 main(cfg): paddle.seed(cfg.COMMON.seed) np.random.seed(cfg.COMMON.seed) net = build_classifier(cfg.CLASSIFIER) model = paddle.Model(net) FLOPs = paddle.flops(net, [1, 3, 32, 32], print_detail=False) lrs = build_lrscheduler(cfg.SCHEDULER) optim = build_optim(cfg.OPTIMIZER, parameters=net.parameters(), learning_rate=lrs) train_transforms, val_transforms = build_transform() train_set = Cifar100(cfg.COMMON.data_path, mode='train', transform=train_transforms) test_set = Cifar100(cfg.COMMON.data_path, mode='test', transform=val_transforms) vis_name = '/{}-{}'.format( cfg.CLASSIFIER.name, time.strftime("%Y-%m-%d-%H:%M:%S", time.localtime())) callbacks = [LRSchedulerC(), VisualDLC(cfg.COMMON.logdir + vis_name)] model.prepare(optim, CrossEntropyLoss(), Accuracy(topk=(1, 5))) model.fit( train_set, test_set, batch_size=cfg.COMMON.batch_size, epochs=cfg.COMMON.epochs, num_workers=cfg.COMMON.workers, verbose=cfg.COMMON.verbose, callbacks=callbacks, )
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 _yolov3_darknet(num_layers=53, num_classes=80, num_max_boxes=50, model_mode='train', pretrained=True): inputs = [ InputSpec([None, 1], 'int64', name='img_id'), InputSpec([None, 2], 'int32', name='img_shape'), InputSpec([None, 3, None, None], 'float32', name='image') ] labels = [ InputSpec([None, num_max_boxes, 4], 'float32', name='gt_bbox'), InputSpec([None, num_max_boxes], 'int32', name='gt_label'), InputSpec([None, num_max_boxes], 'float32', name='gt_score') ] net = YOLOv3(num_classes, model_mode) model = paddle.Model(net, inputs, labels) if pretrained: assert num_layers in pretrain_infos.keys(), \ "YOLOv3-DarkNet{} do not have pretrained weights now, " \ "pretrained should be set as False".format(num_layers) weight_path = get_weights_path_from_url(*(pretrain_infos[num_layers])) assert weight_path.endswith('.pdparams'), \ "suffix of weight must be .pdparams" model.load(weight_path) return model
def main(): paddle.enable_static() if FLAGS.static else None device = paddle.set_device(FLAGS.device) train_dataset = MNIST(mode='train') val_dataset = MNIST(mode='test') inputs = [Input(shape=[None, 1, 28, 28], dtype='float32', name='image')] labels = [Input(shape=[None, 1], dtype='int64', name='label')] net = LeNet() model = paddle.Model(net, inputs, labels) optim = Momentum(learning_rate=FLAGS.lr, momentum=.9, parameter_list=model.parameters()) model.prepare(optim, paddle.nn.CrossEntropyLoss(), paddle.metric.Accuracy(topk=(1, 2))) if FLAGS.resume is not None: model.load(FLAGS.resume) if FLAGS.eval_only: model.evaluate(val_dataset, batch_size=FLAGS.batch_size) return model.fit(train_dataset, val_dataset, epochs=FLAGS.epoch, batch_size=FLAGS.batch_size, save_dir=FLAGS.output_dir)
def infer(args): print(args) device = paddle.set_device(args.device) _, _, _, vocab, bos_id, eos_id, _ = create_data_loader(args) net = VAESeq2SeqInferModel(args.embed_dim, args.hidden_size, args.latent_size, len(vocab) + 2) model = paddle.Model(net) model.prepare() model.load(args.init_from_ckpt) infer_output = paddle.ones((args.batch_size, 1), dtype='int64') * bos_id space_token = ' ' line_token = '\n' with io.open(args.infer_output_file, 'w', encoding='utf-8') as out_file: predict_lines = model.predict_batch(infer_output)[0] for line in predict_lines: end_id = -1 if eos_id in line: end_id = np.where(line == eos_id)[0][0] new_line = [vocab.to_tokens(e[0]) for e in line[:end_id]] out_file.write(space_token.join(new_line)) out_file.write(line_token)
def test_lenet(self): input = InputSpec([None, 1, 28, 28], 'float32', 'x') lenet = paddle.Model(models.__dict__['LeNet'](), input) lenet.prepare() x = np.array(np.random.random((2, 1, 28, 28)), dtype=np.float32) lenet.predict_batch(x)
def train(): if args.use_gpu: paddle.set_device("gpu") else: paddle.set_device("cpu") train_dataset = CovidDataset( args.data_path, args.test_data_size, args.seq_length, mode="train") network = TCNNetwork(input_size=1) model = paddle.Model(network) optimizer = paddle.optimizer.Adam( learning_rate=args.lr, parameters=model.parameters()) loss = paddle.nn.MSELoss(reduction='sum') model.prepare(optimizer, loss) if args.init_checkpoint: model.load(args.init_checkpoint) model.fit(train_dataset, batch_size=32, drop_last=True, epochs=args.epochs, save_dir=args.model_save_dir, save_freq=10, verbose=1)
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 test_model_retrain_built_in_high_level_api( pd_model_built_in_high_level_api, model_path, model_retrain_path, get_dataset_built_in_high_level_api, ): model = pd_model_built_in_high_level_api.model mlflow.paddle.save_model(pd_model=model, path=model_path, training=True) training_dataset, test_dataset = get_dataset_built_in_high_level_api model_retrain = paddle.Model(UCIHousing()) model_retrain = mlflow.paddle.load_model(model_uri=model_path, model=model_retrain) optim = paddle.optimizer.Adam(learning_rate=0.015, parameters=model.parameters()) model_retrain.prepare(optim, paddle.nn.MSELoss()) model_retrain.fit(training_dataset, epochs=6, batch_size=8, verbose=1) mlflow.paddle.save_model(pd_model=model_retrain, path=model_retrain_path, training=False) with pytest.raises(TypeError, match="This model can't be loaded"): mlflow.paddle.load_model(model_uri=model_retrain_path, model=model_retrain) error_model = 0 error_model_type = type(error_model) with pytest.raises( TypeError, match="Invalid object type `{}` for `model`, must be `paddle.Model`" .format(error_model_type), ): mlflow.paddle.load_model(model_uri=model_retrain_path, model=error_model) reloaded_pd_model = mlflow.paddle.load_model(model_uri=model_retrain_path) reloaded_pyfunc = pyfunc.load_pyfunc(model_uri=model_retrain_path) low_level_test_dataset = [x[0] for x in test_dataset] np.testing.assert_array_almost_equal( np.array(model_retrain.predict(test_dataset)).squeeze(), np.array(reloaded_pyfunc.predict( np.array(low_level_test_dataset))).squeeze(), decimal=5, ) np.testing.assert_array_almost_equal( np.array(reloaded_pd_model( np.array(low_level_test_dataset))).squeeze(), np.array(reloaded_pyfunc.predict( np.array(low_level_test_dataset))).squeeze(), decimal=5, )
def pd_model_built_in_high_level_api(): train_dataset, test_dataset = get_dataset_built_in_high_level_api() model = paddle.Model(UCIHousing()) optim = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters()) model.prepare(optim, paddle.nn.MSELoss()) model.fit(train_dataset, epochs=6, batch_size=8, verbose=1) return ModelWithData(model=model, inference_dataframe=test_dataset)
def main(): paddle.enable_static() if FLAGS.static else None device = paddle.set_device(FLAGS.device) model_list = [x for x in models.__dict__["__all__"]] assert FLAGS.arch in model_list, "Expected FLAGS.arch in {}, but received {}".format( model_list, FLAGS.arch) net = models.__dict__[FLAGS.arch]( pretrained=FLAGS.eval_only and not FLAGS.resume) inputs = [Input([None, 3, 224, 224], 'float32', name='image')] labels = [Input([None, 1], 'int64', name='label')] model = paddle.Model(net, inputs, labels) if FLAGS.resume is not None: model.load(FLAGS.resume) train_dataset = ImageNetDataset(os.path.join(FLAGS.data, 'train'), mode='train', image_size=FLAGS.image_size, resize_short_size=FLAGS.resize_short_size) val_dataset = ImageNetDataset(os.path.join(FLAGS.data, 'val'), mode='val', image_size=FLAGS.image_size, resize_short_size=FLAGS.resize_short_size) optim = make_optimizer(np.ceil( len(train_dataset) * 1. / FLAGS.batch_size / ParallelEnv().nranks), parameter_list=model.parameters()) model.prepare(optim, paddle.nn.CrossEntropyLoss(), paddle.metric.Accuracy(topk=(1, 5))) if FLAGS.eval_only: model.evaluate(val_dataset, batch_size=FLAGS.batch_size, num_workers=FLAGS.num_workers) return output_dir = os.path.join( FLAGS.output_dir, FLAGS.arch, time.strftime('%Y-%m-%d-%H-%M', time.localtime())) if ParallelEnv().local_rank == 0 and not os.path.exists(output_dir): os.makedirs(output_dir) model.fit(train_dataset, val_dataset, batch_size=FLAGS.batch_size, epochs=FLAGS.epoch, save_dir=output_dir, num_workers=FLAGS.num_workers)
def do_predict(args): device = paddle.set_device("gpu" if args.use_gpu else "cpu") test_loader, src_vocab_size, tgt_vocab_size, bos_id, eos_id = create_infer_loader( args) _, vocab = IWSLT15.get_vocab() trg_idx2word = vocab.idx_to_token model = paddle.Model( Seq2SeqAttnInferModel( src_vocab_size, tgt_vocab_size, args.hidden_size, args.hidden_size, args.num_layers, args.dropout, bos_id=bos_id, eos_id=eos_id, beam_size=args.beam_size, max_out_len=256)) model.prepare() # Load the trained model assert args.init_from_ckpt, ( "Please set reload_model to load the infer model.") model.load(args.init_from_ckpt) cand_list = [] with io.open(args.infer_output_file, 'w', encoding='utf-8') as f: for data in test_loader(): with paddle.no_grad(): finished_seq = model.predict_batch(inputs=data)[0] finished_seq = finished_seq[:, :, np.newaxis] if len( finished_seq.shape) == 2 else finished_seq finished_seq = np.transpose(finished_seq, [0, 2, 1]) for ins in finished_seq: for beam_idx, beam in enumerate(ins): id_list = post_process_seq(beam, bos_id, eos_id) word_list = [trg_idx2word[id] for id in id_list] sequence = " ".join(word_list) + "\n" f.write(sequence) cand_list.append(word_list) break test_ds = IWSLT15.get_datasets(["test"]) bleu = BLEU() for i, data in enumerate(test_ds): ref = data[1].split() bleu.add_inst(cand_list[i], [ref]) print("BLEU score is %s." % bleu.score())
def test_log_model_built_in_high_level_api(pd_model_built_in_high_level_api, model_path): old_uri = mlflow.get_tracking_uri() model = pd_model_built_in_high_level_api.model _, test_dataset = get_dataset_built_in_high_level_api() with TempDir(chdr=True, remove_on_exit=True) as tmp: for should_start_run in [False, True]: try: mlflow.set_tracking_uri("test") if should_start_run: mlflow.start_run() artifact_path = "model" conda_env = os.path.join(tmp.path(), "conda_env.yaml") _mlflow_conda_env(conda_env, additional_pip_deps=["paddle"]) mlflow.paddle.log_model(pd_model=model, artifact_path=artifact_path, conda_env=conda_env, training=True) model_uri = "runs:/{run_id}/{artifact_path}".format( run_id=mlflow.active_run().info.run_id, artifact_path=artifact_path) model_uri = mlflow.get_artifact_uri("model") model_retrain = paddle.Model(UCIHousing()) optim = paddle.optimizer.Adam(learning_rate=0.015, parameters=model.parameters()) model_retrain.prepare(optim, paddle.nn.MSELoss()) model_retrain = mlflow.paddle.load_model(model_uri=model_uri, model=model_retrain) np.testing.assert_array_almost_equal( np.array(model.predict(test_dataset)).squeeze(), np.array(model_retrain.predict(test_dataset)).squeeze(), decimal=5, ) model_path = _download_artifact_from_uri( artifact_uri=model_uri) model_config = Model.load(os.path.join(model_path, "MLmodel")) assert pyfunc.FLAVOR_NAME in model_config.flavors assert pyfunc.ENV in model_config.flavors[pyfunc.FLAVOR_NAME] env_path = model_config.flavors[pyfunc.FLAVOR_NAME][pyfunc.ENV] assert os.path.exists(os.path.join(model_path, env_path)) finally: mlflow.end_run() mlflow.set_tracking_uri(old_uri)
def train_model(**fit_kwargs): model = paddle.Model(LinearRegression()) optim = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters()) model.prepare(optim, paddle.nn.MSELoss()) train_dataset, eval_dataset = get_datasets() model.fit(train_dataset, eval_dataset, batch_size=16, epochs=NUM_EPOCHS, verbose=1, **fit_kwargs) return model
def build_model(self, args, **kwargs): network = RnnLm(vocab_size=self.vocab_size, hidden_size=args.hidden_size, batch_size=args.batch_size, num_layers=args.num_layers, init_scale=args.init_scale, dropout=args.dropout) self.cross_entropy = CrossEntropyLossForLm() model = paddle.Model(network) return model
def models_infer(self, arch, pretrained=False, batch_norm=False): x = np.array(np.random.random((2, 3, 224, 224)), dtype=np.float32) if batch_norm: net = models.__dict__[arch](pretrained=pretrained, batch_norm=True) else: net = models.__dict__[arch](pretrained=pretrained) input = InputSpec([None, 3, 224, 224], 'float32', 'image') model = paddle.Model(net, input) model.prepare() model.predict_batch(x)
def __init__(self): with open(DATA_CACHE_FILE_PATH, "rb") as f: data = pickle.load(f) self.label_encode = data.label_encode self.label_decode = data.label_decode # 定义输入格式 input_field = [paddle.static.InputSpec(shape=[4], dtype="int64", name="own_team_hero"), paddle.static.InputSpec(shape=[5], dtype="int64", name="cow_team_hero")] # 实例化模型 self.model = paddle.Model(CWNet(is_infer=True), input_field) self.model.load(F_MODEL_PATH) self.model.prepare()
def do_train(args): device = paddle.set_device("gpu" if args.use_gpu else "cpu") fluid.enable_dygraph(device) if args.eager_run else None if args.enable_ce: fluid.default_main_program().random_seed = 102 fluid.default_startup_program().random_seed = 102 # define model inputs = [ Input( [None, None], "int64", name="src_word"), Input( [None], "int64", name="src_length"), Input( [None, None], "int64", name="trg_word"), ] labels = [ Input( [None], "int64", name="trg_length"), Input( [None, None, 1], "int64", name="label"), ] # def dataloader train_loader, eval_loader = create_data_loader(args, device) model_maker = get_model_cls( AttentionModel) if args.attention else get_model_cls(BaseModel) model = paddle.Model( model_maker(args.src_vocab_size, args.tar_vocab_size, args.hidden_size, args.hidden_size, args.num_layers, args.dropout), inputs=inputs, labels=labels) grad_clip = fluid.clip.GradientClipByGlobalNorm( clip_norm=args.max_grad_norm) optimizer = fluid.optimizer.Adam( learning_rate=args.learning_rate, parameter_list=model.parameters(), grad_clip=grad_clip) ppl_metric = PPL(reset_freq=100) # ppl for every 100 batches model.prepare(optimizer, CrossEntropyCriterion(), ppl_metric) model.fit(train_data=train_loader, eval_data=eval_loader, epochs=args.max_epoch, eval_freq=1, save_freq=1, save_dir=args.model_path, callbacks=[TrainCallback(ppl_metric, args.log_freq)])
def infer(self, x, arch, dygraph=True): if dygraph: paddle.disable_static() net = models.__dict__[arch](pretrained=True, classifier_activation=None) inputs = [InputSpec([None, 3, 224, 224], 'float32', 'image')] model = paddle.Model(network=net, inputs=inputs) model.prepare() res = model.test_batch(x) if dygraph: paddle.enable_static() return res
def train(args): print(args) device = paddle.set_device(args.device) train_loader, dev_loader, test_loader, vocab, bos_id, pad_id, train_data_len = create_data_loader( args) net = VAESeq2SeqModel(embed_dim=args.embed_dim, hidden_size=args.hidden_size, latent_size=args.latent_size, vocab_size=len(vocab) + 2, num_layers=args.num_layers, init_scale=args.init_scale, enc_dropout=args.enc_dropout, dec_dropout=args.dec_dropout) gloabl_norm_clip = paddle.nn.ClipGradByGlobalNorm(args.max_grad_norm) anneal_r = 1.0 / (args.warm_up * train_data_len / args.batch_size) cross_entropy = CrossEntropyWithKL(base_kl_weight=args.kl_start, anneal_r=anneal_r) model = paddle.Model(net) optimizer = paddle.optimizer.Adam(args.learning_rate, parameters=model.parameters(), grad_clip=gloabl_norm_clip) if args.init_from_ckpt: model.load(args.init_from_ckpt) print("Loaded checkpoint from %s" % args.init_from_ckpt) ppl_metric = Perplexity(loss=cross_entropy) nll_metric = NegativeLogLoss(loss=cross_entropy) model.prepare(optimizer=optimizer, loss=cross_entropy, metrics=[ppl_metric, nll_metric]) model.fit(train_data=train_loader, eval_data=dev_loader, epochs=args.max_epoch, save_dir=args.model_path, shuffle=False, callbacks=[TrainCallback(ppl_metric, nll_metric, args.log_freq)], log_freq=args.log_freq) # Evaluation print('Start to evaluate on test dataset...') model.evaluate(test_loader, log_freq=len(test_loader))
def train(args): paddle.set_device(args.device) data_path = args.data_path train_loader, valid_loader, test_loader, vocab_size = create_data_loader( batch_size=args.batch_size, num_steps=args.num_steps, data_path=data_path) network = RnnLm(vocab_size=vocab_size, hidden_size=args.hidden_size, batch_size=args.batch_size, num_layers=args.num_layers, init_scale=args.init_scale, dropout=args.dropout) gloabl_norm_clip = paddle.nn.ClipGradByGlobalNorm(args.max_grad_norm) cross_entropy = CrossEntropyLossForLm() ppl_metric = Perplexity() callback = UpdateModel() scheduler = paddle.callbacks.LRScheduler(by_step=False, by_epoch=True) model = paddle.Model(network) learning_rate = paddle.optimizer.lr.LambdaDecay( learning_rate=args.base_lr, lr_lambda=lambda x: args.lr_decay**max(x + 1 - args.epoch_start_decay, 0.0), verbose=True) optimizer = paddle.optimizer.SGD(learning_rate=learning_rate, parameters=model.parameters(), grad_clip=gloabl_norm_clip) model.prepare(optimizer=optimizer, loss=cross_entropy, metrics=ppl_metric) if args.init_from_ckpt: model.load(args.init_from_ckpt) print("Loaded checkpoint from %s" % args.init_from_ckpt) model.fit(train_data=train_loader, eval_data=valid_loader, epochs=args.max_epoch, shuffle=False, callbacks=[callback, scheduler], log_freq=max(1, len(train_loader) // 10)) model.save(path='checkpoint/test') # save for training print('Start to evaluate on test dataset...') model.evaluate(test_loader, log_freq=len(test_loader))
def _tsm_resnet(num_layers, seg_num=8, num_classes=400, pretrained=True): inputs = [InputSpec([None, 8, 3, 224, 224], 'float32', name='image')] labels = [InputSpec([None, 1], 'int64', name='label')] net = TSM_ResNet(num_layers, seg_num, num_classes) model = paddle.Model(net, inputs, labels) if pretrained: assert num_layers in pretrain_infos.keys(), \ "TSM-ResNet{} do not have pretrained weights now, " \ "pretrained should be set as False".format(num_layers) weight_path = get_weights_path_from_url(*(pretrain_infos[num_layers])) assert weight_path.endswith('.pdparams'), \ "suffix of weight must be .pdparams" # weight_dict, _ = fluid.load_dygraph(weight_path) # model.set_dict(weight_dict) model.load(weight_path) return model