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)