def train(self, D, G, optimizer_D, optimizer_G, train, val=None, num_epoch=200, resume=False, opt=None): start_epoch = 0 if resume: cp = Checkpoint.load( Checkpoint.get_latest_checkpoint('./experiment/gan')) self.model = cp.model start_epoch = cp.epoch + 1 for epoch in range(start_epoch, num_epoch): logging.info('Epoch[%d] CycleGAN train' % epoch) train_iter, val_iter = torchtext.data.BucketIterator.splits( (train, val), batch_sizes=(1, 64), device=opt.device, sort_key=lambda x: len(x.real_a), repeat=False) self.train_epoch(D, G, optimizer_D, optimizer_G, train_iter)
def dev_predict(task_path, src_str, is_plot=True): """Helper used to visualize and understand why and what the model predicts. Args: task_path (str): path to the saved task directory containing, amongst other, the model. src_str (str): source sentence that will be used to predict. is_plot (bool, optional): whether to plots the attention pattern. Returns: out_words (list): decoder predictions. other (dictionary): additional information used for predictions. test (dictionary): additional information that is only stored in dev mode. These can include temporary variables that do not have to be stored in `other` but that can still be interesting to inspect. """ check = Checkpoint.load(task_path) check.model.set_dev_mode() predictor = Predictor(check.model, check.input_vocab, check.output_vocab) out_words, other = predictor.predict(src_str.split()) test = dict() for k, v in other["test"].items(): tensor = v if isinstance(v, torch.Tensor) else torch.cat(v) test[k] = tensor.detach().cpu().numpy().squeeze()[:other["length"][0]] # except: # for using "step" # test[k] = v if is_plot: visualizer = AttentionVisualizer(task_path) visualizer(src_str) return out_words, other, test
def predict_with_checkpoint(checkpoint_path, sequence, hierarchial = False, remote = None, word_vectors = None): checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab seq2seq.encoder.word_vectors, seq2seq.decoder.word_vectors = None, None if word_vectors != None: input_vects = Word2Vectors(input_vocab, word_vectors, word_vectors.dim_size) output_vects = Word2Vectors(output_vocab, word_vectors, word_vectors.dim_size) seq2seq.encoder.word_vectors, seq2seq.decoder.word_vectors = input_vects, output_vects seq2seq.decoder = TopKDecoder(seq2seq.decoder, 5) if not hierarchial: predictor = Predictor(seq2seq, input_vocab, output_vocab) seq = sequence.strip().split() else: predictor = HierarchialPredictor(seq2seq, input_vocab, output_vocab) seq = ['|'.join(x.split()) for x in sequence] return ' '.join(predictor.predict(seq))
def test(self, args, model, dataloader, resume=False, save_dir='runs/exp'): # If training is set to resume if resume: latest_checkpoint_path = Checkpoint.get_latest_checkpoint( self.model_dir) resume_checkpoint = Checkpoint.load(latest_checkpoint_path) model.load_state_dict(resume_checkpoint.model) self.optimizer = None self.args = args model.args = args start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step print('Resume from ', latest_checkpoint_path) print('start_epoch : ', start_epoch) print('step : ', step) start_epoch = 1 step = 0 else: print('Please Resume !') raise if args.mode == 'bleu_t1t2': print('Eval on bleu_t1&t2 !') self._test_epoches_t1t2(dataloader, model, step, save_dir=save_dir, args=args) else: print('Please choose t1 | t2 mode !') raise return model
def __init__(self, checkpoint, is_predict_eos=True, is_symbol_rewriting=False): if isinstance(checkpoint, str): checkpoint = Checkpoint.load(checkpoint) self.is_predict_eos = is_predict_eos self.tabular_data_fields = get_tabular_data_fields( is_predict_eos=self.is_predict_eos) dic_data_fields = dict(self.tabular_data_fields) src = dic_data_fields["src"] tgt = dic_data_fields["tgt"] src.vocab = checkpoint.input_vocab tgt.vocab = checkpoint.output_vocab tgt.eos_id = tgt.vocab.stoi[tgt.SYM_EOS] tgt.sos_id = tgt.vocab.stoi[tgt.SYM_SOS] if is_symbol_rewriting: metric_names = ["symbol rewriting accuracy"] elif self.is_predict_eos: metric_names = ["word accuracy", "sequence accuracy"] else: metric_names = ["word accuracy", "final target accuracy"] self.metrics = get_metrics(metric_names, src, tgt, self.is_predict_eos) self.tgt = tgt self.src = src
def __init__(self, ckpt_path='./Res/PretrainModel/2019_12_27_08_48_21/'): checkpoint = Checkpoint.load(ckpt_path) self.seq2seq = checkpoint.model self.input_vocab = checkpoint.input_vocab self.output_vocab = checkpoint.output_vocab self.predictor = Predictor(self.seq2seq, self.input_vocab, self.output_vocab)
def train(self, model, data, num_epochs=5, resume=False, dev_data=None, monitor_data={}, optimizer=None, teacher_forcing_ratio=0, learning_rate=0.001, checkpoint_path=None, top_k=5): """ Run training for a given model. Args: model (seq2seq.models): model to run training on, if `resume=True`, it would be overwritten by the model loaded from the latest checkpoint. data (seq2seq.dataset.dataset.Dataset): dataset object to train on num_epochs (int, optional): number of epochs to run (default 5) resume(bool, optional): resume training with the latest checkpoint, (default False) dev_data (seq2seq.dataset.dataset.Dataset, optional): dev Dataset (default None) optimizer (seq2seq.optim.Optimizer, optional): optimizer for training (default: Optimizer(pytorch.optim.Adam, max_grad_norm=5)) teacher_forcing_ratio (float, optional): teaching forcing ratio (default 0) learing_rate (float, optional): learning rate used by the optimizer (default 0.001) checkpoint_path (str, optional): path to load checkpoint from in case training should be resumed top_k (int): how many models should be stored during training Returns: model (seq2seq.models): trained model. """ # If training is set to resume if resume: resume_checkpoint = Checkpoint.load(checkpoint_path) model = resume_checkpoint.model self.optimizer = resume_checkpoint.optimizer # A walk around to set optimizing parameters properly resume_optim = self.optimizer.optimizer defaults = resume_optim.param_groups[0] defaults.pop('params', None) defaults.pop('initial_lr', None) self.optimizer.optimizer = resume_optim.__class__(model.parameters(), **defaults) start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step else: start_epoch = 1 step = 0 def get_optim(optim_name): optims = {'adam': optim.Adam, 'adagrad': optim.Adagrad, 'adadelta': optim.Adadelta, 'adamax': optim.Adamax, 'rmsprop': optim.RMSprop, 'sgd': optim.SGD, None:optim.Adam} return optims[optim_name] self.optimizer = Optimizer(get_optim(optimizer)(model.parameters(), lr=learning_rate), max_grad_norm=5) self.logger.info("Optimizer: %s, Scheduler: %s" % (self.optimizer.optimizer, self.optimizer.scheduler)) logs = self._train_epoches(data, model, num_epochs, start_epoch, step, dev_data=dev_data, monitor_data=monitor_data, teacher_forcing_ratio=teacher_forcing_ratio, top_k=top_k) return model, logs
def test(self, args, model, dataloader, scheduler, num_epochs=5, resume=False, dev_data=None, optimizer=None, teacher_forcing_ratio=1.0, save_dir='runs/exp'): # If training is set to resume if resume: latest_checkpoint_path = Checkpoint.get_latest_checkpoint(self.model_dir) resume_checkpoint = Checkpoint.load(latest_checkpoint_path) # model = resume_checkpoint.model model.load_state_dict(resume_checkpoint.model) self.optimizer = None self.args = args model.args = args start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step print('Resume from ', latest_checkpoint_path) print('start_epoch : ', start_epoch) print('step : ', step) start_epoch = 1 step = 0 else: print('Please Resume !') raise self._test_epoches(dataloader, model, num_epochs, start_epoch, step, dev_data=dev_data, teacher_forcing_ratio=teacher_forcing_ratio, clip=args.clip, save_dir=save_dir, args=args) return model
def train(self, model, data, num_epochs=5, resume=False, dev_data=None, optimizer=None, teacher_forcing_ratio=0): """ Run training for a given model. Args: model (seq2seq.models): model to run training on, if `resume=True`, it would be overwritten by the model loaded from the latest checkpoint. data (seq2seq.dataset.dataset.Dataset): dataset object to train on num_epochs (int, optional): number of epochs to run (default 5) resume(bool, optional): resume training with the latest checkpoint, (default False) dev_data (seq2seq.dataset.dataset.Dataset, optional): dev Dataset (default None) optimizer (seq2seq.optim.Optimizer, optional): optimizer for training (default: Optimizer(pytorch.optim.Adam, max_grad_norm=5)) teacher_forcing_ratio (float, optional): teaching forcing ratio (default 0) Returns: model (seq2seq.models): trained model. """ # If training is set to resume if resume: latest_checkpoint_path = Checkpoint.get_latest_checkpoint( self.expt_dir) resume_checkpoint = Checkpoint.load(latest_checkpoint_path) model = resume_checkpoint.model self.optimizer = resume_checkpoint.optimizer # A walk around to set optimizing parameters properly resume_optim = self.optimizer.optimizer defaults = resume_optim.param_groups[0] defaults.pop('params', None) defaults.pop('initial_lr', None) self.optimizer.optimizer = resume_optim.__class__( model.parameters(), **defaults) start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step else: start_epoch = 1 step = 0 if optimizer is None: optimizer = Optimizer(optim.Adam(model.parameters()), max_grad_norm=5) self.optimizer = optimizer self.logger.info("Optimizer: %s, Scheduler: %s" % (self.optimizer.optimizer, self.optimizer.scheduler)) self._train_epoches(data, model, num_epochs, start_epoch, step, dev_data=dev_data, teacher_forcing_ratio=teacher_forcing_ratio) return model
def train(self, train, val=None, num_epoch=200, resume=False): start_epoch = 0 if resume: cp = Checkpoint.load( Checkpoint.get_latest_checkpoint('./experiment/gan')) self.model = cp.model start_epoch = cp.epoch + 1 for epoch in range(start_epoch, num_epoch): logging.info('Epoch[%d] CycleGAN train' % epoch) train_iter, val_iter = torchtext.data.BucketIterator.splits( (train, val), batch_sizes=(1, 64), device=self.device, sort_key=lambda x: len(x.real_a), repeat=False) self._train_epoch(train_iter) self.evaluate(val_iter) Checkpoint(model=self.model, optimizer=None, epoch=epoch, step=0, input_vocab=None, output_vocab=None).save('./experiment/gan')
def _evaluate(checkpoint_path, test_paths, metric_names=[ "word accuracy", "sequence accuracy", "final target accuracy" ], loss_names=["nll"], max_len=50, batch_size=32, is_predict_eos=True, content_method=None): """Evaluates the models saved in a checkpoint.""" results = [] print("loading checkpoint from {}".format(os.path.join(checkpoint_path))) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model tabular_data_fields = get_tabular_data_fields( content_method=content_method, is_predict_eos=is_predict_eos) dic_data_fields = dict(tabular_data_fields) src = dic_data_fields["src"] tgt = dic_data_fields["tgt"] src.vocab = checkpoint.input_vocab tgt.vocab = checkpoint.output_vocab tgt.eos_id = tgt.vocab.stoi[tgt.SYM_EOS] tgt.sos_id = tgt.vocab.stoi[tgt.SYM_SOS] for test_path in test_paths: test = get_data(test_path, max_len, tabular_data_fields) metrics = get_metrics(metric_names, src, tgt, is_predict_eos) losses, loss_weights = get_losses(loss_names, tgt, is_predict_eos) evaluator = Evaluator(loss=losses, batch_size=batch_size, metrics=metrics) data_func = SupervisedTrainer.get_batch_data losses, metrics = evaluator.evaluate(model=seq2seq, data=test, get_batch_data=data_func) total_loss, log_msg, _ = SupervisedTrainer.get_losses( losses, metrics, 0) dataset = test_path.split('/')[-1].split('.')[0] results.append([dataset, total_loss] + [metric.get_val() for metric in metrics]) results_df = pd.DataFrame(results, columns=["Dataset", "Loss"] + [metric.name for metric in metrics]) results_df = results_df.melt(id_vars=['Dataset'], var_name="Metric", value_name='Value') return results_df
def load_model(expt_dir, model_name): checkpoint_path = os.path.join(expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, model_name) checkpoint = Checkpoint.load(checkpoint_path) model = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab return model, input_vocab, output_vocab
def test(): checkpoint_path = 'model' checkpoint = Checkpoint.load(checkpoint_path) model = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab predictor = KinasePredictor(model, input_vocab, output_vocab) prediction(predictor, output_vocab)
def load_model(expt_dir, model_name): checkpoint_path = os.path.join(expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, model_name) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab seq2seq.eval() return seq2seq, input_vocab, output_vocab
def init_model(): if args.load_checkpoint is not None: logging.info("loading checkpoint from {}".format( os.path.join(args.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, args.load_checkpoint))) checkpoint_path = os.path.join(args.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, args.load_checkpoint) checkpoint = Checkpoint.load(checkpoint_path) model = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab else: # build the vocabulary index and embedding spk.build_vocab(train, vectors="glove.6B.100d") src.build_vocab(train, max_size=args.vocab_size, vectors="glove.6B.100d") tgt.build_vocab(train, max_size=args.vocab_size, vectors="glove.6B.100d") input_vocab, output_vocab = src.vocab, tgt.vocab # Initialize model encoder = EncoderRNN( vocab_size=len(input_vocab), max_len=args.max_len, vectors=input_vocab.vectors if args.embedding else None, input_dropout_p=args.input_dropout_p, dropout_p=args.dropout_p, hidden_size=args.hidden_size, bidirectional=args.bidirectional, variable_lengths=True) decoder = SpkDecoderRNN( num_spk=args.num_spk, spk_embed_size=args.spk_embed_size, vocab_size=len(output_vocab), max_len=args.max_len, hidden_size=args.hidden_size * 2 if args.bidirectional else args.hidden_size, dropout_p=args.dropout_p, input_dropout_p=args.input_dropout_p, vectors=input_vocab.vectors if args.embedding else None, use_attention=True, bidirectional=args.bidirectional, eos_id=tgt.eos_id, sos_id=tgt.sos_id) model = SpkSeq2seq(encoder, decoder) if torch.cuda.is_available(): model.cuda() for param in model.parameters(): param.data.uniform_(-0.08, 0.08) return model, input_vocab, output_vocab
def load_checkpoint(checkpoint_name, expt_dir): if checkpoint_name is not None: logging.info("loading checkpoint from {}".format( os.path.join(expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, checkpoint_name))) checkpoint_path = os.path.join(expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, checkpoint_name) else: checkpoint_path = Checkpoint.get_latest_checkpoint(expt_dir) return Checkpoint.load(checkpoint_path)
def load_checkpoint(experiment_directory, checkpoint): checkpoint_path = os.path.join( experiment_directory, Checkpoint.CHECKPOINT_DIR_NAME, checkpoint, ) logging.info('Loading checkpoint from {}'.format(checkpoint_path, )) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab return seq2seq, input_vocab, output_vocab
def load_model(opt): checkpoint_path = os.path.join(opt.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, opt.load_checkpoint) checkpoint = Checkpoint.load(checkpoint_path) model = checkpoint.model src_vocab = checkpoint.input_vocab tgt_vocab = checkpoint.output_vocab if opt.verbose: print('Loaded model') # model.eval() return model, src_vocab, tgt_vocab
def __init__(self, device='cuda', model_path='./PretrainModel/Seq2Rank/', model_file='seq2rank.ckpt'): try: checkpoint = Checkpoint.load(os.path.join(model_path, model_file)) except: logging.error( '[ERROR] [Seq2Rank] Pretrain Encode model load failed on {0}'. format(os.path.join(model_path, model_file))) self.seq2seq = checkpoint.model self.input_vocab = checkpoint.input_vocab self.output_vocab = checkpoint.output_vocab self.device = device
def load_model_from_checkpoint(opt, src, tgt): logging.info("loading checkpoint from {}".format( os.path.join(opt.output_dir, opt.load_checkpoint))) checkpoint_path = os.path.join(opt.output_dir, opt.load_checkpoint) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab src.vocab = input_vocab output_vocab = checkpoint.output_vocab tgt.vocab = output_vocab tgt.eos_id = tgt.vocab.stoi[tgt.SYM_EOS] tgt.sos_id = tgt.vocab.stoi[tgt.SYM_SOS] return seq2seq, input_vocab, output_vocab
def train(self, model, data, num_epochs=5, resume=False, dev_data=None, optimizer=None, teacher_forcing_ratio=0): """ Run training for a given model. Args: model (seq2seq.models): model to run training on, if `resume=True`, it would be overwritten by the model loaded from the latest checkpoint. data (seq2seq.dataset.dataset.Dataset): dataset object to train on num_epochs (int, optional): number of epochs to run (default 5) resume(bool, optional): resume training with the latest checkpoint, (default False) dev_data (seq2seq.dataset.dataset.Dataset, optional): dev Dataset (default None) optimizer (seq2seq.optim.Optimizer, optional): optimizer for training (default: Optimizer(pytorch.optim.Adam, max_grad_norm=5)) teacher_forcing_ratio (float, optional): teaching forcing ratio (default 0) Returns: model (seq2seq.models): trained model. """ # If training is set to resume if resume: latest_checkpoint_path = Checkpoint.get_latest_checkpoint(self.expt_dir) resume_checkpoint = Checkpoint.load(latest_checkpoint_path) model = resume_checkpoint.model self.optimizer = resume_checkpoint.optimizer # A walk around to set optimizing parameters properly resume_optim = self.optimizer.optimizer defaults = resume_optim.param_groups[0] defaults.pop('params', None) self.optimizer.optimizer = resume_optim.__class__(model.parameters(), **defaults) start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step else: start_epoch = 1 step = 0 if optimizer is None: optimizer = Optimizer(optim.Adam(model.parameters()), max_grad_norm=5) self.optimizer = optimizer self.logger.info("Optimizer: %s, Scheduler: %s" % (self.optimizer.optimizer, self.optimizer.scheduler)) self._train_epoches(data, model, num_epochs, start_epoch, step, dev_data=dev_data, teacher_forcing_ratio=teacher_forcing_ratio) return model
def train(self, encoder, decoder, data, num_epochs=5, resume=False, dev_data=None, optimizer=None, is_training=0): if resume: latest_checkpoint_path = Checkpoint.get_latest_checkpoint( self.expt_dir) resume_checkpoint = Checkpoint.load(latest_checkpoint_path) decoder = resume_checkpoint.model self.optimizer = resume_checkpoint.optimizer # A walk around to set optimizing parameters properly resume_optim = self.optimizer.optimizer defaults = resume_optim.param_groups[0] defaults.pop('params', None) defaults.pop('initial_lr', None) self.optimizer.optimizer = resume_optim.__class__( decoder.parameters(), **defaults) start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step else: start_epoch = 1 step = 0 if optimizer is None: optimizer = Optimizer(optim.Adam(decoder.parameters()), max_grad_norm=5) self.optimizer = optimizer self.logger.info("Optimizer: %s, Scheduler: %s" % (self.optimizer.optimizer, self.optimizer.scheduler)) self._train_epoches(data, encoder, decoder, num_epochs, start_epoch, step, dev_data=dev_data, is_training=is_training) return decoder
def train(self, args, model, dataloader, scheduler, num_epochs=5, resume=False, dev_data=None, optimizer=None, teacher_forcing_ratio=1.0, save_dir='runs/exp'): # If training is set to resume if resume: latest_checkpoint_path = Checkpoint.get_latest_checkpoint(self.model_dir) resume_checkpoint = Checkpoint.load(latest_checkpoint_path) # model = resume_checkpoint.model model.load_state_dict(resume_checkpoint.model) self.optimizer = optimizer self.args = args model.args = args start_epoch = resume_checkpoint.epoch step = resume_checkpoint.step print('Resume from ', latest_checkpoint_path) print('start_epoch : ', start_epoch) print('step : ', step) if args.adam: self.optimizer = torch.optim.Adam(model.parameters()) optimizer.load_state_dict(resume_checkpoint.optimizer) elif args.sgd: self.optimizer = torch.optim.SGD(model.parameters(), lr=args.lr) optimizer.load_state_dict(resume_checkpoint.optimizer) self.scheduler = lr_scheduler.StepLR(self.optimizer, args.decay_steps, gamma=args.decay_factor) # for i in range(step): # self.scheduler.step() self.scheduler._step_count = step for param_group in self.optimizer.param_groups: print('learning rate', param_group['lr'], step) else: start_epoch = 1 step = 0 if optimizer is None: optimizer = Optimizer(optim.Adam(model.parameters()), max_grad_norm=5) self.optimizer = optimizer self.scheduler = scheduler # self.logger.info("Optimizer: %s, Scheduler: %s" % (self.optimizer.optimizer, self.optimizer.scheduler)) if args.only_sql: self._train_sql_epoches(dataloader, model, num_epochs, start_epoch, step, dev_data=dev_data, teacher_forcing_ratio=teacher_forcing_ratio, clip=args.clip, save_dir=save_dir, args=args) else: self._train_epoches(dataloader, model, num_epochs, start_epoch, step, dev_data=dev_data, teacher_forcing_ratio=teacher_forcing_ratio, clip=args.clip, save_dir=save_dir, args=args) return model
def test_load(self, mock_vocabulary, mock_torch): dummy_vocabulary = mock.Mock() mock_optimizer_state_dict = mock.Mock() torch_dict = {"optimizer": mock_optimizer_state_dict, "epoch": 5, "step": 10} mock_torch.load.return_value = torch_dict mock_vocabulary.load.return_value = dummy_vocabulary loaded_chk_point = Checkpoint.load("mock_checkpoint_path") mock_torch.load.assert_any_call( os.path.join('mock_checkpoint_path', Checkpoint.TRAINER_STATE_NAME)) mock_torch.load.assert_any_call( os.path.join("mock_checkpoint_path", Checkpoint.MODEL_NAME)) self.assertEquals(loaded_chk_point.epoch, torch_dict['epoch']) self.assertEquals(loaded_chk_point.optimizer_state_dict, torch_dict['optimizer']) self.assertEquals(loaded_chk_point.step, torch_dict['step'])
def test_load(self, mock_open, mock_dill, mock_torch): dummy_vocabulary = mock.Mock() mock_optimizer = mock.Mock() torch_dict = {"optimizer": mock_optimizer, "epoch": 5, "step": 10} mock_open.return_value = mock.MagicMock() mock_torch.load.side_effect = [torch_dict, mock.MagicMock()] mock_dill.load.return_value = dummy_vocabulary loaded_chk_point = Checkpoint.load("mock_checkpoint_path") mock_torch.load.assert_any_call( os.path.join('mock_checkpoint_path', Checkpoint.TRAINER_STATE_NAME)) mock_torch.load.assert_any_call( os.path.join("mock_checkpoint_path", Checkpoint.MODEL_NAME)) self.assertEqual(loaded_chk_point.epoch, torch_dict['epoch']) self.assertEqual(loaded_chk_point.optimizer, torch_dict['optimizer']) self.assertEqual(loaded_chk_point.step, torch_dict['step']) self.assertEqual(loaded_chk_point.input_vocab, dummy_vocabulary) self.assertEqual(loaded_chk_point.output_vocab, dummy_vocabulary)
def load_model_data_evaluator(expt_dir, model_name, data_path, batch_size=128): checkpoint_path = os.path.join(expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, model_name) checkpoint = Checkpoint.load(checkpoint_path) model = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab data_all, data_sml, data_med, data_lrg, fields_inp, src, tgt, src_adv, idx_field = load_data(data_path) src.vocab = input_vocab tgt.vocab = output_vocab src_adv.vocab = input_vocab weight = torch.ones(len(tgt.vocab)) pad = tgt.vocab.stoi[tgt.pad_token] loss = Perplexity(weight, pad) if torch.cuda.is_available(): loss.cuda() evaluator = Evaluator(loss=loss, batch_size=batch_size) return model, data_all, data_sml, data_med, data_lrg, evaluator, fields_inp
def _load_output_training(task_path, _filenames=dict(results="results.csv", histories="histories.csv", other="other.pkl", parameters='train_arguments.txt')): """Loads all the components that were saved during and at the end of training.""" checkpoint = Checkpoint.load(task_path) model = checkpoint.model results = pd.read_csv(os.path.join(task_path, _filenames["results"])) histories = pd.read_csv(os.path.join(task_path, _filenames["histories"]), converters={ 0: ast.literal_eval, 1: ast.literal_eval }) with open(os.path.join(task_path, _filenames["other"]), 'rb') as f: other = pickle.load(f) with open(os.path.join(task_path, _filenames["parameters"]), 'r') as f: parameters = json.load(f) histories = _format_losses_history(histories) return model, results, histories, other, parameters
def test(opt, test_path): if opt.load_checkpoint is not None: # load model logging.info("loading check point from {}".format( os.path.join(opt.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, opt.load_checkpoint))) checkpoint_path = os.path.join(opt.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, opt.load_checkpoint) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab # Prepare predictor predictor = Predictor(seq2seq, input_vocab, output_vocab) with open(test_path, 'r') as reader, open(test_path + '_pred', 'w') as writer: for line in reader: source = treebank_tokenizer(line.split("\t")[0]) writer.write(generate(source, predictor) + '\n')
def test(expt_dir, checkpoint, test_file, output_file): if checkpoint is not None: checkpoint_path = os.path.join(expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, checkpoint) logging.info("loading checkpoint from {}".format(checkpoint_path)) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab else: raise Exception("checkpoint path does not exist") predictor = Predictor(seq2seq, input_vocab, output_vocab) output = open(output_file, 'ab') with open(test_file) as f: for line_ in f: line = line_.strip().split('<s>') if len(line) != 0: question = basic_tokenizer(line[-2]) answer = predictor.predict(question)[:-1] output.write(''.join(answer) + '\n')
help='Logging level.') opt = parser.parse_args() LOG_FORMAT = '%(asctime)s %(name)-12s %(levelname)-8s %(message)s' logging.basicConfig(format=LOG_FORMAT, level=getattr(logging, opt.log_level.upper())) logging.info(opt) if opt.load_checkpoint is not None: logging.info("loading checkpoint from {}".format( os.path.join(opt.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, opt.load_checkpoint))) checkpoint_path = os.path.join(opt.expt_dir, Checkpoint.CHECKPOINT_DIR_NAME, opt.load_checkpoint) checkpoint = Checkpoint.load(checkpoint_path) seq2seq = checkpoint.model input_vocab = checkpoint.input_vocab output_vocab = checkpoint.output_vocab else: # Prepare dataset # SourceField requires that batch_first and include_lengths be true. src = SourceField(lower=opt.lower) # TargetField requires that batch_first be true as well as prepends <sos> and appends <eos> to sequences. tgt = TargetField() # Sequence's length cannot exceed max_len. max_len = 100 def len_filter(example): return len(example.src) <= max_len and len(example.tgt) <= max_len
def __init__( self, task_path, figsize=(15, 13), decimals=2, is_show_attn_split=True, is_show_evaluation=True, output_length_key='length', attention_key="attention_score", position_attn_key='position_attention', content_attn_key='content_attention', positional_table_labels={ "λ%": "position_percentage", "C.γ": "content_confidence", #"lgt": "approx_max_logit", "C.λ": "pos_confidence", "μ": "mu", "σ": "sigma", "w_α": "mean_attn_old_weight", "w_j/n": "rel_counter_decoder_weight", "w_1/n": "single_step_weight", "w_μ": "mu_old_weight", "w_γ": "mean_content_old_weight", "w_1": "bias_weight" }, # "% carry": "carry_rates", is_show_name=True, max_src=17, max_out=13, max_tgt=13, **kwargs): check = Checkpoint.load(task_path) self.model = check.model # store some interesting variables self.model.set_dev_mode() self.predictor = Predictor(self.model, check.input_vocab, check.output_vocab) self.model_name = task_path.split("/")[-2] self.figsize = figsize self.decimals = decimals self.is_show_attn_split = is_show_attn_split self.is_show_evaluation = is_show_evaluation self.positional_table_labels = positional_table_labels self.is_show_name = is_show_name self.max_src = max_src self.max_out = max_out self.max_tgt = max_tgt self.output_length_key = output_length_key self.attention_key = attention_key self.position_attn_key = position_attn_key self.content_attn_key = content_attn_key if self.is_show_evaluation: self.is_symbol_rewriting = "symbol rewriting" in task_path.lower() self.metric_computer = MetricComputer( check, is_symbol_rewriting=self.is_symbol_rewriting, **kwargs) if self.model.decoder.is_attention is None: raise AttentionException("Model is not using attention.")