def __init__(self): self.guessed_letters = [] self.vocab = Vocab() self.model = self.load_model('model_v3/real_model.checkpoint')
def init_process(local_rank, backend, config): os.environ['MASTER_ADDR'] = '127.0.0.1' os.environ['MASTER_PORT'] = '29500' dist.init_process_group(backend, rank=local_rank, world_size=config.num_gpus) torch.cuda.set_device(local_rank) torch.backends.cudnn.benchmark = True logger = logging.getLogger("DST") logger.setLevel(logging.INFO) stream_handler = logging.StreamHandler() logger.addHandler(stream_handler) if local_rank != 0: logger.setLevel(logging.WARNING) if local_rank == 0: writer = SummaryWriter() if not os.path.exists("save"): os.mkdir("save") save_path = "save/model_{}.pt".format( re.sub("\s+", "_", time.asctime())) random.seed(config.seed) vocab = Vocab(config) vocab.load("save/vocab") db = DB(config.data_path) reader = Reader(vocab, config) start = time.time() logger.info("Loading data...") reader.load_data("train") end = time.time() logger.info("Loaded. {} secs".format(end - start)) evaluator = MultiWOZEvaluator(reader, db, config) lr = config.lr model = DIALOG(vocab, db, config).cuda() optimizer = Adam(model.parameters(), lr=lr) model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[local_rank], output_device=local_rank) # load saved model, optimizer if config.save_path is not None: load(model, optimizer, config.save_path) train.max_iter = len(list(reader.make_batch(reader.train))) validate.max_iter = len(list(reader.make_batch(reader.dev))) train.warmup_steps = train.max_iter * config.max_epochs * config.warmup_steps train.global_step = 0 max_joint_acc = 0 early_stop_count = config.early_stop_count loss, joint_acc, slot_acc = validate(model, reader, evaluator, config, local_rank) logger.info( "loss: {:.4f}, joint accuracy: {:.4f}, slot accuracy: {:.4f}".format( loss, joint_acc, slot_acc)) # loss, joint_acc, slot_acc, perplexity, inform_rate, success_rate, inform_test, success_test = validate(model, reader, evaluator, config, local_rank) # logger.info("loss: {:.4f}, joint accuracy: {:.4f}, slot accuracy: {:.4f}, perplexity: {:.4f}, inform rate: {:.4f}, success rate: {:.4f}, inform test: {:.4f}, success test: {:.4f}"\ # .format(loss, joint_acc, slot_acc, perplexity, inform_rate, success_rate, inform_test, success_test)) for epoch in range(config.max_epochs): logger.info("Train...") start = time.time() if local_rank == 0: train(model, reader, optimizer, writer, config, local_rank, evaluator) else: train(model, reader, optimizer, None, config, local_rank, evaluator) end = time.time() logger.info("epoch: {}, {:.4f} secs".format(epoch + 1, end - start)) logger.info("Validate...") loss, joint_acc, slot_acc = validate(model, reader, evaluator, config, local_rank) logger.info( "loss: {:.4f}, joint accuracy: {:.4f}, slot accuracy: {:.4f}". format(loss, joint_acc, slot_acc)) # logger.info("loss: {:.4f}, joint accuracy: {:.4f}, slot accuracy: {:.4f}, perplexity: {:.4f}, inform rate: {:.4f}, success rate: {:.4f}, inform test: {:.4f}, success test: {:.4f}"\ # .format(loss, joint_acc, slot_acc, perplexity, inform_rate, success_rate, inform_test, success_test)) if local_rank == 0: writer.add_scalar("Val/loss", loss, epoch + 1) writer.add_scalar("Val/joint_acc", joint_acc, epoch + 1) writer.add_scalar("Val/slot_acc", slot_acc, epoch + 1) if joint_acc > max_joint_acc: # save model if local_rank == 0: save(model, optimizer, save_path) logger.info("Saved to {}.".format(os.path.abspath(save_path))) max_joint_acc = joint_acc early_stop_count = config.early_stop_count else: # ealry stopping if early_stop_count == 0: logger.info("Early stopped.") break elif early_stop_count == 2: lr = lr / 2 logger.info("learning rate schedule: {}".format(lr)) for param in optimizer.param_groups: param["lr"] = lr early_stop_count -= 1 logger.info("early stop count: {}".format(early_stop_count)) logger.info("Training finished.")
inform_rate_ = inform_rate.float().mean(dim=1).sum(dim=0) inform_rate = (inform_rate.float().mean(dim=1) == 1) inform_rate = inform_rate.sum(dim=0).float() success_rate = (true_request_goals <= pred_request_goals ) # like recall (not precision) success_rate_ = success_rate.float().mean(dim=1).sum(dim=0) success_rate = (success_rate.float().mean(dim=1) == 1 ) # check all slots success_rate = success_rate.sum(dim=0).float() return inform_rate, success_rate, inform_rate_, success_rate_ if __name__ == "__main__": config = Config() parser = config.parser config = parser.parse_args() vocab = Vocab(config) vocab.load("save/vocab") reader = Reader(vocab, config) evaluator = MultiWOZEvaluator(reader, db, config) dial_id = evaluator.test_list[0] goal = evaluator.parse_goal(dial_id) print("")
def main(_): vocab = Vocab() vocab.load_from_pickle() reader = Reader(vocab) config_proto = tf.ConfigProto() config_proto.gpu_options.allow_growth = True with tf.Graph().as_default(), tf.Session(config=config_proto) as session: with tf.variable_scope("Model") as scope: if cfg.training: with tf.variable_scope("LR"): g_lr = tf.get_variable("g_lr", shape=[], initializer=tf.zeros_initializer, trainable=False) d_lr = tf.get_variable("d_lr", shape=[], initializer=tf.zeros_initializer, trainable=False) g_optimizer = utils.get_optimizer(g_lr, cfg.g_optimizer) d_optimizer = utils.get_optimizer(d_lr, cfg.d_optimizer) model = EncoderDecoderModel(vocab, True, use_gan=cfg.use_gan, g_optimizer=g_optimizer, d_optimizer=d_optimizer) scope.reuse_variables() eval_model = EncoderDecoderModel(vocab, False, use_gan=cfg.use_gan) else: test_model = EncoderDecoderModel(vocab, False, use_gan=cfg.use_gan) scope.reuse_variables() generator = EncoderDecoderModel(vocab, False, use_gan=cfg.use_gan, generator=True) decode_op = beam_decode_op(generator, vocab, cfg.beam_size) saver = tf.train.Saver() try: # try to restore a saved model file saver.restore(session, cfg.load_file) print("Model restored from", cfg.load_file) except ValueError: if cfg.training: tf.initialize_all_variables().run() print("No loadable model file, new model initialized.") else: print("You need to provide a valid model file for testing!") sys.exit(1) if cfg.training: steps = 0 train_perps = [] valid_perps = [] session.run(tf.assign(g_lr, cfg.g_learning_rate)) session.run(tf.assign(d_lr, cfg.d_learning_rate)) if cfg.sc_use_kld_weight: min_kld_weight = cfg.anneal_max - 1e-4 else: min_kld_weight = -1 scheduler = utils.Scheduler(cfg.min_d_acc, cfg.max_d_acc, cfg.max_perplexity, min_kld_weight, cfg.sc_list_size, cfg.sc_decay) for i in range(cfg.max_epoch): print("\nEpoch: %d" % (i + 1)) perplexity, steps = run_epoch(i, session, model, generator, reader.training(), vocab, saver, steps, cfg.max_steps, scheduler, cfg.use_gan, cfg.gen_every, decode_op) print("Epoch: %d Train Perplexity: %.3f" % (i + 1, perplexity)) train_perps.append(perplexity) if cfg.validate_every > 0 and (i + 1) % cfg.validate_every == 0: perplexity, _ = run_epoch(i, session, eval_model, generator, reader.validation(), vocab, None, 0, -1, None, cfg.use_gan, -1, decode_op) print("Epoch: %d Validation Perplexity: %.3f" % (i + 1, perplexity)) valid_perps.append(perplexity) else: valid_perps.append(None) print('Train:', train_perps) print('Valid:', valid_perps) if steps >= cfg.max_steps: break else: print('\nTesting') perplexity, _ = run_epoch(0, session, test_model, generator, reader.testing(), vocab, None, 0, cfg.max_steps, None, cfg.use_gan, -1, decode_op) print("Test Perplexity: %.3f" % perplexity)
from config import Config from reader import Vocab import ontology if __name__ == "__main__": config = Config() parser = config.parser config = parser.parse_args() logger = logging.getLogger() logger.setLevel(logging.INFO) stream_handler = logging.StreamHandler() logger.addHandler(stream_handler) vocab = Vocab(config) data_path = "data/MultiWOZ_2.1" data = {} if not os.path.exists("save"): os.mkdir("save") if not os.path.exists("save/vocab"): os.mkdir("save/vocab") save_path = "save/vocab" logger.info("Making vocabulary...") # ontology for domain in ontology.all_domains: vocab.add("[" + domain + "]", word=True) for slot in ontology.all_info_slots + ontology.all_req_slots: