def test_test_batch(self, dynamic=True): 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_variable(data)) fluid.disable_dygraph() return output.numpy() ref = get_expect() for dynamic in [True, False]: device = set_device('cpu') fluid.enable_dygraph(device) if dynamic else None self.set_seed() model = MyModel() inputs = [Input([None, dim], 'float32', name='x')] model.prepare(inputs=inputs, device=device) out, = model.test_batch([data]) np.testing.assert_allclose(out, ref) fluid.disable_dygraph() if dynamic else None
def main(): device = set_device(FLAGS.device) fluid.enable_dygraph(device) if FLAGS.dynamic else None train_dataset = MnistDataset(mode='train') val_dataset = MnistDataset(mode='test') inputs = [Input([None, 784], 'float32', name='image')] labels = [Input([None, 1], 'int64', name='label')] model = MNIST() optim = Momentum(learning_rate=FLAGS.lr, momentum=.9, parameter_list=model.parameters()) model.prepare(optim, CrossEntropy(), Accuracy(topk=(1, 2)), inputs, labels, device=FLAGS.device) if FLAGS.resume is not None: model.load(FLAGS.resume) model.fit(train_dataset, val_dataset, epochs=FLAGS.epoch, batch_size=FLAGS.batch_size, save_dir='mnist_checkpoint')
def main(args): place = 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 = SeqTagging(args, vocab_size, num_labels, mode="test") model.mode = "test" model.prepare(metrics=ChunkEval(num_labels), inputs=inputs, labels=labels, device=place) 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 main(args): place = 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') ] dataset = LacDataset(args) predict_dataset = LacDataLoader(args, place, phase="predict") vocab_size = dataset.vocab_size num_labels = dataset.num_labels model = SeqTagging(args, vocab_size, num_labels, mode="predict") model.mode = "test" model.prepare(inputs=inputs) model.load(args.init_from_checkpoint, skip_mismatch=True) f = open(args.output_file, "wb") for data in predict_dataset.dataloader: if len(data) == 1: input_data = data[0] else: input_data = data results, length = model.test_batch(inputs=flatten(input_data)) for i in range(len(results)): word_len = length[i] word_ids = results[i][:word_len] tags = [dataset.id2label_dict[str(id)] for id in word_ids] f.write("\002".join(tags) + "\n")
def main(): device = set_device(FLAGS.device) fluid.enable_dygraph(device) if FLAGS.dynamic else None transform = Compose([GroupScale(), GroupCenterCrop(), NormalizeImage()]) dataset = KineticsDataset(pickle_file=FLAGS.infer_file, label_list=FLAGS.label_list, mode='test', transform=transform) labels = dataset.label_list model = tsm_resnet50(num_classes=len(labels), pretrained=FLAGS.weights is None) inputs = [Input([None, 8, 3, 224, 224], 'float32', name='image')] model.prepare(inputs=inputs, device=FLAGS.device) if FLAGS.weights is not None: model.load(FLAGS.weights, reset_optimizer=True) imgs, label = dataset[0] pred = model.test_batch([imgs[np.newaxis, :]]) pred = labels[np.argmax(pred)] logger.info("Sample {} predict label: {}, ground truth label: {}" \ .format(FLAGS.infer_file, pred, labels[int(label)]))
def test_bmn(args): device = set_device(args.device) fluid.enable_dygraph(device) if args.dynamic else None #config setting config = parse_config(args.config_file) eval_cfg = merge_configs(config, 'test', vars(args)) feat_dim = config.MODEL.feat_dim tscale = config.MODEL.tscale dscale = config.MODEL.dscale prop_boundary_ratio = config.MODEL.prop_boundary_ratio num_sample = config.MODEL.num_sample num_sample_perbin = config.MODEL.num_sample_perbin #input and video index inputs = [ Input([None, config.MODEL.feat_dim, config.MODEL.tscale], 'float32', name='feat_input') ] gt_iou_map = Input([None, config.MODEL.dscale, config.MODEL.tscale], 'float32', name='gt_iou_map') gt_start = Input([None, config.MODEL.tscale], 'float32', name='gt_start') gt_end = Input([None, config.MODEL.tscale], 'float32', name='gt_end') video_idx = Input([None, 1], 'int64', name='video_idx') labels = [gt_iou_map, gt_start, gt_end, video_idx] #data eval_dataset = BmnDataset(eval_cfg, 'test') #model model = bmn(tscale, dscale, prop_boundary_ratio, num_sample, num_sample_perbin, pretrained=args.weights is None) model.prepare(loss_function=BmnLoss(tscale, dscale), metrics=BmnMetric(config, mode='test'), inputs=inputs, labels=labels, device=device) #load checkpoint if args.weights is not None: assert os.path.exists(args.weights + '.pdparams'), \ "Given weight dir {} not exist.".format(args.weights) logger.info('load test weights from {}'.format(args.weights)) model.load(args.weights) model.evaluate(eval_data=eval_dataset, batch_size=eval_cfg.TEST.batch_size, num_workers=eval_cfg.TEST.num_workers, log_freq=args.log_interval) logger.info("[EVAL] eval finished")
def train_bmn(args): device = set_device(args.device) fluid.enable_dygraph(device) if args.dynamic else None if not os.path.isdir(args.save_dir): os.makedirs(args.save_dir) #config setting config = parse_config(args.config_file) train_cfg = merge_configs(config, 'train', vars(args)) val_cfg = merge_configs(config, 'valid', vars(args)) feat_dim = config.MODEL.feat_dim tscale = config.MODEL.tscale dscale = config.MODEL.dscale prop_boundary_ratio = config.MODEL.prop_boundary_ratio num_sample = config.MODEL.num_sample num_sample_perbin = config.MODEL.num_sample_perbin # input and label list inputs = [Input([None, feat_dim, tscale], 'float32', name='feat_input')] gt_iou_map = Input([None, dscale, tscale], 'float32', name='gt_iou_map') gt_start = Input([None, tscale], 'float32', name='gt_start') gt_end = Input([None, tscale], 'float32', name='gt_end') labels = [gt_iou_map, gt_start, gt_end] # data train_dataset = BmnDataset(train_cfg, 'train') val_dataset = BmnDataset(val_cfg, 'valid') # model model = bmn(tscale, dscale, prop_boundary_ratio, num_sample, num_sample_perbin, pretrained=False) optim = optimizer(config, parameter_list=model.parameters()) model.prepare(optimizer=optim, loss_function=BmnLoss(tscale, dscale), inputs=inputs, labels=labels, device=device) # if resume weights is given, load resume weights directly if args.resume is not None: model.load(args.resume) model.fit(train_data=train_dataset, eval_data=val_dataset, batch_size=train_cfg.TRAIN.batch_size, epochs=train_cfg.TRAIN.epoch, eval_freq=args.valid_interval, log_freq=args.log_interval, save_dir=args.save_dir, shuffle=train_cfg.TRAIN.use_shuffle, num_workers=train_cfg.TRAIN.num_workers, drop_last=True)
def test_parameters(self): for dynamic in [True, False]: device = set_device('cpu') fluid.enable_dygraph(device) if dynamic else None model = MyModel() inputs = [Input([None, 20], 'float32', name='x')] model.prepare(inputs=inputs) 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 infer_bmn(args): device = set_device(args.device) fluid.enable_dygraph(device) if args.dynamic else None #config setting config = parse_config(args.config_file) infer_cfg = merge_configs(config, 'infer', vars(args)) feat_dim = config.MODEL.feat_dim tscale = config.MODEL.tscale dscale = config.MODEL.dscale prop_boundary_ratio = config.MODEL.prop_boundary_ratio num_sample = config.MODEL.num_sample num_sample_perbin = config.MODEL.num_sample_perbin #input and video index inputs = [ Input([None, config.MODEL.feat_dim, config.MODEL.tscale], 'float32', name='feat_input') ] labels = [Input([None, 1], 'int64', name='video_idx')] #data infer_dataset = BmnDataset(infer_cfg, 'infer') #model model = bmn(tscale, dscale, prop_boundary_ratio, num_sample, num_sample_perbin, pretrained=args.weights is None) model.prepare(metrics=BmnMetric(config, mode='infer'), inputs=inputs, labels=labels, device=device) # load checkpoint if args.weights is not None: assert os.path.exists( args.weights + ".pdparams"), "Given weight dir {} not exist.".format(args.weights) logger.info('load test weights from {}'.format(args.weights)) model.load(args.weights) # here use model.eval instead of model.test, as post process is required in our case model.evaluate(eval_data=infer_dataset, batch_size=infer_cfg.TEST.batch_size, num_workers=infer_cfg.TEST.num_workers, log_freq=args.log_interval) logger.info("[INFER] infer finished")
def test_save_load(self): path = tempfile.mkdtemp() for dynamic in [True, False]: device = set_device('cpu') fluid.enable_dygraph(device) if dynamic else None model = MyModel() inputs = [Input([None, 20], 'float32', name='x')] model.prepare(inputs=inputs) model.save(path + '/test') model.load(path + '/test') shutil.rmtree(path) fluid.disable_dygraph() if dynamic else None
def do_train(args): device = 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 = AttentionModel if args.attention else BaseModel model = model_maker(args.src_vocab_size, args.tar_vocab_size, args.hidden_size, args.hidden_size, args.num_layers, args.dropout) 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, inputs=inputs, labels=labels, device=device) 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 main(): device = set_device(FLAGS.device) fluid.enable_dygraph(device) if FLAGS.dynamic else None 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) model = models.__dict__[FLAGS.arch]( pretrained=FLAGS.eval_only and not FLAGS.resume) if FLAGS.resume is not None: model.load(FLAGS.resume) inputs = [Input([None, 3, 224, 224], 'float32', name='image')] labels = [Input([None, 1], 'int64', name='label')] 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, CrossEntropy(), Accuracy(topk=(1, 5)), inputs, labels, FLAGS.device) 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 test_bmn(args): # only support dynamic mode at present time device = set_device(args.device) fluid.enable_dygraph(device) if args.dynamic else None config = parse_config(args.config_file) eval_cfg = merge_configs(config, 'test', vars(args)) if not os.path.isdir(config.TEST.output_path): os.makedirs(config.TEST.output_path) if not os.path.isdir(config.TEST.result_path): os.makedirs(config.TEST.result_path) inputs = [ Input([None, config.MODEL.feat_dim, config.MODEL.tscale], 'float32', name='feat_input') ] gt_iou_map = Input([None, config.MODEL.dscale, config.MODEL.tscale], 'float32', name='gt_iou_map') gt_start = Input([None, config.MODEL.tscale], 'float32', name='gt_start') gt_end = Input([None, config.MODEL.tscale], 'float32', name='gt_end') video_idx = Input([None, 1], 'int64', name='video_idx') labels = [gt_iou_map, gt_start, gt_end, video_idx] #data eval_dataset = BmnDataset(eval_cfg, 'test') #model model = bmn(config, pretrained=args.weights is None) model.prepare(loss_function=BmnLoss(config), metrics=BmnMetric(config, mode='test'), inputs=inputs, labels=labels, device=device) #load checkpoint if args.weights is not None: assert os.path.exists(args.weights + '.pdparams'), \ "Given weight dir {} not exist.".format(args.weights) logger.info('load test weights from {}'.format(args.weights)) model.load(args.weights) model.evaluate(eval_data=eval_dataset, batch_size=eval_cfg.TEST.batch_size, num_workers=eval_cfg.TEST.num_workers, log_freq=args.log_interval) logger.info("[EVAL] eval finished")
def main(args): place = 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')] feed_list = None if args.dynamic else [ x.forward() for x in inputs + labels ] dataset = LacDataset(args) train_dataset = LacDataLoader(args, place, phase="train") vocab_size = dataset.vocab_size num_labels = dataset.num_labels model = SeqTagging(args, vocab_size, num_labels, mode="train") optim = AdamOptimizer( learning_rate=args.base_learning_rate, parameter_list=model.parameters()) model.prepare( optim, LacLoss(), ChunkEval(num_labels), inputs=inputs, labels=labels, device=args.device) if args.init_from_checkpoint: model.load(args.init_from_checkpoint) if args.init_from_pretrain_model: model.load(args.init_from_pretrain_model, reset_optimizer=True) model.fit(train_dataset.dataloader, epochs=args.epoch, batch_size=args.batch_size, eval_freq=args.eval_freq, save_freq=args.save_freq, save_dir=args.save_dir)
def infer_bmn(args): # only support dynamic mode at present time device = set_device(args.device) fluid.enable_dygraph(device) if args.dynamic else None config = parse_config(args.config_file) infer_cfg = merge_configs(config, 'infer', vars(args)) if not os.path.isdir(config.INFER.output_path): os.makedirs(config.INFER.output_path) if not os.path.isdir(config.INFER.result_path): os.makedirs(config.INFER.result_path) inputs = [ Input([None, config.MODEL.feat_dim, config.MODEL.tscale], 'float32', name='feat_input') ] labels = [Input([None, 1], 'int64', name='video_idx')] #data infer_dataset = BmnDataset(infer_cfg, 'infer') model = bmn(config, pretrained=args.weights is None) model.prepare(metrics=BmnMetric(config, mode='infer'), inputs=inputs, labels=labels, device=device) # load checkpoint if args.weights is not None: assert os.path.exists( args.weights + ".pdparams"), "Given weight dir {} not exist.".format(args.weights) logger.info('load test weights from {}'.format(args.weights)) model.load(args.weights) # here use model.eval instead of model.test, as post process is required in our case model.evaluate(eval_data=infer_dataset, batch_size=infer_cfg.TEST.batch_size, num_workers=infer_cfg.TEST.num_workers, log_freq=args.log_interval) logger.info("[INFER] infer finished")
def main(FLAGS): device = set_device("gpu" if FLAGS.use_gpu else "cpu") fluid.enable_dygraph(device) if FLAGS.dynamic else None model = Seq2SeqAttModel(encoder_size=FLAGS.encoder_size, decoder_size=FLAGS.decoder_size, emb_dim=FLAGS.embedding_dim, num_classes=FLAGS.num_classes) # yapf: disable inputs = [ Input([None, 1, 48, 384], "float32", name="pixel"), Input([None, None], "int64", name="label_in") ] labels = [ Input([None, None], "int64", name="label_out"), Input([None, None], "float32", name="mask") ] # yapf: enable model.prepare(loss_function=WeightCrossEntropy(), metrics=SeqAccuracy(), inputs=inputs, labels=labels, device=device) model.load(FLAGS.init_model) test_dataset = data.test() test_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) test_sampler = data.BatchSampler(test_dataset, batch_size=FLAGS.batch_size, drop_last=False, shuffle=False) test_loader = fluid.io.DataLoader(test_dataset, batch_sampler=test_sampler, places=device, num_workers=0, return_list=True, collate_fn=test_collate_fn) model.evaluate(eval_data=test_loader, callbacks=[LoggerCallBack(10, 2, FLAGS.batch_size)])
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_variable(data)) l = to_variable(label) loss = fluid.layers.cross_entropy(output, l) 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 = set_device('cpu') fluid.enable_dygraph(device) if dynamic else None self.set_seed() model = MyModel() optim2 = fluid.optimizer.SGD(learning_rate=0.001, parameter_list=model.parameters()) inputs = [Input([None, dim], 'float32', name='x')] labels = [Input([None, 1], 'int64', name='label')] model.prepare(optim2, loss_function=CrossEntropy(average=False), inputs=inputs, labels=labels, device=device) loss, = model.train_batch([data], [label]) np.testing.assert_allclose(loss.flatten(), ref.flatten()) fluid.disable_dygraph() if dynamic else None
def main(FLAGS): device = set_device("gpu" if FLAGS.use_gpu else "cpu") fluid.enable_dygraph(device) if FLAGS.dynamic else None model = Seq2SeqAttInferModel( encoder_size=FLAGS.encoder_size, decoder_size=FLAGS.decoder_size, emb_dim=FLAGS.embedding_dim, num_classes=FLAGS.num_classes, beam_size=FLAGS.beam_size) inputs = [Input([None, 1, 48, 384], "float32", name="pixel"), ] model.prepare(inputs=inputs, device=device) model.load(FLAGS.init_model) fn = lambda p: Image.open(p).convert('L') test_dataset = ImageFolder(FLAGS.image_path, loader=fn) test_collate_fn = BatchCompose([data.Resize(), data.Normalize()]) test_loader = fluid.io.DataLoader( test_dataset, places=device, num_workers=0, return_list=True, collate_fn=test_collate_fn) samples = test_dataset.samples #outputs = model.predict(test_loader) ins_id = 0 for image, in test_loader: image = image if FLAGS.dynamic else image[0] pred = model.test_batch([image])[0] pred = pred[:, :, np.newaxis] if len(pred.shape) == 2 else pred pred = np.transpose(pred, [0, 2, 1]) for ins in pred: impath = samples[ins_id] ins_id += 1 print('Image {}: {}'.format(ins_id, impath)) for beam_idx, beam in enumerate(ins): id_list = postprocess(beam) word_list = index2word(id_list) sequence = "".join(word_list) print('{}: {}'.format(beam_idx, sequence))
def main(): place = set_device(FLAGS.device) fluid.enable_dygraph(place) if FLAGS.dynamic else None # Generators g_AB = Generator() g_BA = Generator() g = GeneratorCombine(g_AB, g_BA, is_train=False) im_shape = [-1, 3, 256, 256] input_A = Input(im_shape, 'float32', 'input_A') input_B = Input(im_shape, 'float32', 'input_B') g.prepare(inputs=[input_A, input_B], device=FLAGS.device) g.load(FLAGS.init_model, skip_mismatch=True, reset_optimizer=True) if not os.path.exists(FLAGS.output): os.makedirs(FLAGS.output) test_data_A = data.TestDataA() test_data_B = data.TestDataB() for i in range(len(test_data_A)): data_A, A_name = test_data_A[i] data_B, B_name = test_data_B[i] data_A = np.array(data_A).astype("float32") data_B = np.array(data_B).astype("float32") fake_A, fake_B, cyc_A, cyc_B = g.test_batch([data_A, data_B]) datas = [fake_A, fake_B, cyc_A, cyc_B, data_A, data_B] odatas = [] for o in datas: d = np.squeeze(o[0]).transpose([1, 2, 0]) im = ((d + 1) * 127.5).astype(np.uint8) odatas.append(im) imsave(FLAGS.output + "/fakeA_" + B_name, odatas[0]) imsave(FLAGS.output + "/fakeB_" + A_name, odatas[1]) imsave(FLAGS.output + "/cycA_" + A_name, odatas[2]) imsave(FLAGS.output + "/cycB_" + B_name, odatas[3]) imsave(FLAGS.output + "/inputA_" + A_name, odatas[4]) imsave(FLAGS.output + "/inputB_" + B_name, odatas[5])
def setUpClass(cls): cls.device = set_device('gpu') fluid.enable_dygraph(cls.device) sp_num = 1280 cls.train_dataset = MnistDataset(mode='train', sample_num=sp_num) cls.val_dataset = MnistDataset(mode='test', sample_num=sp_num) cls.test_dataset = MnistDataset(mode='test', return_label=False, sample_num=sp_num) cls.train_loader = fluid.io.DataLoader(cls.train_dataset, places=cls.device, batch_size=64) cls.val_loader = fluid.io.DataLoader(cls.val_dataset, places=cls.device, batch_size=64) cls.test_loader = fluid.io.DataLoader(cls.test_dataset, places=cls.device, batch_size=64) seed = 333 fluid.default_startup_program().random_seed = seed fluid.default_main_program().random_seed = seed dy_lenet = LeNetDygraph() cls.init_param = dy_lenet.state_dict() dynamic_train(dy_lenet, cls.train_loader) cls.acc1 = dynamic_evaluate(dy_lenet, cls.val_loader) cls.inputs = [Input([-1, 1, 28, 28], 'float32', name='image')] cls.labels = [Input([None, 1], 'int64', name='label')] cls.save_dir = tempfile.mkdtemp() cls.weight_path = os.path.join(cls.save_dir, 'lenet') fluid.dygraph.save_dygraph(dy_lenet.state_dict(), cls.weight_path) fluid.disable_dygraph()
def fit(self, dynamic): device = set_device('gpu') fluid.enable_dygraph(device) if dynamic else None im_shape = (-1, 784) batch_size = 128 inputs = [Input(im_shape, 'float32', name='image')] labels = [Input([None, 1], 'int64', name='label')] train_dataset = MnistDataset(mode='train') val_dataset = MnistDataset(mode='test') test_dataset = MnistDataset(mode='test', return_label=False) model = LeNet() optim = fluid.optimizer.Momentum(learning_rate=0.01, momentum=.9, parameter_list=model.parameters()) loss = CrossEntropy() model.prepare(optim, loss, Accuracy(), inputs, labels, device=device) cbk = 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 = get_predict_accuracy(output[0], val_dataset.labels) np.testing.assert_allclose(acc, eval_result['acc'])
def main(): device = set_device(FLAGS.device) fluid.enable_dygraph(device) if FLAGS.dynamic else None inputs = [ Input([None, 1], 'int64', name='img_id'), Input([None, 2], 'int32', name='img_shape'), Input([None, 3, None, None], 'float32', name='image') ] cat2name = load_labels(FLAGS.label_list, with_background=False) model = yolov3_darknet53(num_classes=len(cat2name), model_mode='test', pretrained=FLAGS.weights is None) model.prepare(inputs=inputs, device=FLAGS.device) if FLAGS.weights is not None: model.load(FLAGS.weights, reset_optimizer=True) # image preprocess orig_img = Image.open(FLAGS.infer_image).convert('RGB') w, h = orig_img.size img = orig_img.resize((608, 608), Image.BICUBIC) img = np.array(img).astype('float32') / 255.0 img -= np.array(IMAGE_MEAN) img /= np.array(IMAGE_STD) img = img.transpose((2, 0, 1))[np.newaxis, :] img_id = np.array([0]).astype('int64')[np.newaxis, :] img_shape = np.array([h, w]).astype('int32')[np.newaxis, :] _, bboxes = model.test([img_id, img_shape, img]) vis_img = draw_bbox(orig_img, cat2name, bboxes, FLAGS.draw_threshold) save_name = get_save_image_name(FLAGS.output_dir, FLAGS.infer_image) logger.info("Detection bbox results save in {}".format(save_name)) vis_img.save(save_name, quality=95)
def main(): place = set_device(FLAGS.device) fluid.enable_dygraph(place) if FLAGS.dynamic else None # Generators g_AB = Generator() g_BA = Generator() g = GeneratorCombine(g_AB, g_BA, is_train=False) im_shape = [-1, 3, 256, 256] input_A = Input(im_shape, 'float32', 'input_A') input_B = Input(im_shape, 'float32', 'input_B') g.prepare(inputs=[input_A, input_B], device=FLAGS.device) g.load(FLAGS.init_model, skip_mismatch=True, reset_optimizer=True) out_path = FLAGS.output + "/single" if not os.path.exists(out_path): os.makedirs(out_path) for f in glob.glob(FLAGS.input): image_name = os.path.basename(f) image = Image.open(f).convert('RGB') image = image.resize((256, 256), Image.BICUBIC) image = np.array(image) / 127.5 - 1 image = image[:, :, 0:3].astype("float32") data = image.transpose([2, 0, 1])[np.newaxis, :] if FLAGS.input_style == "A": _, fake, _, _ = g.test_batch([data, data]) if FLAGS.input_style == "B": fake, _, _, _ = g.test_batch([data, data]) fake = np.squeeze(fake[0]).transpose([1, 2, 0]) opath = "{}/fake{}{}".format(out_path, FLAGS.input_style, image_name) imsave(opath, ((fake + 1) * 127.5).astype(np.uint8)) print("transfer {} to {}".format(f, opath))
def do_train(args): device = set_device("gpu" if args.use_cuda else "cpu") fluid.enable_dygraph(device) if args.eager_run else None # set seed for CE random_seed = eval(str(args.random_seed)) if random_seed is not None: fluid.default_main_program().random_seed = random_seed fluid.default_startup_program().random_seed = random_seed # define inputs inputs = [ Input([None, None], "int64", name="src_word"), Input([None, None], "int64", name="src_pos"), Input([None, args.n_head, None, None], "float32", name="src_slf_attn_bias"), Input([None, None], "int64", name="trg_word"), Input([None, None], "int64", name="trg_pos"), Input([None, args.n_head, None, None], "float32", name="trg_slf_attn_bias"), Input([None, args.n_head, None, None], "float32", name="trg_src_attn_bias"), ] labels = [ Input([None, 1], "int64", name="label"), Input([None, 1], "float32", name="weight"), ] # def dataloader (train_loader, train_steps_fn), (eval_loader, eval_steps_fn) = create_data_loader(args, device) # define model transformer = Transformer(args.src_vocab_size, args.trg_vocab_size, args.max_length + 1, args.n_layer, args.n_head, args.d_key, args.d_value, args.d_model, args.d_inner_hid, args.prepostprocess_dropout, args.attention_dropout, args.relu_dropout, args.preprocess_cmd, args.postprocess_cmd, args.weight_sharing, args.bos_idx, args.eos_idx) transformer.prepare(fluid.optimizer.Adam( learning_rate=fluid.layers.noam_decay( args.d_model, args.warmup_steps, learning_rate=args.learning_rate), beta1=args.beta1, beta2=args.beta2, epsilon=float(args.eps), parameter_list=transformer.parameters()), CrossEntropyCriterion(args.label_smooth_eps), inputs=inputs, labels=labels, device=device) ## init from some checkpoint, to resume the previous training if args.init_from_checkpoint: transformer.load(args.init_from_checkpoint) ## init from some pretrain models, to better solve the current task if args.init_from_pretrain_model: transformer.load(args.init_from_pretrain_model, reset_optimizer=True) # model train transformer.fit(train_data=train_loader, eval_data=eval_loader, epochs=args.epoch, eval_freq=1, save_freq=1, save_dir=args.save_model, callbacks=[ TrainCallback(args, train_steps_fn=train_steps_fn, eval_steps_fn=eval_steps_fn) ])
def main(): device = set_device(FLAGS.device) fluid.enable_dygraph(device) if FLAGS.dynamic else None inputs = [ Input([None, 1], 'int64', name='img_id'), Input([None, 2], 'int32', name='img_shape'), Input([None, 3, None, None], 'float32', name='image') ] labels = [ Input([None, NUM_MAX_BOXES, 4], 'float32', name='gt_bbox'), Input([None, NUM_MAX_BOXES], 'int32', name='gt_label'), Input([None, NUM_MAX_BOXES], 'float32', name='gt_score') ] if not FLAGS.eval_only: # training mode train_transform = Compose([ ColorDistort(), RandomExpand(), RandomCrop(), RandomFlip(), NormalizeBox(), PadBox(), BboxXYXY2XYWH() ]) train_collate_fn = BatchCompose([RandomShape(), NormalizeImage()]) dataset = COCODataset(dataset_dir=FLAGS.data, anno_path='annotations/instances_train2017.json', image_dir='train2017', with_background=False, mixup=True, transform=train_transform) batch_sampler = DistributedBatchSampler(dataset, batch_size=FLAGS.batch_size, shuffle=True, drop_last=True) loader = DataLoader(dataset, batch_sampler=batch_sampler, places=device, num_workers=FLAGS.num_workers, return_list=True, collate_fn=train_collate_fn) else: # evaluation mode eval_transform = Compose([ ResizeImage(target_size=608), NormalizeBox(), PadBox(), BboxXYXY2XYWH() ]) eval_collate_fn = BatchCompose([NormalizeImage()]) dataset = COCODataset(dataset_dir=FLAGS.data, anno_path='annotations/instances_val2017.json', image_dir='val2017', with_background=False, transform=eval_transform) # batch_size can only be 1 in evaluation for YOLOv3 # prediction bbox is a LoDTensor batch_sampler = DistributedBatchSampler(dataset, batch_size=1, shuffle=False, drop_last=False) loader = DataLoader(dataset, batch_sampler=batch_sampler, places=device, num_workers=FLAGS.num_workers, return_list=True, collate_fn=eval_collate_fn) pretrained = FLAGS.eval_only and FLAGS.weights is None model = yolov3_darknet53(num_classes=dataset.num_classes, model_mode='eval' if FLAGS.eval_only else 'train', pretrained=pretrained) if FLAGS.pretrain_weights and not FLAGS.eval_only: pretrain_weights = FLAGS.pretrain_weights if is_url(pretrain_weights): pretrain_weights = get_weights_path(pretrain_weights) model.load(pretrain_weights, skip_mismatch=True, reset_optimizer=True) optim = make_optimizer(len(batch_sampler), parameter_list=model.parameters()) model.prepare(optim, YoloLoss(num_classes=dataset.num_classes), inputs=inputs, labels=labels, device=FLAGS.device) # NOTE: we implement COCO metric of YOLOv3 model here, separately # from 'prepare' and 'fit' framework for follwing reason: # 1. YOLOv3 network structure is different between 'train' and # 'eval' mode, in 'eval' mode, output prediction bbox is not the # feature map used for YoloLoss calculating # 2. COCO metric behavior is also different from defined Metric # for COCO metric should not perform accumulate in each iteration # but only accumulate at the end of an epoch if FLAGS.eval_only: if FLAGS.weights is not None: model.load(FLAGS.weights, reset_optimizer=True) preds = model.predict(loader, stack_outputs=False) _, _, _, img_ids, bboxes = preds anno_path = os.path.join(FLAGS.data, 'annotations/instances_val2017.json') coco_metric = COCOMetric(anno_path=anno_path, with_background=False) for img_id, bbox in zip(img_ids, bboxes): coco_metric.update(img_id, bbox) coco_metric.accumulate() coco_metric.reset() return if FLAGS.resume is not None: model.load(FLAGS.resume) model.fit(train_data=loader, epochs=FLAGS.epoch - FLAGS.no_mixup_epoch, save_dir="yolo_checkpoint/mixup", save_freq=10) # do not use image mixup transfrom in laste FLAGS.no_mixup_epoch epoches dataset.mixup = False model.fit(train_data=loader, epochs=FLAGS.no_mixup_epoch, save_dir="yolo_checkpoint/no_mixup", save_freq=5)
def main(): config = Config(yaml_file="./bert.yaml") config.build() config.Print() device = set_device("gpu" if config.use_cuda else "cpu") fluid.enable_dygraph(device) bert_config = BertConfig(config.bert_config_path) bert_config.print_config() tokenizer = tokenization.FullTokenizer( vocab_file=config.vocab_path, do_lower_case=config.do_lower_case) def mnli_line_processor(line_id, line): if line_id == "0": return None uid = tokenization.convert_to_unicode(line[0]) text_a = tokenization.convert_to_unicode(line[8]) text_b = tokenization.convert_to_unicode(line[9]) label = tokenization.convert_to_unicode(line[-1]) if label not in ["contradiction", "entailment", "neutral"]: label = "contradiction" return BertInputExample( uid=uid, text_a=text_a, text_b=text_b, label=label) train_dataloader = BertDataLoader( "./data/glue_data/MNLI/train.tsv", tokenizer, ["contradiction", "entailment", "neutral"], max_seq_length=config.max_seq_len, batch_size=config.batch_size, line_processor=mnli_line_processor) test_dataloader = BertDataLoader( "./data/glue_data/MNLI/dev_matched.tsv", tokenizer, ["contradiction", "entailment", "neutral"], max_seq_length=config.max_seq_len, batch_size=config.batch_size, line_processor=mnli_line_processor, shuffle=False, phase="predict") trainer_count = fluid.dygraph.parallel.Env().nranks num_train_examples = len(train_dataloader.dataset) max_train_steps = config.epoch * num_train_examples // config.batch_size // trainer_count warmup_steps = int(max_train_steps * config.warmup_proportion) print("Trainer count: %d" % trainer_count) print("Num train examples: %d" % num_train_examples) print("Max train steps: %d" % max_train_steps) print("Num warmup steps: %d" % warmup_steps) inputs = [ Input( [None, None], 'int64', name='src_ids'), Input( [None, None], 'int64', name='pos_ids'), Input( [None, None], 'int64', name='sent_ids'), Input( [None, None, 1], 'float32', name='input_mask') ] labels = [Input([None, 1], 'int64', name='label')] cls_model = ClsModelLayer( config, bert_config, len(["contradiction", "entailment", "neutral"]), return_pooled_out=True) optimizer = make_optimizer( warmup_steps=warmup_steps, num_train_steps=max_train_steps, learning_rate=config.learning_rate, weight_decay=config.weight_decay, scheduler=config.lr_scheduler, model=cls_model, loss_scaling=config.loss_scaling, parameter_list=cls_model.parameters()) cls_model.prepare( optimizer, SoftmaxWithCrossEntropy(), Accuracy(topk=(1, 2)), inputs, labels, device=device) cls_model.bert_layer.load("./bert_uncased_L-12_H-768_A-12/bert", reset_optimizer=True) # do train cls_model.fit(train_data=train_dataloader.dataloader, epochs=config.epoch, save_dir=config.checkpoints) # do eval cls_model.evaluate( eval_data=test_dataloader.dataloader, batch_size=config.batch_size)
from __future__ import print_function import numpy as np import paddle.fluid as fluid from hapi.model import set_device, Model, CrossEntropy, Input from hapi.configure import Config from hapi.text.senta import SentaProcessor from hapi.metrics import Accuracy from models import CNN, BOW, GRU, BiGRU import json import os args = Config(yaml_file='./senta.yaml') args.build() args.Print() device = set_device("gpu" if args.use_cuda else "cpu") dev_count = fluid.core.get_cuda_device_count() if args.use_cuda else 1 def main(): if args.do_train: train() elif args.do_infer: infer() def train(): fluid.enable_dygraph(device) processor = SentaProcessor(data_dir=args.data_dir, vocab_path=args.vocab_path, random_seed=args.random_seed)
def main(): device = set_device(FLAGS.device) fluid.enable_dygraph(device) if FLAGS.dynamic else None train_transform = Compose([ GroupScale(), GroupMultiScaleCrop(), GroupRandomCrop(), GroupRandomFlip(), NormalizeImage() ]) train_dataset = KineticsDataset( file_list=os.path.join(FLAGS.data, 'train_10.list'), pickle_dir=os.path.join(FLAGS.data, 'train_10'), label_list=os.path.join(FLAGS.data, 'label_list'), transform=train_transform) val_transform = Compose( [GroupScale(), GroupCenterCrop(), NormalizeImage()]) val_dataset = KineticsDataset( file_list=os.path.join(FLAGS.data, 'val_10.list'), pickle_dir=os.path.join(FLAGS.data, 'val_10'), label_list=os.path.join(FLAGS.data, 'label_list'), mode='val', transform=val_transform) pretrained = FLAGS.eval_only and FLAGS.weights is None model = tsm_resnet50(num_classes=train_dataset.num_classes, pretrained=pretrained) step_per_epoch = int(len(train_dataset) / FLAGS.batch_size \ / ParallelEnv().nranks) optim = make_optimizer(step_per_epoch, model.parameters()) inputs = [Input([None, 8, 3, 224, 224], 'float32', name='image')] labels = [Input([None, 1], 'int64', name='label')] model.prepare(optim, CrossEntropy(), metrics=Accuracy(topk=(1, 5)), inputs=inputs, labels=labels, device=FLAGS.device) if FLAGS.eval_only: if FLAGS.weights is not None: model.load(FLAGS.weights, reset_optimizer=True) model.evaluate(val_dataset, batch_size=FLAGS.batch_size, num_workers=FLAGS.num_workers) return if FLAGS.resume is not None: model.load(FLAGS.resume) model.fit(train_data=train_dataset, eval_data=val_dataset, epochs=FLAGS.epoch, batch_size=FLAGS.batch_size, save_dir='tsm_checkpoint', num_workers=FLAGS.num_workers, drop_last=True, shuffle=True)
def do_predict(args): device = set_device("gpu" if args.use_cuda else "cpu") fluid.enable_dygraph(device) if args.eager_run else None inputs = [ Input([None, None], "int64", name="src_word"), Input([None, None], "int64", name="src_pos"), Input([None, args.n_head, None, None], "float32", name="src_slf_attn_bias"), Input([None, args.n_head, None, None], "float32", name="trg_src_attn_bias"), ] # define data dataset = Seq2SeqDataset(fpattern=args.predict_file, src_vocab_fpath=args.src_vocab_fpath, trg_vocab_fpath=args.trg_vocab_fpath, token_delimiter=args.token_delimiter, start_mark=args.special_token[0], end_mark=args.special_token[1], unk_mark=args.special_token[2], byte_data=True) args.src_vocab_size, args.trg_vocab_size, args.bos_idx, args.eos_idx, \ args.unk_idx = dataset.get_vocab_summary() trg_idx2word = Seq2SeqDataset.load_dict(dict_path=args.trg_vocab_fpath, reverse=True, byte_data=True) batch_sampler = Seq2SeqBatchSampler(dataset=dataset, use_token_batch=False, batch_size=args.batch_size, max_length=args.max_length) data_loader = DataLoader(dataset=dataset, batch_sampler=batch_sampler, places=device, collate_fn=partial(prepare_infer_input, bos_idx=args.bos_idx, eos_idx=args.eos_idx, src_pad_idx=args.eos_idx, n_head=args.n_head), num_workers=0, return_list=True) # define model transformer = InferTransformer(args.src_vocab_size, args.trg_vocab_size, args.max_length + 1, args.n_layer, args.n_head, args.d_key, args.d_value, args.d_model, args.d_inner_hid, args.prepostprocess_dropout, args.attention_dropout, args.relu_dropout, args.preprocess_cmd, args.postprocess_cmd, args.weight_sharing, args.bos_idx, args.eos_idx, beam_size=args.beam_size, max_out_len=args.max_out_len) transformer.prepare(inputs=inputs) # load the trained model assert args.init_from_params, ( "Please set init_from_params to load the infer model.") transformer.load(args.init_from_params) # TODO: use model.predict when support variant length f = open(args.output_file, "wb") for data in data_loader(): finished_seq = transformer.test_batch(inputs=flatten(data))[0] finished_seq = np.transpose(finished_seq, [0, 2, 1]) for ins in finished_seq: for beam_idx, beam in enumerate(ins): if beam_idx >= args.n_best: break id_list = post_process_seq(beam, args.bos_idx, args.eos_idx) word_list = [trg_idx2word[id] for id in id_list] sequence = b" ".join(word_list) + b"\n" f.write(sequence)
def do_predict(args): device = set_device("gpu" if args.use_gpu else "cpu") fluid.enable_dygraph(device) if args.eager_run else None # define model inputs = [ Input([None, None], "int64", name="src_word"), Input([None], "int64", name="src_length"), ] # def dataloader dataset = Seq2SeqDataset( fpattern=args.infer_file, src_vocab_fpath=args.vocab_prefix + "." + args.src_lang, trg_vocab_fpath=args.vocab_prefix + "." + args.tar_lang, token_delimiter=None, start_mark="<s>", end_mark="</s>", unk_mark="<unk>") trg_idx2word = Seq2SeqDataset.load_dict(dict_path=args.vocab_prefix + "." + args.tar_lang, reverse=True) (args.src_vocab_size, args.trg_vocab_size, bos_id, eos_id, unk_id) = dataset.get_vocab_summary() batch_sampler = Seq2SeqBatchSampler(dataset=dataset, use_token_batch=False, batch_size=args.batch_size) data_loader = DataLoader(dataset=dataset, batch_sampler=batch_sampler, places=device, collate_fn=partial(prepare_infer_input, bos_id=bos_id, eos_id=eos_id, pad_id=eos_id), num_workers=0, return_list=True) model_maker = AttentionInferModel if args.attention else BaseInferModel model = model_maker(args.src_vocab_size, args.tar_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(inputs=inputs, device=device) # load the trained model assert args.reload_model, ( "Please set reload_model to load the infer model.") model.load(args.reload_model) # TODO(guosheng): use model.predict when support variant length with io.open(args.infer_output_file, 'w', encoding='utf-8') as f: for data in data_loader(): finished_seq = model.test_batch(inputs=flatten(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) break