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: