def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
with tf.Session() as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def main(argv):
flags = tf.app.flags
FLAGS = flags.FLAGS
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
# Cluster One setting
clusterone_dist_env = distributed_env(config.root_path_to_local_data,
config.path_to_local_logs,
config.cloud_path_to_data,
config.local_repo,
config.cloud_user_repo, flags)
clusterone_dist_env.get_env()
tf.reset_default_graph()
device, target = clusterone_dist_env.device_and_target(
) # getting node environment
# end of setting
# Using tensorflow's MonitoredTrainingSession to take care of checkpoints
with tf.train.MonitoredTrainingSession(
master=target,
is_chief=(FLAGS.task_index == 0),
checkpoint_dir=FLAGS.log_dir) as sess:
# with tf.Session() as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
with tf.device(device): # define model
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
config.batch_size = 1
coco, data, vocabulary = prepare_eval_data(config)
with tf.device(device): # define model
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing phase
data, vocabulary = prepare_test_data(config)
with tf.device(device): # define model
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
config.trainable_variable = FLAGS.train_cnn
np.random.seed(config.seed)
tf.random.set_random_seed(config.seed)
model = SeqGAN(config) #initializes seqgan model
with tf.Session() as sess:
print("FLAG: " + FLAGS.phase)
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
model.train(sess, data)
elif FLAGS.phase == 'eval':
print("EVALUATING")
eval_data = prepare_eval_data(config)
model.load(sess, FLAGS.model_file)
model.eval(sess, eval_data)
elif FLAGS.phase == 'test_loaded_cnn': #test phase doesn't work yet
# testing only cnn
sess.run(tf.global_variables_initializer())
imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
probs = model.test_cnn(imgs)
model.load_cnn(sess, FLAGS.cnn_model_file)
img1 = imread(FLAGS.image_file, mode='RGB')
img1 = imresize(img1, (224, 224))
prob = sess.run(probs, feed_dict={imgs: [img1]})[0]
preds = (np.argsort(prob)[::-1])[0:5]
for p in preds:
print(class_names[p], prob[p])
else:
# testing phase
test_data = prepare_test_data(config)
model.load(sess, FLAGS.model_file)
#tf.get_default_graph().finalize()
model.test(sess, test_data)
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
with tf.compat.v1.Session() as sess:
if FLAGS.phase == 'train':
# training phase
config.train_image_dir = config.train_image_dir[:
-1] + "_" + FLAGS.namedir + "/"
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
config.eval_image_dir = config.eval_image_dir[:
-1] + "_" + FLAGS.namedir + "/"
config.eval_result_dir = config.eval_result_dir[:
-1] + "_" + FLAGS.namedir + "/"
config.eval_result_file = config.eval_result_file[:
-5] + "_" + FLAGS.namedir + config.eval_result_file[
-5:] # .json
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing phase
config.test_image_dir = config.test_image_dir[:
-1] + "_" + FLAGS.namedir + "/"
config.test_result_dir = config.test_result_dir[:
-1] + "_" + FLAGS.namedir + "/"
config.test_result_file = config.test_result_file[:
-4] + "_" + FLAGS.namedir + config.test_result_file[
-4:] # .csv
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.compat.v1.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
config.trainable_variable = FLAGS.train_cnn
with tf.Session() as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
#load the cnn file
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
elif FLAGS.phase == 'test_loaded_cnn':
# testing only cnn
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
probs = model.test_cnn(imgs)
model.load_cnn(sess, FLAGS.cnn_model_file)
img1 = imread(FLAGS.image_file, mode='RGB')
img1 = imresize(img1, (224, 224))
prob = sess.run(probs, feed_dict={imgs: [img1]})[0]
preds = (np.argsort(prob)[::-1])[0:5]
for p in preds:
print(class_names[p], prob[p])
else:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def main(argv):
os.system("ls /tinysrc")
os.system("python tinysrc/download_flickr8k.py")
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.joint_train = FLAGS.joint_train
config.beam_size = FLAGS.beam_size
config.attention_mechanism = FLAGS.attention
config.faster_rcnn_frozen = FLAGS.faster_rcnn_frozen
with tf.Session() as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_faster_rcnn_feature_extractor(
sess, FLAGS.faster_rcnn_ckpt)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
os.system("rm -rf /output/Flickr8k_Dataset/")
os.system("rm -rf /output/Flickr8k_text/")
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
with tf.Session() as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
else:
# testing phase
cap = cv2.VideoCapture(0)
#cap = cv2.VideoCapture('./video3.mp4')
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
i = 1
vocabulary = prepare_test_data(config)
while True:
ret, frame = cap.read()
if not ret:
break
if i == 1 or i % 4 == 0:
caption = model.test(sess, frame, vocabulary)
i += 1
word_and_img = np.concatenate((np.zeros(
(50, np.shape(frame)[1], 3), np.uint8), frame),
axis=0)
cv2.putText(word_and_img, caption, (15, 30),
cv2.FONT_HERSHEY_TRIPLEX, 0.5, (18, 87, 220), 1)
cv2.imshow('VideoShow', word_and_img)
cv2.waitKey(5)
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
config2 = tf.ConfigProto()
config2.gpu_options.allow_growth = True
with tf.Session(config=config2) as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
'''
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
checkpoint_dir = config.checkpoint_dir
save_checkpoint_secs = config.save_checkpoint_secs
save_checkpoint_steps = config.save_checkpoint_steps
global_step = tf.train.get_or_create_global_step()
checkpoint_step = tf.assign_add(global_step, 1)
model = CaptionGenerator(config)
# with tf.Session() as sess:
with tf.train.MonitoredTrainingSession(
checkpoint_dir=checkpoint_dir,
save_checkpoint_steps=save_checkpoint_steps,
) as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
# WIP modify load part
# if FLAGS.load:
# model.load(sess, FLAGS.model_file)
# if FLAGS.load_cnn:
# model.load_cnn(sess, FLAGS.cnn_model_file)
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing phase
data, vocabulary = prepare_test_data(config)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9)
with tf.Session(config=tf.ConfigProto(log_device_placement=False,
gpu_options=gpu_options)) as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def main(_):
config = Config()
config.mode = FLAGS.mode
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
# 设置按需分配GPU
with tf.Session(config=tf_config) as sess:
if FLAGS.mode == 'train':
# training mode
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.mode == 'eval':
# evaluation mode
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
# testing mode
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
def train(config):
"""Orchestrates the training process.
This method is responsible of executing all the steps required to train a new model,
which includes:
- Preparing the dataset
- Building the model
- Fitting the model to the data
Arguments:
config (util.Config): Values for various configuration options
"""
logging.info("cnn = %s", config.cnn)
logging.info("rnn = %s", config.rnn)
logging.info("embedding_dim = %s", config.embedding_dim)
logging.info("rnn_units = %s", config.rnn_units)
logging.info("num_features = %s", config.num_features)
logging.info("use_attention = %s", config.use_attention)
logging.info("weight_initialization = %s", config.weight_initialization)
logging.info("batch_size = %s", config.batch_size)
logging.info("optimizer = %s", config.optimizer)
logging.info("dropout = %s", config.dropout)
train_dataset, vocabulary = prepare_train_data(config)
model = build_model(config, vocabulary)
start = time.time()
losses = fit(model, train_dataset, config)
if len(losses) > 0:
logging.info('Total training time: %d seconds', time.time() - start)
logging.info('Final loss after %d epochs = %.6f', config.num_epochs,
losses[-1])
print('Final loss after %d epochs = %.6f' %
(config.num_epochs, losses[-1]))
# plot_loss(losses)
else:
print("No training done, since number of epochs was reached")
def main(argv):
start_time = time.time()
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
config.distributed = FLAGS.distributed
config.test_image_dir = os.path.join(FLAGS.node_root, 'images')
config.test_result_dir = os.path.join(FLAGS.node_root, 'results')
config.test_result_file = os.path.join(FLAGS.node_root, 'results.cvs')
config.replicas = len(FLAGS.worker_hosts.split(","))
if FLAGS.task_index == '':
config.task_index = 0
else:
config.task_index = int(FLAGS.task_index)
if FLAGS.phase == 'train':
# training phase
if FLAGS.distributed:
config.train_image_dir = FLAGS.input_path
ps_hosts = FLAGS.ps_hosts.split(",")
worker_hosts = FLAGS.worker_hosts.split(",")
# Create a cluster from the parameter server and worker hosts.
cluster = tf.train.ClusterSpec({
"ps": ps_hosts,
"worker": worker_hosts
})
# Create and start a server for the local task.
server = tf.train.Server(cluster,
job_name=FLAGS.job_name,
task_index=config.task_index)
#with tf.device(tf.train.replica_device_setter(cluster=cluster)):
# global_step = tf.Variable(0)
#with tf.device("/job:ps/task:0"):
# global_step = tf.Variable(0, name="global_step")
if FLAGS.job_name == "ps":
server.join()
elif FLAGS.job_name == "worker":
with tf.device(
tf.train.replica_device_setter(
worker_device="/job:worker/task:%d" %
config.task_index,
cluster=cluster)):
model = CaptionGenerator(config)
data = prepare_train_data(config)
init_op = tf.initialize_all_variables()
print "Variables Initialized ..."
begin = time.time()
#The StopAtStepHook handles stopping after running given steps.
hooks = [tf.train.StopAtStepHook(num_steps=1200000)]
# The MonitoredTrainingSession takes care of session initialization,
# restoring from a checkpoint, saving to a checkpoint, and closing when done
# or an error occurs.
with tf.train.MonitoredTrainingSession(
master=server.target,
is_chief=(config.task_index == 0),
checkpoint_dir=
"/home/mauro.emc/image_captioning/models",
hooks=hooks) as mon_sess:
if not os.path.exists(config.summary_dir):
os.mkdir(config.summary_dir)
train_writer = tf.summary.FileWriter(
config.summary_dir, mon_sess.graph)
print "Start the model training"
#while not mon_sess.should_stop():
model.train(mon_sess, data, train_writer,
config.task_index)
train_writer.close()
print "Model stopped train"
print("Train completed")
print("Total Time in secs: " + str(time.time() - begin))
else:
with tf.Session() as sess:
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
with tf.Session() as sess:
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
with tf.Session() as sess:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
print 'Total time in seconds : ' + str(time.time() - start_time)
def main(argv):
start_time = time.time()
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
config.distributed = FLAGS.distributed
config.test_image_dir = os.path.join(FLAGS.node_root, 'images')
config.test_result_dir = os.path.join(FLAGS.node_root, 'results')
config.test_result_file = os.path.join(FLAGS.node_root, 'results.cvs')
config.replicas = len(FLAGS.worker_hosts.split(","))
config.task_index = FLAGS.task_index
if FLAGS.phase == 'train':
# training phase
if FLAGS.distributed:
config.train_image_dir = FLAGS.input_path
print config.train_image_dir
ps_hosts = FLAGS.ps_hosts.split(",")
worker_hosts = FLAGS.worker_hosts.split(",")
# Create a cluster from the parameter server and worker hosts.
cluster = tf.train.ClusterSpec({
"ps": ps_hosts,
"worker": worker_hosts
})
# Create and start a server for the local task.
server = tf.train.Server(cluster,
job_name=FLAGS.job_name,
task_index=FLAGS.task_index)
if FLAGS.job_name == "ps":
server.join()
elif FLAGS.job_name == "worker":
with tf.device(
tf.train.replica_device_setter(
worker_device="/job:worker/task:%d" %
FLAGS.task_index,
cluster=cluster)):
tf.reset_default_graph()
global_step = tf.get_variable(
'global_step', [],
initializer=tf.constant_initializer(0),
trainable=False,
dtype=tf.int32)
data = prepare_train_data(config)
model = CaptionGenerator(config)
init_op = tf.initialize_all_variables()
is_chief = (FLAGS.task_index == 0)
# Create a "supervisor", which oversees the training process.
sv = tf.train.Supervisor(
is_chief=is_chief,
logdir="/home/mauro.emc/image_captioning/tmp/logs",
init_op=init_op,
global_step=global_step,
save_model_secs=600)
with sv.prepare_or_wait_for_session(server.target) as sess:
if is_chief:
sv.start_queue_runners(sess, [chief_queue_runner])
# Insert initial tokens to the queue.
sess.run(init_token_op)
sess.run(tf.global_variables_initializer())
model.train(sess, data)
sv.stop()
else:
with tf.Session() as sess:
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
with tf.Session() as sess:
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
else:
with tf.Session() as sess:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
print 'Total time in seconds : ' + str(time.time() - start_time)
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
with tf.Session() as sess:
if FLAGS.phase == 'train':
# training phase
data = prepare_train_data(config)
model = CaptionGenerator(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
if FLAGS.load_cnn:
model.load_cnn(sess, FLAGS.cnn_model_file)
tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
# evaluation phase
coco, data, vocabulary = prepare_eval_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval(sess, coco, data, vocabulary)
elif FLAGS.phase == 'test_new_data':
# evaluation phase
coco, data, vocabulary = prepare_eval_new_data(
config.eval_caption_file_unsplash, config.eval_image_unsplash,
config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval_new_data(sess, coco, data, vocabulary,
config.eval_result_dir_unsplash,
config.eval_result_file_unsplash)
elif FLAGS.phase == 'test_new_data_vizwiz':
# evaluation phase
coco, data, vocabulary = prepare_eval_new_data(
config.eval_caption_file_vizwiz_train,
config.eval_image_vizwiz_train, config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval_new_data(sess, coco, data, vocabulary,
config.eval_result_dir_vizwiz_train,
config.eval_result_file_vizwiz_train)
elif FLAGS.phase == 'test_new_data_insta':
# evaluation phase
coco, data, vocabulary = prepare_eval_new_data(
config.eval_caption_file_insta, config.eval_image_insta,
config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval_new_data(sess, coco, data, vocabulary,
config.eval_result_dir_insta,
config.eval_result_file_insta)
elif FLAGS.phase == 'test_new_data_google_top_n':
# evaluation phase
coco, data, vocabulary = prepare_eval_new_data(
config.eval_caption_file_topN, config.eval_image_topN, config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.eval_new_data(sess, coco, data, vocabulary,
config.eval_result_dir_topN,
config.eval_result_file_topN)
else:
# testing phase
data, vocabulary = prepare_test_data(config)
model = CaptionGenerator(config)
model.load(sess, FLAGS.model_file)
tf.get_default_graph().finalize()
model.test(sess, data, vocabulary)
import tensorflow as tf
import os
from config import Config
from model import CaptionGenerator
from dataset import prepare_train_data, prepare_eval_data, prepare_test_data
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1'
from dataset import prepare_train_data, prepare_eval_data, prepare_test_data
config = Config()
with tf.Session() as sess:
data = prepare_train_data(config)
print(data)
def init_real_training(self, data_loc=None):
#from utils.text_process import text_precess, text_to_code
#from utils.text_process import get_tokenlized, get_word_list, get_dict
from dataset import prepare_train_data
if data_loc is None:
data_loc = 'data/image_coco.txt'
#self.sequence_length, self.vocab_size, word_index_dict, index_word_dict = text_precess(data_loc, self.oracle_file)
dataset, self.sequence_length = prepare_train_data(
self.config, data_loc)
self.vocab_size = dataset.vocab_size()
word_index_dict, idnex_work_dict = dataset.get_dict()
goal_out_size = sum(self.num_filters)
discriminator = Discriminator(sequence_length=self.sequence_length,
num_classes=2,
vocab_size=self.vocab_size,
dis_emb_dim=self.dis_embedding_dim,
filter_sizes=self.filter_size,
num_filters=self.num_filters,
batch_size=self.batch_size,
hidden_dim=self.hidden_dim,
start_token=self.start_token,
goal_out_size=goal_out_size,
step_size=4,
l2_reg_lambda=self.l2_reg_lambda)
self.set_discriminator(discriminator)
generator = Generator(num_classes=2,
num_vocabulary=self.vocab_size,
batch_size=self.batch_size,
emb_dim=self.emb_dim,
dis_emb_dim=self.dis_embedding_dim,
goal_size=self.goal_size,
hidden_dim=self.hidden_dim,
sequence_length=self.sequence_length,
filter_sizes=self.filter_size,
start_token=self.start_token,
num_filters=self.num_filters,
goal_out_size=goal_out_size,
D_model=discriminator,
step_size=4)
self.set_generator(generator)
gen_dataloader = DataLoader(batch_size=self.batch_size,
seq_length=self.sequence_length,
dataset=dataset)
oracle_dataloader = None
dis_dataloader = DisDataloader(batch_size=self.batch_size,
seq_length=self.sequence_length,
dataset=dataset)
self.set_data_loader(gen_loader=gen_dataloader,
dis_loader=dis_dataloader,
oracle_loader=oracle_dataloader)
"""
tokens = get_tokenlized(data_loc)
word_set = get_word_list(tokens)
[word_index_dict, index_word_dict] = get_dict(word_set)
with open(self.oracle_file, 'w') as outfile:
outfile.write(text_to_code(tokens, word_index_dict, self.sequence_length))
"""
return word_index_dict, index_word_dict
def main(argv):
config = Config()
config.phase = FLAGS.phase
config.train_cnn = FLAGS.train_cnn
config.beam_size = FLAGS.beam_size
config.trainable_variable = FLAGS.train_cnn
np.random.seed(config.seed)
tf.random.set_random_seed(config.seed)
is_trainable = FLAGS.phase == 'train'
if FLAGS.model == 'SeqGAN':
model = SeqGAN(config, is_trainable)
elif FLAGS.model == 'Show&Tell':
model = CaptionGenerator(config)
else:
model = SeqGAN(config, is_trainable)
with tf.Session() as sess:
print("FLAG: " + FLAGS.phase)
if FLAGS.phase == 'train':
# training phase
#image_path = 'D:/download/COCO/train/images/COCO_train2014_000000318556.jpg'
#image_loader = ImageLoader('./utils/ilsvrc_2012_mean.npy')
data = prepare_train_data(config)
sess.run(tf.global_variables_initializer())
if FLAGS.load:
model.load(sess, FLAGS.model_file)
#load the cnn file
#if FLAGS.load_cnn:
#model.load_cnn(sess, FLAGS.cnn_model_file)
#model.load_vgg()
#tf.get_default_graph().finalize()
model.train(sess, data)
elif FLAGS.phase == 'eval':
print("EVALUATING")
# evaluation phase
eval_data = prepare_eval_data(config)
#model.load(sess, FLAGS.model_file)
#sess.run(tf.global_variables_initializer())
#tf.get_default_graph().finalize()
#saver = tf.train.Saver(tf.global_variables())
#saver.restore(sess,FlAGS.model_file)
model.eval(sess, eval_data)
elif FLAGS.phase == 'test_loaded_cnn':
# testing only cnn
sess.run(tf.global_variables_initializer())
imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
probs = model.test_cnn(imgs)
model.load_cnn(sess, FLAGS.cnn_model_file)
img1 = imread(FLAGS.image_file, mode='RGB')
img1 = imresize(img1, (224, 224))
prob = sess.run(probs, feed_dict={imgs: [img1]})[0]
preds = (np.argsort(prob)[::-1])[0:5]
for p in preds:
print(class_names[p], prob[p])
else:
# testing phase
test_data = prepare_test_data(config)
model.load(sess, FLAGS.model_file)
#tf.get_default_graph().finalize()
model.test(sess, test_data)
