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