def __init__(self):
super().__init__()
self.parser = argparse.ArgumentParser()
self.set_args()
self.params = self.get_params()
util.maybe_mkdir(self.params.model)
self.logger = util.get_logger(self.params.model + '.log',
log_level=self.params.loglevel)
for key, value in vars(self.params).items():
self.logger.info('command line argument: %s - %r', key, value)
setup_seed(self.params.seed)
self.data = None
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
# ---------
self.logger.info('device: %s', self.device)
# ---------
self.model = None
self.optimizer = None
self.min_lr = 0
self.scheduler = None
self.evaluator = None
self.global_steps = 0
self.last_devloss = float('inf')
self.models: List[Evaluation] = list()
def run(self):
args = self.args
self.setup_processor(args.lang)
self.setup_model()
self.setup_evaluator()
if args.do_train:
try:
self.do_train()
self.final_eval()
except Exception as e:
self.logger.error(traceback.format_exc())
if args.do_eval and not args.do_train and args.local_rank in [-1, 0]:
self.load_model(args.load)
modes = []
if not args.no_eval_dev:
modes.append(Mode.dev)
if not args.no_eval_test:
modes.append(Mode.test)
for trg_lang in tqdm(args.trg_lang, desc="Eval Lang"):
self.setup_processor(trg_lang)
write_file = f'{args.output_dir}/eval/{args.lang}-{trg_lang}/eval_results.txt'
maybe_mkdir(write_file)
for mode in modes:
eval_loss, metrics = self.do_eval(mode)
self.write_eval(write_file, mode, eval_loss, metrics)
def main():
opt = get_args()
decode_fn = setup_inference(opt)
device = get_device()
model = torch.load(open(opt.model, mode='rb'), map_location=device)
model = model.to(device)
trg_i2c = {i: c for c, i in model.trg_c2i.items()}
decode_trg = lambda seq: [trg_i2c[i] for i in seq]
maybe_mkdir(opt.out_file)
with open(opt.in_file, 'r', encoding='utf-8') as in_fp, \
open(opt.out_file, 'w', encoding='utf-8') as out_fp:
for line in in_fp.readlines():
toks = line.strip().split('\t')
if len(toks) < 2 or line[0] == '#': # pass through
out_fp.write(line)
continue
# word, lemma, tags = toks[1], toks[2], toks[5]
word, tags = toks[1], toks[5]
word, tags = list(word), tags.split(';')
src = encode(model, word, tags, device)
pred, _ = decode_fn(model, src)
pred_out = ''.join(decode_trg(pred))
# write lemma
toks[2] = pred_out
out_fp.write('\t'.join(toks) + '\n')
def main():
opt = get_args()
decode_fn = Decoder(opt.decode, max_len=opt.max_len, beam_size=opt.beam_size)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.load(open(opt.model, mode="rb"), map_location=device)
model = model.to(device)
trg_i2c = {i: c for c, i in model.trg_c2i.items()}
def decode_trg(seq):
return [trg_i2c[i] for i in seq]
maybe_mkdir(opt.out_file)
with open(opt.in_file, "r", encoding="utf-8") as in_fp, open(
opt.out_file, "w", encoding="utf-8"
) as out_fp:
for line in in_fp.readlines():
toks = line.strip().split("\t")
if len(toks) < 2 or line[0] == "#": # pass through
out_fp.write(line)
continue
# word, lemma, tags = toks[1], toks[2], toks[5]
word, tags = toks[1], toks[5]
word, tags = list(word), tags.split(";")
src = encode(model, word, tags, device)
src_mask = dummy_mask(src)
pred, _ = decode_fn(model, src, src_mask)
pred = unpack_batch(pred)[0]
pred_out = "".join(decode_trg(pred))
# write lemma
toks[2] = pred_out
out_fp.write("\t".join(toks) + "\n")
def dump_state_dict(self, filepath):
util.maybe_mkdir(filepath)
self.model = self.model.to('cpu')
torch.save(self.model.state_dict(), filepath)
self.model = self.model.to(self.device)
# fix alexander kahanek
# self.logger.info(f'dump to {filepath}')
self.logger.info('dump to %s', filepath)
def main(args=None):
'''
main
'''
opt = get_args(args=args)
util.maybe_mkdir(opt.model)
logger = util.get_logger(opt.model + '.log', log_level=opt.loglevel)
for key, value in vars(opt).items():
logger.info('command line argument: %s - %r', key, value)
random.seed(opt.seed)
np.random.seed(opt.seed)
torch.manual_seed(opt.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(opt.seed)
trainer = Trainer(logger)
trainer.load_data(opt.dataset,
opt.train,
opt.dev,
test=opt.test,
shuffle=opt.shuffle)
trainer.setup_evalutator()
if opt.load and opt.load != '0':
if os.path.isfile(opt.load):
start_epoch = trainer.load_model(opt.load) + 1
elif opt.load == 'smart':
start_epoch = trainer.smart_load_model(opt.model) + 1
else:
raise ValueError
logger.info('continue training from epoch %d', start_epoch)
trainer.setup_training(opt.optimizer, opt.lr, opt.momentum)
trainer.setup_scheduler(opt.min_lr, opt.patience, opt.cooldown,
opt.discount_factor)
trainer.load_training(opt.model)
else:
start_epoch = 0
trainer.build_model(opt)
trainer.setup_training(opt.optimizer, opt.lr, opt.momentum)
trainer.setup_scheduler(opt.min_lr, opt.patience, opt.cooldown,
opt.discount_factor)
for epoch_idx in range(start_epoch, start_epoch + opt.epochs):
trainer.train(epoch_idx, opt.bs, opt.max_norm)
with torch.no_grad():
devloss = trainer.calc_loss(DEV, opt.bs, epoch_idx)
eval_res = trainer.evaluate(DEV, epoch_idx)
if trainer.update_lr_and_stop_early(epoch_idx, devloss, opt.estop):
break
trainer.save_model(epoch_idx, devloss, eval_res, opt.model)
trainer.save_training(opt.model)
with torch.no_grad():
save_fps = trainer.reload_and_test(opt.model, opt.bs, opt.bestacc)
trainer.cleanup(opt.saveall, save_fps, opt.model)
def final_eval(self):
args = self.args
save_fp = f'{args.output_dir}/model.pth'
self.load_model(save_fp)
for trg_lang in tqdm(args.trg_lang, desc="Eval Lang"):
self.setup_processor(trg_lang)
write_file = f'{args.output_dir}/eval/{args.lang}-{trg_lang}/eval_results.txt'
maybe_mkdir(write_file)
eval_loss, metrics = self.do_eval(Mode.test)
self.write_eval(write_file, Mode.test, eval_loss, metrics)
def main():
'''
main
'''
print(os.getcwd())
opt = get_args()
util.maybe_mkdir(opt.model)
logger = util.get_logger(opt.model + '.log', log_level=opt.loglevel)
for key, value in vars(opt).items():
logger.info('command line argument: %s - %r', key, value)
random.seed(opt.seed)
np.random.seed(opt.seed)
torch.manual_seed(opt.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(opt.seed)
trainer = Trainer(logger)
trainer.load_data(opt.dataset, opt.train, opt.dev, test=opt.test)
if opt.load and opt.load != '0':
if os.path.isfile(opt.load):
start_epoch = trainer.load_model(opt.load) + 1
elif opt.load == 'smart':
start_epoch = trainer.smart_load_model(opt.model) + 1
else:
raise ValueError
logger.info('continue training from epoch %d', start_epoch)
trainer.setup_training(opt.optimizer, opt.lr, opt.min_lr, opt.momentum,
opt.cooldown)
trainer.load_training(opt.model)
else:
start_epoch = 0
trainer.build_model(opt)
trainer.setup_training(opt.optimizer, opt.lr, opt.min_lr, opt.momentum,
opt.cooldown)
for epoch_idx in range(start_epoch, start_epoch + opt.epochs):
trainer.train(epoch_idx, opt.bs, opt.max_norm)
with torch.no_grad():
devloss = trainer.calc_loss(DEV, opt.bs, epoch_idx)
eval_res = trainer.evaluate(DEV, epoch_idx)
if trainer.update_lr_and_stop_early(epoch_idx, devloss, opt.estop):
break
trainer.save_model(epoch_idx, devloss, eval_res, opt.model)
trainer.save_training(opt.model)
save_fps = trainer.reload_and_test(opt.model, opt.bs, opt.bestacc)
trainer.cleanup(opt.saveall, save_fps, opt.model)
def main():
opt = get_args()
decode_fn = setup_inference(opt)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.load(open(opt.model, mode='rb'), map_location=device)
model = model.to(device)
trg_i2c = {i: c for c, i in model.trg_c2i.items()}
decode_trg = lambda seq: [trg_i2c[i] for i in seq]
maybe_mkdir(opt.out_file)
with open(opt.out_file, 'w', encoding='utf-8') as fp:
for lemma, tags in read_file(opt.in_file, opt.lang):
src = encode(model, lemma, tags, device)
pred, _ = decode_fn(model, src)
pred_out = ''.join(decode_trg(pred))
fp.write(f'{"".join(lemma)}\t{pred_out}\t{";".join(tags[1:])}\n')
def main():
opt = get_args()
decode_fn = setup_inference(opt)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.load(open(opt.model, mode='rb'), map_location=device)
model = model.to(device)
trg_i2c = {i: c for c, i in model.trg_c2i.items()}
decode_trg = lambda seq: [trg_i2c[i] for i in seq]
maybe_mkdir(opt.out_file)
with open(opt.out_file, 'w', encoding='utf-8') as fp:
for lemma, tags in read_file(opt.in_file, opt.lang):
src = encode(model, lemma, tags, device)
pred, _ = decode_fn(model, src)
pred_out = ''.join(decode_trg(pred))
fp.write(f'{"".join(lemma)}\t{pred_out}\t{";".join(tags[1:])}\n')
def final_eval(self):
args = self.args
task_name = args.task_name.lower()
save_fp = f'{args.output_dir}/model.pth'
self.load_model(save_fp)
if task_name == 'xnli' or 'mldoc' in task_name or 'tobacco' in task_name:
for trg_lang in tqdm(args.trg_lang, desc="Eval Lang"):
self.setup_processor(trg_lang)
write_file = f'{args.output_dir}/eval/{args.lang}-{trg_lang}/eval_results.txt'
maybe_mkdir(write_file)
eval_loss, metrics = self.do_eval(Mode.test)
self.write_eval(write_file, Mode.test, eval_loss, metrics)
else:
for mode in [Mode.dev, Mode.test]:
write_file = f'{args.output_dir}/eval_results.txt'
maybe_mkdir(write_file)
eval_loss, metrics = self.do_eval(mode)
self.write_eval(write_file, mode, eval_loss, metrics)
def main():
opt = get_args()
decode_fn = Decoder(opt.decode, max_len=opt.max_len, beam_size=opt.beam_size)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.load(open(opt.model, mode="rb"), map_location=device)
model = model.to(device)
trg_i2c = {i: c for c, i in model.trg_c2i.items()}
def decode_trg(seq):
return [trg_i2c[i] for i in seq]
maybe_mkdir(opt.out_file)
with open(opt.out_file, "w", encoding="utf-8") as fp:
for lemma, tags in read_file(opt.in_file, opt.lang):
src = encode(model, lemma, tags, device)
src_mask = dummy_mask(src)
pred, _ = decode_fn(model, src, src_mask)
pred = unpack_batch(pred)[0]
pred_out = "".join(decode_trg(pred))
fp.write(f'{"".join(lemma)}\t{pred_out}\t{";".join(tags[1:])}\n')
def dump_state_dict(self, filepath):
util.maybe_mkdir(filepath)
self.model = self.model.to("cpu")
torch.save(self.model.state_dict(), filepath)
self.model = self.model.to(self.device)
self.logger.info(f"dump to {filepath}")
