from utils.evaluator import Evaluator
from utils.batch import get_minibatch
from utils.constants import PAD
from utils.word2vec import load_embeddings
from utils.hyperparam import hyperparam_path
from models.slu.make_model import construct_models as slu_model_constructor
from models.nlg.make_model import construct_models as nlg_model_constructor
from models.language_model import LanguageModel as lm_constructor
from models.reward import RewardModel
from models.dual_learning import DualLearning
from scripts.decode import slu_decode, nlg_decode
task = 'dual_learning'
##### Arguments parsing and preparations #####
opt = init_args(params=sys.argv[1:], task=task)
exp_path = hyperparam_path(opt, task=task)
logger = set_logger(exp_path, testing=opt.testing)
set_random_seed(opt.seed)
slu_device, nlg_device = set_torch_device(opt.deviceIds[0]), set_torch_device(
opt.deviceIds[1])
lm_device = nlg_device # slu may use bert model
logger.info("Initialization finished ...")
logger.info("Parameters: " + str(json.dumps(vars(opt))))
logger.info("Output path is: %s" % (exp_path))
logger.info("Random seed is set to: %d" % (opt.seed))
logger.info("Use GPU with index %s as target slu device" % (opt.deviceIds[0])
if opt.deviceIds[0] >= 0 else "Use CPU as target slu torch device")
logger.info("Use GPU with index %s as target nlg device" % (opt.deviceIds[1])
if opt.deviceIds[1] >= 0 else "Use CPU as target nlg torch device")
#coding=utf8
import sys, os, time, json, gc
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from argparse import Namespace
from utils.args import init_args
from utils.hyperparams import hyperparam_path
from utils.initialization import *
from utils.example import Example
from utils.batch import Batch
from utils.optimization import set_optimizer
from model.model_utils import Registrable
from model.model_constructor import *
# initialization params, output path, logger, random seed and torch.device
args = init_args(sys.argv[1:])
exp_path = hyperparam_path(args)
logger = set_logger(exp_path, args.testing)
set_random_seed(args.seed)
device = set_torch_device(args.device)
logger.info("Initialization finished ...")
logger.info("Output path is %s" % (exp_path))
logger.info("Random seed is set to %d" % (args.seed))
logger.info("Use GPU with index %s" % (args.device) if args.device >= 0 else "Use CPU as target torch device")
# load dataset and vocabulary
start_time = time.time()
if args.read_model_path:
params = json.load(open(os.path.join(args.read_model_path, 'params.json')), object_hook=lambda d: Namespace(**d))
params.lazy_load = True
else:
params = args