def train(args):
args, model, iters, vocab, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {}".format(args.ckpt_name))
loss_fn = get_loss(args, vocab)
optimizer = get_optimizer(args, model)
trainer = get_trainer(args, model, loss_fn, optimizer)
metrics = get_metrics(args, vocab)
evaluator = get_evaluator(args, model, loss_fn, metrics)
logger = get_logger(args)
@trainer.on(Events.STARTED)
def on_training_started(engine):
print("Begin Training")
@trainer.on(Events.ITERATION_COMPLETED)
def log_iter_results(engine):
log_results(logger, 'train/iter', engine.state, engine.state.iteration)
@trainer.on(Events.EPOCH_COMPLETED)
def evaluate_epoch(engine):
log_results(logger, 'train/epoch', engine.state, engine.state.epoch)
state = evaluate_once(evaluator, iterator=iters['val'])
log_results(logger, 'valid/epoch', state, engine.state.epoch)
save_ckpt(args, engine.state.epoch, engine.state.metrics['loss'], model, vocab)
trainer.run(iters['train'], max_epochs=args.max_epochs)
def load_model(self, **kwargs):
args = self._default_args(**kwargs)
args.question = "init"
args.vid = "init"
args.ckpt_name = "vqa_model.pickle"
args, model, iters, vocab, ckpt_available = get_model_ckpt(args)
return [args, model, iters, vocab, ckpt_available]
def train(args):
args, model, iters, vocab, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {}".format(args.ckpt_name))
loss_fn = get_loss(args, vocab)
optimizer = get_optimizer(args, model)
pretrainer = get_pretrainer(args, model, loss_fn, optimizer)
trainer = get_trainer(args, model, loss_fn, optimizer)
metrics = get_metrics(args, vocab)
evaluator = get_evaluator(args, model, loss_fn, metrics)
logger = get_logger(args)
@pretrainer.on(Events.STARTED)
def on_training_started(engine):
print("Begin Pretraining")
@pretrainer.on(Events.ITERATION_COMPLETED)
def log_iter_results(engine):
log_results(logger, 'pretrain/iter', engine.state, engine.state.iteration)
@pretrainer.on(Events.EPOCH_COMPLETED)
def evaluate_epoch(engine):
log_results(logger, 'pretrain/epoch', engine.state, engine.state.epoch)
"""
@pretrainer.on(Events.COMPLETED)
def unfreeze_language_model(engine):
for param in model.module.language_model.base_model.parameters():
param.requires_grad = True
"""
@trainer.on(Events.STARTED)
def on_training_started(engine):
print("Begin Training")
@trainer.on(Events.ITERATION_COMPLETED)
def log_iter_results(engine):
log_results(logger, 'train/iter', engine.state, engine.state.iteration)
@trainer.on(Events.EPOCH_COMPLETED)
def evaluate_epoch(engine):
log_results(logger, 'train/epoch', engine.state, engine.state.epoch)
state = evaluate_once(evaluator, iterator=iters['val'])
log_results(logger, 'valid/epoch', state, engine.state.epoch)
log_results_cmd('valid/epoch', state, engine.state.epoch)
save_ckpt(args, engine.state.epoch, engine.state.metrics['loss'], model, vocab)
evaluate_by_logic_level(args, model, iterator=iters['val'])
if args.pretrain_epochs > 0:
pretrainer.run(iters['pretrain'], max_epochs=args.pretrain_epochs)
trainer.run(iters['train'], max_epochs=args.max_epochs)
def evaluate(args):
args, model, iters, vocab, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {}".format(args.ckpt_name))
loss_fn = get_loss(args, vocab)
metrics = get_metrics(args, vocab)
evaluator = get_evaluator(args, model, loss_fn, metrics)
state = evaluate_once(evaluator, iterator=iters['val'])
log_results_cmd('valid/epoch', state, 0)
def interactive(args):
args, model, iters, vocab, ckpt_available = get_model_ckpt(args)
vid = args.get('vid', 's02e09_04_153')
question = args.get('question', 'What does Monica place on the tablo?')
batch = get_interactive_batch(args, vid, question, iters)
with torch.no_grad():
net_inputs, target = prepare_batch(args, batch, model.vocab)
y_pred = model(**net_inputs)
top_1 = y_pred.argmax(dim=-1).item()
top_0_ans = net_inputs['answers'].squeeze(0)[top_1]
ans = to_sent(vocab, top_0_ans)
return ans
def infer(args):
args, model, iters, vocab, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {}".format(args.ckpt_name))
loss_fn = get_loss(args, vocab)
evaluator = get_evaluator(args, model, loss_fn)
answers = evaluate_once(evaluator, iterator=iters['test'])
keys = sorted(list(answers.keys()))
answers = [{"correct_idx": answers[key], "qid": key} for key in keys]
path = str(args.data_path.parent / 'answers.json')
with open(path, 'w') as f:
json.dump(answers, f, indent=4)
print("saved outcome at {}".format(path))
def train(args):
args, model, iters, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {}".format(args.ckpt_name))
loss_fn = get_loss(args)
optimizer = get_optimizer(args, model)
trainer = get_trainer(args, model, loss_fn, optimizer)
metrics = get_metrics(args)
evaluator = get_evaluator(args, model, loss_fn, metrics)
logger = get_logger(args)
trainer.run(iters['train']), max_epochs=args.max_epochs)
def pretrain(args):
tf = get_transform(args, 'none')
ds = get_dataset(args, tf, 'none')
args, model, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {} in pretraining stage".format(args.ckpt_name))
loss_fn = get_loss(args)
sub_optimizer = get_sub_optimizer(args, model)
optimizer = get_optimizer(args, sub_optimizer)
scheduler = get_scheduler(args, optimizer)
# setup nvidia/apex amp
# model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level, num_losses=1)
# model = idist.auto_model(model)
trainer = get_trainer(args, model, loss_fn, optimizer, scheduler)
def pretrain(args):
tf = get_transform(args, 'none')
ds = get_dataset(args, tf, 'none')
args, model, ckpt_available = get_model_ckpt(args)
if ckpt_available:
print("loaded checkpoint {} in pretraining stage".format(
args.ckpt_name))
loss_fn = get_loss(args)
sub_optimizer = get_sub_optimizer(args, model)
optimizer = get_optimizer(args, sub_optimizer)
scheduler = get_scheduler(args, optimizer)
# setup nvidia/apex amp
# model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level, num_losses=1)
# model = idist.auto_model(model)
trainer = get_trainer(args, model, loss_fn, optimizer, scheduler)
metrics = get_metrics(args)
logger = get_logger(args)
@trainer.on(Events.STARTED)
def on_training_started(engine):
print("Begin Pretraining")
# batch-wise
@trainer.on(Events.ITERATION_COMPLETED)
def log_iter_results(engine):
log_results(logger, 'pretrain/iter', engine.state,
engine.state.iteration)
# epoch-wise (ckpt)
@trainer.on(Events.EPOCH_COMPLETED)
def save_epoch(engine):
log_results(logger, 'pretrain/epoch', engine.state, engine.state.epoch)
log_results_cmd(logger, 'pretrain/epoch', engine.state,
engine.state.epoch)
save_ckpt(args, engine.state.epoch, engine.state.metrics['loss'],
model)
trainer.run(ds, max_epochs=args.epoch)
def eval_linear(pretrain_args, args):
# get pretrained model
pt_args, pt_model, ckpt_available = get_model_ckpt(pretrain_args)
tf = get_transform(args, 'train')
ds = get_dataset(args, tf, 'train')
if ckpt_available:
print("loaded pretrained model {} in eval linear".format(args.ckpt_name))
model = get_linear(args, pt_model, args.num_classes)
loss_fn = get_loss(args)
optimizer = get_sub_optimizer(args, model)
scheduler = get_scheduler(args, optimizer)
trainer = get_trainer(args, model, loss_fn, optimizer, scheduler)
evaluator = get_evaluator(args, model, loss_fn)
# metrics = get_metrics(args)
logger = get_logger(args)
trainer.run(ds, max_epochs=args.epoch)
