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
