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.")
