# Load dictionary
tokenizer_description = None
if config["inputs"]["description"]:
logger.info('Loading dictionary Description......')
tokenizer_description = GWTokenizer(os.path.join(args.data_dir,args.dict_file_description),question=False)
# Build Network
logger.info('Building network..')
if tokenizer_description != None:
network = OracleNetwork(config, num_words_question=tokenizer.no_words,num_words_description=tokenizer_description.no_words)
else:
network = OracleNetwork(config, num_words_question=tokenizer.no_words,num_words_description=None)
# Build Optimizer
logger.info('Building optimizer..')
optimizer, outputs = create_optimizer(network, config, finetune=finetune)
best_param = network.get_predict()
##############################
# START TRAINING
#############################
logger.info("Start training .......")
# create a saver to store/load checkpoint
saver = tf.train.Saver()
resnet_saver = None
logger.info("saver done !")
cpu_pool = Pool(args.no_thread, maxtasksperchild=5000)
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_ratio)
logger.info('Loading data..')
trainset = Dataset(args.data_dir, "train", image_builder, crop_builder)
validset = Dataset(args.data_dir, "valid", image_builder, crop_builder)
testset = Dataset(args.data_dir, "test", image_builder, crop_builder)
# Load dictionary
logger.info('Loading dictionary..')
tokenizer = GWTokenizer(os.path.join(args.data_dir, args.dict_file))
# Build Network
logger.info('Building network..')
network = GuesserNetwork(config['model'], num_words=tokenizer.no_words)
# Build Optimizer
logger.info('Building optimizer..')
optimizer, outputs = create_optimizer(network, config["optimizer"])
###############################
# START TRAINING
#############################
# Load config
batch_size = config['model']['batch_size']
no_epoch = config["optimizer"]["no_epoch"]
# create a saver to store/load checkpoint
saver = tf.train.Saver()
# Retrieve only resnet variabes
if use_resnet:
resnet_saver = create_resnet_saver([network])
guesser_var = [v for v in tf.global_variables() if "guesser" in v.name]
guesser_saver = tf.train.Saver(var_list=guesser_var)
loop_saver = tf.train.Saver(allow_empty=False)
###############################
# REINFORCE OPTIMIZER
#############################
logger.info('Building optimizer..')
pg_variables = [v for v in tf.trainable_variables() if "qgen" in v.name and 'rl_baseline' not in v.name]
baseline_variables = [v for v in tf.trainable_variables() if "qgen" in v.name and 'rl_baseline' in v.name]
pg_optimize, _ = create_optimizer(qgen_network, qgen_network.policy_gradient_loss, loop_config,
var_list=pg_variables,
optim=tf.train.GradientDescentOptimizer)
baseline_optimize, _= create_optimizer(qgen_network, qgen_network.baseline_loss, loop_config,
var_list=baseline_variables,
optim=tf.train.GradientDescentOptimizer,
apply_update_ops=False)
optimizer = [pg_optimize, baseline_optimize]
###############################
# START TRAINING
#############################
# Load config
batch_size = loop_config['optimizer']['batch_size']
no_epoch = loop_config["optimizer"]["no_epoch"]
validset = Dataset(args.data_dir, "valid", image_loader, crop_loader)
testset = Dataset(args.data_dir, "test", image_loader, crop_loader)
# Load dictionary
logger.info('Loading dictionary..')
tokenizer = GWTokenizer(os.path.join(args.data_dir, args.dict_file))
# Build Network
logger.info('Building network..')
network = QGenNetworkLSTM(config["model"],
num_words=tokenizer.no_words,
policy_gradient=False)
# Build Optimizer
logger.info('Building optimizer..')
optimizer, outputs = create_optimizer(network, network.ml_loss, config)
###############################
# START TRAINING
#############################
# Load config
batch_size = config['optimizer']['batch_size']
no_epoch = config["optimizer"]["no_epoch"]
# create a saver to store/load checkpoint
saver = tf.train.Saver()
# CPU/GPU option
cpu_pool = Pool(args.no_thread, maxtasksperchild=1000)
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_ratio)
rcnn, args.no_games_to_load)
testset = Dataset(args.data_dir, "test", image_builder, crop_builder, rcnn,
args.no_games_to_load)
# Load dictionary
logger.info('Loading dictionary..')
tokenizer = GWTokenizer(args.dict_file)
# Build Network
logger.info('Building network..')
network, batchifier_cstor = create_qgen(config["model"],
num_words=tokenizer.no_words)
# Build Optimizer
logger.info('Building optimizer..')
optimizer, outputs = create_optimizer(
network, config["optimizer"]) # output:[loss, accuracy]
###############################
# START TRAINING
#############################
# create a saver to store/load checkpoint
saver = tf.train.Saver()
# CPU/GPU option
config_gpu = tf.ConfigProto()
config_gpu.gpu_options.allow_growth = True
with tf.Session(config=config_gpu) as sess:
sources = network.get_sources(sess)
oracle_var = [v for v in tf.global_variables() if "oracle" in v.name]
oracle_saver = tf.train.Saver(var_list=oracle_var)
guesser_network, guesser_batchifier_cstor, guesser_listener = create_guesser(guesser_config["model"], num_words=tokenizer.no_words)
guesser_var = [v for v in tf.global_variables() if "guesser" in v.name]
guesser_saver = tf.train.Saver(var_list=guesser_var)
loop_saver = tf.train.Saver(allow_empty=False)
###############################
# REINFORCE OPTIMIZER
#############################
logger.info('Building optimizer..')
optimizer, _ = create_optimizer(qgen_network, loop_config["optimizer"],
optim_cst=eval("tf.train." + loop_config["optimizer"]["name"]),
accumulate_gradient=qgen_network.is_seq2seq())
###############################
# START TRAINING
#############################
# Load config
batch_size = loop_config['optimizer']['batch_size']
no_epoch = loop_config["optimizer"]["no_epoch"]
# mode_to_evaluate = ["sampling", "beam"]
mode_to_evaluate = ["greedy"]
if args.evaluate_all:
mode_to_evaluate = ["greedy", "sampling", "beam"]
which_set="test",
dataset=args.dataset,
split_by=args.split_by,
image_builder=image_builder,
crop_builder=crop_builder,
games_to_load=args.no_games_to_load)
# Build Network
logger.info('Building network..')
network = create_network(config=config["model"],
no_words=tokenizer.no_words)
# Build Optimizer
logger.info('Building optimizer..')
optimize, outputs = create_optimizer(network,
config["optimizer"],
finetune=finetune)
###############################
# START TRAINING
#############################
# create a saver to store/load checkpoint
saver = tf.train.Saver()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_ratio)
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
# retrieve incoming sources
sources = network.get_sources(sess)
