def main():
config = Config.flags
if config.mode == 'gan':
scope = config.dis_run_name
run_name = config.run_name + "/discriminator"
config.mode = 'disc'
else:
scope = config.run_name
run_name = config.run_name
with tf.Graph().as_default(), tf.Session() as session:
with tf.variable_scope(scope):
model = init_model(config, None)
saver = tf.train.Saver([
var for var in tf.global_variables()
if 'embeddings' in var.name
])
ckpt = tf.train.latest_checkpoint(
os.path.join(config.model_dir, config.model, run_name))
print('Loading checkpoint: %s' % ckpt)
saver.restore(session, ckpt)
embeddings = session.run(model.embedding_model.embeddings)
if config.model == 'transd':
embeddings = np.concatenate(
(embeddings, session.run(
model.embedding_model.p_embeddings)),
axis=1)
np.savez_compressed(config.embedding_file, embs=embeddings)
def _load_model(args):
if not os.path.exists(args.checkpoint_dir):
raise SystemExit("predict: checkpoint directory %s does not exist" %
args.checkpoint_dir)
log.info("Loading trained model from %s", args.checkpoint_dir)
model = train.init_model()
model.load_weights(_checkpoint_path(args))
return model
def main():
# load settings for training
parser = argparse.ArgumentParser(
description='predict.py',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
config.preprocess_opts(parser)
config.model_opts(parser)
config.train_opts(parser)
config.predict_opts(parser)
config.transformer_opts(parser)
opt = parser.parse_args()
if opt.seed > 0:
torch.manual_seed(opt.seed)
# print(opt.gpuid)
if torch.cuda.is_available() and not opt.gpuid:
opt.gpuid = 0
opt.exp = 'predict.' + opt.exp
if hasattr(opt, 'copy_model') and opt.copy_model:
opt.exp += '.copy'
if hasattr(opt, 'bidirectional'):
if opt.bidirectional:
opt.exp += '.bi-directional'
else:
opt.exp += '.uni-directional'
# fill time into the name
if opt.exp_path.find('%s') > 0:
opt.exp_path = opt.exp_path % (opt.exp, opt.timemark)
opt.pred_path = opt.pred_path % (opt.exp, opt.timemark)
if not os.path.exists(opt.exp_path):
os.makedirs(opt.exp_path)
if not os.path.exists(opt.pred_path):
os.makedirs(opt.pred_path)
logging = config.init_logging(logger_name=None, log_file=opt.exp_path + '/output.log', stdout=True)
try:
opt.train_from = 'model/kp20k.ml.copy.bi-directional.20180908-054257/kp20k.ml.copy.bi-directional.epoch=9.batch=2932.model'
test_data_loader, word2id, id2word, vocab = load_data_vocab(opt, load_train=False)
model = init_model(opt)
generator = SequenceGenerator(model,opt,
eos_id=opt.word2id[pykp.io.EOS_WORD],
beam_size=opt.beam_size,
max_sequence_length=opt.max_sent_length,
)
evaluate_beam_search(generator, test_data_loader, opt, title='predict', save_path=opt.pred_path + '/[epoch=%d,batch=%d,total_batch=%d]test_result.csv' % (0, 0, 0))
except Exception as e:
logging.exception("message")
def load(self):
word2id, id2word, vocab = torch.load(self.model_opts.vocab, 'rb')
self.model_opts.word2id = word2id
self.model_opts.id2word = id2word
self.model_opts.vocab = vocab
self.model = init_model(self.model_opts)
self.generator = SequenceGenerator(
self.model,
eos_id=self.model_opts.word2id[pykp.io.EOS_WORD],
beam_size=self.model_opts.beam_size,
max_sequence_length=self.model_opts.max_sent_length)
def main():
opt = config.init_opt(description='predict_keyphrase.py')
logger = config.init_logging('predict_keyphrase',
opt.exp_path + '/output.log',
redirect_to_stdout=False)
logger.info('EXP_PATH : ' + opt.exp_path)
logger.info('Parameters:')
[
logger.info('%s : %s' % (k, str(v)))
for k, v in opt.__dict__.items()
]
logger.info(
'====================== Checking GPU Availability ========================='
)
if torch.cuda.is_available():
if isinstance(opt.device_ids, int):
opt.device_ids = [opt.device_ids]
logger.info('Running on %s! devices=%s' %
('MULTIPLE GPUs' if len(opt.device_ids) > 1 else '1 GPU',
str(opt.device_ids)))
else:
logger.info('Running on CPU!')
try:
one2one, one2many = generate_dataset()
test_data_loaders, word2id, id2word, vocab = load_vocab_and_testsets(
opt, one2one, one2many)
model = init_model(opt)
generator = SequenceGenerator(model,
eos_id=opt.word2id[pykp.io.EOS_WORD],
beam_size=opt.beam_size,
max_sequence_length=opt.max_sent_length)
for testset_name, test_data_loader in zip(['kp20k'],
test_data_loaders):
logger.info('Evaluating %s' % testset_name)
output = predict_beam_search(
generator,
test_data_loader,
opt,
title='test_%s' % testset_name,
predict_save_path=None
) #opt.pred_path + '/%s_test_result/' % (testset_name))
print(output)
except Exception as e:
logger.error(e, exc_info=True)
def load_model(args):
checkpoint_filename = args.checkpoint
checkpoint = torch.load(checkpoint_filename)
# Get args from saved checkpoint for rebuilding model
args.arch = checkpoint['arch']
args.input_size = checkpoint['input_size']
args.output_size = checkpoint['output_size']
args.hidden_units = checkpoint['hidden_size']
args.dropout = checkpoint['dropout']
args.pretrained = True
model = init_model(args)
model.load_state_dict(checkpoint['model_state'])
return model
def load_checkpoint_and_model(checkpoint_path, _device='cpu'):
print('loading checkpoint {}'.format(checkpoint_path))
checkpoint = torch.load(checkpoint_path, map_location=_device)
args = checkpoint['args']
epoch = checkpoint['epoch']
lang_model = checkpoint['lang_model']
pose_dim = checkpoint['pose_dim']
print('epoch {}'.format(epoch))
generator, loss_fn = init_model(args, lang_model, pose_dim, _device)
generator.load_state_dict(checkpoint['gen_dict'])
# set to eval mode
generator.train(False)
return args, generator, loss_fn, lang_model, pose_dim
method = args.method
pipeline = None
sr = 16000
split_ckpt = ckpt.split('/')
audio_length = 0.064
if args.length:
audio_length = args.length
if model_name == 'igan':
pipeline, sr = create_pipeline(data,
batch_size,
3 * audio_length,
prediction_only=False)
if model_name == 'pgan':
pipeline, sr = create_pipeline(data,
batch_size,
3 * audio_length,
prediction_only=True)
model = init_model(ckpt, pipeline, model_name)
evaluator = Percept_eval(model, target, sr)
dataloader = DataLoader.LoadData(data,
repeat=False,
audio_frame_length=2.220,
batch_size=batch_size)
dataset = dataloader.create_dataset()
if method == 'chaining':
evaluator.prediction_chaining(dataset,
pipeline,
length=audio_length * sr)
if method == 'single_hole':
evaluator.eval_on_1_hole(dataset, pipeline, length=audio_length)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--lut_points',
type=int,
default=32,
help='lut points')
parser.add_argument('--load_from',
type=str,
default="newest.ckpt",
help='load from ckpt')
parser.add_argument('--give_ref',
type=bool,
default=False,
help='give reference img and color graded img')
parser.add_argument('--lut',
type=str,
default=None,
help='reference lut img')
parser.add_argument('--input', type=str, default=None, help='input img')
parser.add_argument('--input_type',
type=str,
default='img',
help='input type')
parser.add_argument('--clear_lut',
type=bool,
default=False,
help='clear LUT instead of apply')
parser.add_argument('--output_lut',
type=str,
default='lut_test/lut.png',
help='output lut path')
parser.add_argument('--output_path',
type=str,
default=None,
help='output img path')
args = parser.parse_args()
model, device = init_model(args)
model.eval()
Img_resize = Img()
Img_noresize = Img(False)
if not args.clear_lut:
lut_img = Img_resize.read_img(args.lut).unsqueeze(0).to(device)
input_img = Img_resize.read_img(args.input).unsqueeze(0).to(device)
with torch.no_grad():
if args.clear_lut:
output_lut = model(input_img)
else:
output_lut = model(lut_img)
output_interp_lut = Img.interp_lut(output_lut)
input_img = Img_noresize.read_img(args.input).unsqueeze(0).to(device)
output_batch = Img.apply_lut(input_img, output_interp_lut, device)
Img.write_img(output_batch[0, :, :, :], args.output_path)
lut = output_interp_lut[0, :, :].detach().cpu().numpy()
fig, ax = plt.subplots(nrows=1, ncols=1)
ax.plot(lut[0, :], color='red')
ax.plot(lut[1, :], color='green')
ax.plot(lut[2, :], color='blue')
plt.savefig(args.output_lut)
plt.close()
def main():
# load settings for training
parser = argparse.ArgumentParser(
description='predict.py',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
config.preprocess_opts(parser)
config.model_opts(parser)
config.train_opts(parser)
config.predict_opts(parser)
opt = parser.parse_args()
if opt.seed > 0:
torch.manual_seed(opt.seed)
print(opt.gpuid)
if torch.cuda.is_available() and not opt.gpuid:
opt.gpuid = 0
opt.exp = 'predict.' + opt.exp
if hasattr(opt, 'copy_model') and opt.copy_model:
opt.exp += '.copy'
if hasattr(opt, 'bidirectional'):
if opt.bidirectional:
opt.exp += '.bi-directional'
else:
opt.exp += '.uni-directional'
# fill time into the name
if opt.exp_path.find('%s') > 0:
opt.exp_path = opt.exp_path % (opt.exp, opt.timemark)
opt.pred_path = opt.pred_path % (opt.exp, opt.timemark)
if not os.path.exists(opt.exp_path):
os.makedirs(opt.exp_path)
if not os.path.exists(opt.pred_path):
os.makedirs(opt.pred_path)
logging = config.init_logging('train', opt.exp_path + '/output.log')
logging.info('Parameters:')
[
logging.info('%s : %s' % (k, str(v)))
for k, v in opt.__dict__.items()
]
try:
train_data_loader, valid_data_loader, test_data_loader, word2id, id2word, vocab = load_data_vocab(
opt, load_train=False)
model = init_model(opt)
# optimizer, criterion = init_optimizer_criterion(model, opt)
generator = SequenceGenerator(model,
eos_id=opt.word2id[pykp.io.EOS_WORD],
beam_size=opt.beam_size,
max_sequence_length=opt.max_sent_length)
# import time
# start_time = time.time()
evaluate_beam_search(
generator,
test_data_loader,
opt,
title='predict',
save_path=opt.pred_path +
'/[epoch=%d,batch=%d,total_batch=%d]test_result.csv' % (0, 0, 0))
# print("--- %s seconds --- Complete Beam Search" % (time.time() - start_time))
# predict_greedy(model, test_data_loader, test_examples, opt)
except Exception as e:
logging.exception("message")
def main():
opt = config.init_opt(description='predict.py')
logger = config.init_logging('predict',
opt.exp_path + '/output.log',
redirect_to_stdout=False)
logger.info('EXP_PATH : ' + opt.exp_path)
logger.info('Parameters:')
[
logger.info('%s : %s' % (k, str(v)))
for k, v in opt.__dict__.items()
]
logger.info(
'====================== Checking GPU Availability ========================='
)
if torch.cuda.is_available():
if isinstance(opt.device_ids, int):
opt.device_ids = [opt.device_ids]
logger.info('Running on %s! devices=%s' %
('MULTIPLE GPUs' if len(opt.device_ids) > 1 else '1 GPU',
str(opt.device_ids)))
else:
logger.info('Running on CPU!')
try:
valid_data_loaders, word2id, id2word, vocab = load_vocab_and_datasets_for_testing(
dataset_names=opt.test_dataset_names, type='valid', opt=opt)
test_data_loaders, _, _, _ = load_vocab_and_datasets_for_testing(
dataset_names=opt.test_dataset_names, type='test', opt=opt)
opt.word2id = word2id
opt.id2word = id2word
opt.vocab = vocab
model = init_model(opt)
generator = SequenceGenerator(model,
eos_id=opt.word2id[pykp.io.EOS_WORD],
beam_size=opt.beam_size,
max_sequence_length=opt.max_sent_length)
valid_score_dict = evaluate_multiple_datasets(
generator,
valid_data_loaders,
opt,
title='valid',
predict_save_path=opt.pred_path)
test_score_dict = evaluate_multiple_datasets(
generator,
test_data_loaders,
opt,
title='test',
predict_save_path=opt.pred_path)
# test_data_loaders, word2id, id2word, vocab = load_vocab_and_datasets(opt)
# for testset_name, test_data_loader in zip(opt.test_dataset_names, test_data_loaders):
# logger.info('Evaluating %s' % testset_name)
# evaluate_beam_search(generator, test_data_loader, opt,
# title='test_%s' % testset_name,
# predict_save_path=opt.pred_path + '/%s_test_result/' % (testset_name))
except Exception as e:
logger.error(e, exc_info=True)
def get_model_for_prediction():
# reset batchsize to 1 of the trained model
trained_model = load_model(MODEL_NAME)
return init_model(batch_size=1, weights=trained_model.get_weights())
from transformers import TextGenerationPipeline
from transformers import GPT2Tokenizer
from train import init_model, load_tokenizer
tokenizer = load_tokenizer()
model = init_model(tokenizer)
text_generator = TextGenerationPipeline(model, tokenizer)
print(
text_generator("唐诗：",
max_length=64,
do_sample=True,
top_k=10,
eos_token_id=tokenizer.get_vocab().get("】", 0)))
print(
text_generator("此地是我开",
max_length=64,
do_sample=True,
top_k=10,
eos_token_id=tokenizer.get_vocab().get("】", 0)))
print(
text_generator("一只乌鸦",
max_length=64,
do_sample=True,
top_k=10,
eos_token_id=tokenizer.get_vocab().get("】", 0)))
print(text_generator("走向森林 ", max_length=64, do_sample=False))
print(text_generator("拿出一本秘籍", max_length=64, do_sample=False))
print(text_generator("今日", max_length=64, do_sample=False))
print(text_generator("大江东去", max_length=64, do_sample=False))
def main():
opt = config.init_opt(description='predict.py')
opt.data = 'data3/kp20k/kp20k'
opt.vocab = 'data3/kp20k/kp20k.vocab.pt'
#opt.train_from = 'exp/kp20k.ml.copy.20181129-193506/model/kp20k.ml.copy.epoch=1.batch=20000.total_batch=20000.model'
opt.train_from = 'exp/kp20k.ml.copy.20181128-153121/model/kp20k.ml.copy.epoch=2.batch=15495.total_batch=38000.model'
opt.useGpu = 0
opt.encoder_type = 'rnn'
opt.useCLF = False
if opt.encoder_type.startswith('transformer'):
opt.batch_size = 32
opt.d_inner = 2048
opt.enc_n_layers = 4
opt.dec_n_layers = 2
opt.n_head = 8
opt.d_k = 64
opt.d_v = 64
opt.d_model = 512
opt.word_vec_size = 512
opt.run_valid_every = 5000000
opt.save_model_every = 20000
opt.decode_old = True
# opt.copy_attention = False
elif opt.encoder_type.startswith('bert'):
opt.useOnlyTwo = False
opt.avgHidden = True
opt.useZeroDecodeHidden = False
opt.useSameEmbeding = False
opt.batch_size = 10
opt.max_sent_length = 10
opt.run_valid_every = 20000
opt.decode_old = False
opt.beam_search_batch_size = 10
opt.bert_model = 'bert-base-uncased'
opt.tokenizer = BertTokenizer.from_pretrained(opt.bert_model)
if opt.encoder_type == 'bert_low':
opt.copy_attention = False
else:
opt.enc_layers = 2
opt.bidirectional = True
opt.decode_old = True
logger = config.init_logging('predict',
opt.exp_path + '/output.log',
redirect_to_stdout=False)
logger.info('EXP_PATH : ' + opt.exp_path)
logger.info('Parameters:')
[
logger.info('%s : %s' % (k, str(v)))
for k, v in opt.__dict__.items()
]
logger.info(
'====================== Checking GPU Availability ========================='
)
if torch.cuda.is_available() and opt.useGpu:
if isinstance(opt.gpuid, int):
opt.gpuid = [opt.gpuid]
logger.info('Running on %s! devices=%s' %
('MULTIPLE GPUs' if len(opt.gpuid) > 1 else '1 GPU',
str(opt.gpuid)))
else:
logger.info('Running on CPU!')
try:
test_data_loaders, word2id, id2word, vocab = load_vocab_and_testsets(
opt)
model = init_model(opt)
if torch.cuda.is_available() and opt.useGpu:
model.cuda()
generator = SequenceGenerator(model,
opt.word_vec_size if opt.encoder_type
== 'transformer' else opt.vocab_size,
eos_id=opt.word2id[pykp.io.EOS_WORD],
beam_size=opt.beam_size,
max_sequence_length=opt.max_sent_length,
useGpu=opt.useGpu)
for testset_name, test_data_loader in zip(opt.test_dataset_names,
test_data_loaders):
logger.info('Evaluating %s' % testset_name)
evaluate_beam_search(generator,
test_data_loader,
opt,
title='test_%s' % testset_name,
predict_save_path=opt.pred_path +
'/%s_test_result/' % (testset_name))
except Exception as e:
logger.error(e, exc_info=True)
