def write_summary(value, tag, summary_writer, global_step):
"""Write a single summary value to tensorboard"""
summary = tf.Summary()
summary.value.add(tag=tag, simple_value=value)
summary_writer.add_summary(summary, global_step)
_gradients = [] # clean list of gradients
# acumulate loss
train_loss += gradIterationLoss
iterationLossCounter += gradIterationLossCounter
gradIterationLoss, gradIterationLossCounter = 0, 0
if iteration % 10 == 0:
print('Iteration ', iteration, ' out of ', train_iterations, ' finished.')
# ----------------------------------------------------------------------
# -----------------------------------------------------------------------
# avg accumulators
with open('Trainings-outputs.txt', 'a') as f:
f.write('acumulated accuracy: ' + str(train_acc) + ' iterations: ' + str(accuracyIterationsCounter))
f.write('\n')
train_loss /= iterationLossCounter # average loss
train_acc /= accuracyIterationsCounter # average accuracy
train_summary = tf.Summary(value=[tf.Summary.Value(tag='train_loss', simple_value=train_loss),
tf.Summary.Value(tag='train_accuracy', simple_value=train_acc)])
# -----------------------------------------------------------------------
# VALIDATION
if settings['validImagesDir'] != '':
validBatchReader = BatchReader(settings['validImagesDir'], 0.0, 1.0, 0.0)
else:
validBatchReader = batchReader
if validBatchReader.getNOfIterations('Valid') > 0:
valid_acc, valid_loss, valid_summary = performValidation(sess, validBatchReader, valid_iterator)
# summary_writer.add_summary(summary=valid_summary, global_step=epoch)
# summary_writer.add_summary(summary=train_summary, global_step=epoch)
# summary_writer.flush()
line = "epoch: %d/%d, train_loss: %.4f, train_acc: %.4f, valid_loss: %.4f, valid_acc: %.4f \n" % (
epoch, settings['total_epochs'], train_loss, train_acc, valid_loss, valid_acc)
print(line)
def eval_once(saver, summary_writer, label_predict, summary_op, labels, images,
filenames, logits):
"""Run Eval once.
Args:
saver: Saver.
summary_writer: Summary writer.
top_k_op: Top K op.
summary_op: Summary op.
"""
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
# Assuming model_checkpoint_path looks something like:
# /my-favorite-path/cifar10_train/model.ckpt-0,
# extract global_step from it.
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
else:
print('No checkpoint file found')
return
# Start the queue runners.
coord = tf.train.Coordinator()
try:
threads = []
for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
threads.extend(
qr.create_threads(sess,
coord=coord,
daemon=True,
start=True))
num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size))
true_count = 0 # Counts the number of correct predictions.
total_sample_count = num_iter * FLAGS.batch_size
step = 0
while step < num_iter and not coord.should_stop():
#predictions = sess.run([top_k_op])
predictions, image, label, filename, logit = sess.run(
[label_predict, images, labels, filenames, logits])
#image = sess.run(images)
#label = sess.run(labels)
saveLabelResults(image, label, predictions, filename, logit)
true_count += np.sum(predictions)
step += 1
# Compute precision @ 1.
precision = true_count / total_sample_count
print('%s: precision @ 1 = %.3f' % (datetime.now(), precision))
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
summary.value.add(tag='Precision @ 1', simple_value=precision)
summary_writer.add_summary(summary, global_step)
except Exception as e: # pylint: disable=broad-except
coord.request_stop(e)
coord.request_stop()
coord.join(threads, stop_grace_period_secs=10)
def write_summary(value, tag, summary_writer, global_step):
summary = tf.Summary()
summary.value.add(tag=tag, simple_value=value)
summary_writer.add_summary(summary, global_step)
def run_training(hypes, modules, tv_graph, tv_sess, start_step=0):
"""Run one iteration of training."""
# Unpack operations for later use
summary = tf.Summary()
sess = tv_sess['sess']
summary_writer = tv_sess['writer']
solver = modules['solver']
display_iter = hypes['logging']['display_iter']
write_iter = hypes['logging'].get('write_iter', 5 * display_iter)
eval_iter = hypes['logging']['eval_iter']
save_iter = hypes['logging']['save_iter']
image_iter = hypes['logging'].get('image_iter', 5 * save_iter)
dict_smoother = ExpoSmoother(0.95)
py_smoother = MedianSmoother(20)
n = 0
eval_names, eval_ops = zip(*tv_graph['eval_list'])
# Run the training Step
start_time = time.time()
for step in range(start_step, hypes['solver']['max_steps']):
regression_weights = solver.get_regression_weights(step, 1.0)
lr = solver.get_learning_rate(hypes, step)
feed_dict = {
tv_graph['learning_rate']: lr,
hypes['solver']['regression_weights']: regression_weights
}
if step % display_iter:
sess.run([tv_graph['train_op']], feed_dict=feed_dict)
# Write the summaries and print an overview fairly often.
elif step % display_iter == 0:
# Print status to stdout.
_, loss_value, training_loss, eval_results = sess.run(
[
tv_graph['train_op'], tv_graph['losses']['total_loss'],
tv_graph['losses'], eval_ops
],
feed_dict=feed_dict)
_print_training_status(hypes, step, loss_value, start_time, lr)
_print_eval_dict(eval_names, eval_results, prefix=' (raw)')
dict_smoother.update_weights(eval_results)
smoothed_results = dict_smoother.get_weights()
_print_eval_dict(eval_names, smoothed_results, prefix='(smooth)')
#logging.info('Regression Weights: Depth: %.2f, Location: %.2f, Corner: %.2f'%(regression_weights[0], \
# regression_weights[1], regression_weights[2]))
# Reset timer
start_time = time.time()
if step % write_iter == 0:
# write values to summary
if FLAGS.summary:
summary_str = sess.run(tv_sess['summary_op'],
feed_dict=feed_dict)
summary_writer.add_summary(summary_str, global_step=step)
summary.value.add(tag='training/total_loss',
simple_value=float(loss_value))
summary.value.add(tag='training/learning_rate', simple_value=lr)
summary_writer.add_summary(summary, step)
# Convert numpy types to simple types.
eval_results = np.array(eval_results)
eval_results = eval_results.tolist()
eval_dict = zip(eval_names, eval_results)
_write_eval_dict_to_summary(eval_dict, 'Eval/raw', summary_writer,
step)
eval_dict = zip(eval_names, smoothed_results)
_write_eval_dict_to_summary(eval_dict, 'Eval/smooth',
summary_writer, step)
# Do a evaluation and print the current state
if (step) % eval_iter == 0 \
or (step + 1) == hypes['solver']['max_steps']:
# write checkpoint to disk
logging.info('Running Evaluation Script.')
eval_dict, images = modules['eval'].evaluate(
hypes, sess, tv_graph['image_pl'], tv_graph['calib_pl'],
tv_graph['xy_scale_pl'], tv_graph['inf_out'])
_write_images_to_summary(images, summary_writer, step)
logging.info("Evaluation Finished. All results will be saved to:")
logging.info(hypes['dirs']['output_dir'])
if images is not None and len(images) > 0:
name = str(n % 10) + '_' + images[0][0]
image_file = os.path.join(hypes['dirs']['image_dir'], name)
imageio.imsave(image_file, images[0][1])
n = n + 1
logging.info('Raw Results:')
utils.print_eval_dict(eval_dict, prefix='(raw) ')
_write_eval_dict_to_summary(eval_dict, 'Evaluation/raw',
summary_writer, step)
logging.info('Smooth Results:')
names, res = zip(*eval_dict)
smoothed = py_smoother.update_weights(res)
eval_dict = zip(names, smoothed)
utils.print_eval_dict(eval_dict, prefix='(smooth)')
_write_eval_dict_to_summary(eval_dict, 'Evaluation/smoothed',
summary_writer, step)
# Reset timer
start_time = time.time()
# Save a checkpoint periodically.
if (step) % save_iter == 0 and step > 0 or \
(step + 1) == hypes['solver']['max_steps']:
# write checkpoint to disk
checkpoint_path = os.path.join(hypes['dirs']['output_dir'],
'model.ckpt')
tv_sess['saver'].save(sess, checkpoint_path, global_step=step)
# Reset timer
start_time = time.time()
if step % image_iter == 0 and step > 0 or \
(step + 1) == hypes['solver']['max_steps']:
_write_images_to_disk(hypes, images, step)
def main():
args = parser.parse_args()
# We store all arguments in a json file. This has two advantages:
# 1. We can always get back and see what exactly that experiment was
# 2. We can resume an experiment as-is without needing to remember all flags.
args_file = os.path.join(args.experiment_root, 'args.json')
if args.resume:
if not os.path.isfile(args_file):
raise IOError('`args.json` not found in {}'.format(args_file))
print('Loading args from {}.'.format(args_file))
with open(args_file, 'r') as f:
args_resumed = json.load(f)
args_resumed['resume'] = True # This would be overwritten.
# When resuming, we not only want to populate the args object with the
# values from the file, but we also want to check for some possible
# conflicts between loaded and given arguments.
for key, value in args.__dict__.items():
if key in args_resumed:
resumed_value = args_resumed[key]
if resumed_value != value:
print('Warning: For the argument `{}` we are using the'
' loaded value `{}`. The provided value was `{}`'
'.'.format(key, resumed_value, value))
comand = input('Would you like to restore it?(yes/no)')
if comand == 'yes':
args.__dict__[key] = resumed_value
print('For the argument `{}` we are using the loaded value `{}`.'.format(key,
args.__dict__[key]))
else:
print('For the argument `{}` we are using the provided value `{}`.'.format(key,
args.__dict__[key]))
else:
print('Warning: A new argument was added since the last run:'
' `{}`. Using the new value: `{}`.'.format(key, value))
os.remove(args_file)
with open(args_file, 'w') as f:
json.dump(vars(args), f, ensure_ascii=False, indent=2, sort_keys=True)
else:
# If the experiment directory exists already, we bail in fear.
if os.path.exists(args.experiment_root):
if os.listdir(args.experiment_root):
print('The directory {} already exists and is not empty.'
' If you want to resume training, append --resume to'
' your call.'.format(args.experiment_root))
exit(1)
else:
os.makedirs(args.experiment_root)
# Store the passed arguments for later resuming and grepping in a nice
# and readable format.
with open(args_file, 'w') as f:
json.dump(vars(args), f, ensure_ascii=False, indent=2, sort_keys=True)
log_file = os.path.join(args.experiment_root, "train")
logging.config.dictConfig(common.get_logging_dict(log_file))
log = logging.getLogger('train')
# Also show all parameter values at the start, for ease of reading logs.
log.info('Training using the following parameters:')
for key, value in sorted(vars(args).items()):
log.info('{}: {}'.format(key, value))
# Check them here, so they are not required when --resume-ing.
if not args.train_set:
parser.print_help()
log.error("You did not specify the `train_set` argument!")
sys.exit(1)
if not args.image_root:
parser.print_help()
log.error("You did not specify the required `image_root` argument!")
sys.exit(1)
######################################################################################
#prepare the training dataset
# Load the data from the TxT file. see Common.load_dataset function for details
pids_train, fids_train = common.load_dataset(args.train_set, args.image_root)
max_fid_len = max(map(len, fids_train)) # We'll need this later for logfiles.
# Setup a tf.Dataset where one "epoch" loops over all PIDS.
# PIDS are shuffled after every epoch and continue indefinitely.
unique_pids = np.unique(pids_train)
dataset = tf.data.Dataset.from_tensor_slices(unique_pids)
dataset = dataset.shuffle(len(unique_pids))
# Constrain the dataset size to a multiple of the batch-size, so that
# we don't get overlap at the end of each epoch.
dataset = dataset.take((len(unique_pids) // args.batch_p) * args.batch_p)
dataset = dataset.repeat(None) # Repeat forever. Funny way of stating it.
# For every PID, get K images.
dataset = dataset.map(lambda pid: sample_k_fids_for_pid(
pid, all_fids=fids_train, all_pids=pids_train, batch_k=args.batch_k)) # now the dataset has been modified as [selected_fids
# , pid] due to the return of the function 'sample_k_fids_for_pid'
# Ungroup/flatten the batches for easy loading of the files.
dataset = dataset.apply(tf.contrib.data.unbatch())
# Convert filenames to actual image tensors.
net_input_size = (args.net_input_height, args.net_input_width)
pre_crop_size = (args.pre_crop_height, args.pre_crop_width)
dataset = dataset.map(
lambda fid, pid: common.fid_to_image(
fid, pid, image_root=args.image_root,
image_size=pre_crop_size if args.crop_augment else net_input_size),
num_parallel_calls=args.loading_threads) # now the dataset has been modified as [selected_images
# , fid， pid] due to the return of the function 'fid_to_image'
# Augment the data if specified by the arguments.
if args.flip_augment:
dataset = dataset.map(
lambda im, fid, pid: (tf.image.random_flip_left_right(im), fid, pid))
if args.crop_augment:
dataset = dataset.map(
lambda im, fid, pid: (tf.random_crop(im, net_input_size + (3,)), fid, pid))
# Group it back into PK batches.
batch_size = args.batch_p * args.batch_k
dataset = dataset.batch(batch_size)
# Overlap producing and consuming for parallelism.
dataset = dataset.prefetch(1)
# Since we repeat the data infinitely, we only need a one-shot iterator.
images_train, fids_train, pids_train = dataset.make_one_shot_iterator().get_next()
########################################################################################################################
#prepare the validation set
pids_val, fids_val = common.load_dataset(args.validation_set, args.validation_image_root)
# Setup a tf.Dataset where one "epoch" loops over all PIDS.
# PIDS are shuffled after every epoch and continue indefinitely.
unique_pids_val = np.unique(pids_val)
dataset_val = tf.data.Dataset.from_tensor_slices(unique_pids_val)
dataset_val = dataset_val.shuffle(len(unique_pids_val))
# Constrain the dataset size to a multiple of the batch-size, so that
# we don't get overlap at the end of each epoch.
dataset_val = dataset_val.take((len(unique_pids_val) // args.batch_p) * args.batch_p)
dataset_val = dataset_val.repeat(None) # Repeat forever. Funny way of stating it.
# For every PID, get K images.
dataset_val = dataset_val.map(lambda pid: sample_k_fids_for_pid(
pid, all_fids=fids_val, all_pids=pids_val, batch_k=args.batch_k)) # now the dataset has been modified as [selected_fids
# , pid] due to the return of the function 'sample_k_fids_for_pid'
# Ungroup/flatten the batches for easy loading of the files.
dataset_val = dataset_val.apply(tf.contrib.data.unbatch())
# Convert filenames to actual image tensors.
net_input_size = (args.net_input_height, args.net_input_width)
pre_crop_size = (args.pre_crop_height, args.pre_crop_width)
dataset_val = dataset_val.map(
lambda fid, pid: common.fid_to_image(
fid, pid, image_root=args.validation_image_root,
image_size=pre_crop_size if args.crop_augment else net_input_size),
num_parallel_calls=args.loading_threads) # now the dataset has been modified as [selected_images
# , fid， pid] due to the return of the function 'fid_to_image'
# Augment the data if specified by the arguments.
if args.flip_augment:
dataset_val = dataset_val.map(
lambda im, fid, pid: (tf.image.random_flip_left_right(im), fid, pid))
if args.crop_augment:
dataset_val = dataset_val.map(
lambda im, fid, pid: (tf.random_crop(im, net_input_size + (3,)), fid, pid))
# Group it back into PK batches.
dataset_val = dataset_val.batch(batch_size)
# Overlap producing and consuming for parallelism.
dataset_val = dataset_val.prefetch(1)
# Since we repeat the data infinitely, we only need a one-shot iterator.
images_val, fids_val, pids_val = dataset_val.make_one_shot_iterator().get_next()
####################################################################################################################
# Create the model and an embedding head.
model = import_module('nets.' + args.model_name)
head = import_module('heads.' + args.head_name)
# Feed the image through the model. The returned `body_prefix` will be used
# further down to load the pre-trained weights for all variables with this
# prefix.
input_images = tf.placeholder(dtype=tf.float32, shape=[None,args.net_input_height,args.net_input_width,3],name='input')
pids = tf.placeholder(dtype=tf.string, shape=[None,],name='pids')
fids = tf.placeholder(dtype=tf.string, shape=[None, ], name='fids')
endpoints, body_prefix = model.endpoints(input_images, is_training=True)
with tf.name_scope('head'):
endpoints = head.head(endpoints, args.embedding_dim, is_training=True)
# Create the loss in two steps:
# 1. Compute all pairwise distances according to the specified metric.
# 2. For each anchor along the first dimension, compute its loss.
# dists = loss.cdist(endpoints['emb'], endpoints['emb'], metric=args.metric)
# losses, train_top1, prec_at_k, _, neg_dists, pos_dists = loss.LOSS_CHOICES[args.loss](
# dists, pids, args.margin, batch_precision_at_k=args.batch_k-1)
# # '_' stands for the boolean matrix shows topK where the correct match of the identities occurs
# shape=(batch_size,K)
# 更改
# loss1
dists1 = loss.cdist(endpoints['feature1'], endpoints['feature1'], metric=args.metric)
losses1,_,_,_,_,_ =loss.LOSS_CHOICES[args.loss](
dists1, pids, args.margin, batch_precision_at_k=args.batch_k - 1)
dists2 = loss.cdist(endpoints['feature2'], endpoints['feature2'], metric=args.metric)
losses2, _, _, _, _, _ = loss.LOSS_CHOICES[args.loss](
dists2, pids, args.margin, batch_precision_at_k=args.batch_k - 1)
dists3 = loss.cdist(endpoints['feature3'], endpoints['feature3'], metric=args.metric)
losses3, _, _, _, _, _ = loss.LOSS_CHOICES[args.loss](
dists3, pids, args.margin, batch_precision_at_k=args.batch_k - 1)
dists4 = loss.cdist(endpoints['feature4'], endpoints['feature4'], metric=args.metric)
losses4, _, _, _, _, _ = loss.LOSS_CHOICES[args.loss](
dists4, pids, args.margin, batch_precision_at_k=args.batch_k - 1)
dists_fu = loss.cdist(endpoints['fusion_layer'], endpoints['fusion_layer'], metric=args.metric)
losses_fu, train_top1, prec_at_k, _, neg_dists, pos_dists = loss.LOSS_CHOICES[args.loss](
dists_fu, pids, args.margin, batch_precision_at_k=args.batch_k - 1)
losses = losses1+losses2+losses3+losses4+losses_fu
# 更改
#loss
# losses_fu, train_top1, prec_at_k, _, neg_dists, pos_dists = loss.LOSS_CHOICES[args.loss](
# endpoints,pids, model_type=args.model_name, metric=args.metric, batch_precision_at_k=args.batch_k - 1
# )
# Count the number of active entries, and compute the total batch loss.
num_active = tf.reduce_sum(tf.cast(tf.greater(losses, 1e-5), tf.float32))
# 此处losses即为 pospair 比 negpair+margin 还大的部分
loss_mean = tf.reduce_mean(losses)
# Some logging for tensorboard.
tf.summary.histogram('loss_distribution', losses)
tf.summary.scalar('loss', loss_mean)
tf.summary.scalar('batch_top1', train_top1)
tf.summary.scalar('batch_prec_at_{}'.format(args.batch_k-1), prec_at_k)
tf.summary.scalar('active_count', num_active)
#tf.summary.histogram('embedding_dists', dists)
tf.summary.histogram('embedding_pos_dists', pos_dists)
tf.summary.histogram('embedding_neg_dists', neg_dists)
tf.summary.histogram('embedding_lengths',
tf.norm(endpoints['emb_raw'], axis=1))
# Create the mem-mapped arrays in which we'll log all training detail in
# addition to tensorboard, because tensorboard is annoying for detailed
# inspection and actually discards data in histogram summaries.
if args.detailed_logs:
log_embs = lb.create_or_resize_dat(
os.path.join(args.experiment_root, 'embeddings'),
dtype=np.float32, shape=(args.train_iterations, batch_size, args.embedding_dim))
log_loss = lb.create_or_resize_dat(
os.path.join(args.experiment_root, 'losses'),
dtype=np.float32, shape=(args.train_iterations, batch_size))
log_fids = lb.create_or_resize_dat(
os.path.join(args.experiment_root, 'fids'),
dtype='S' + str(max_fid_len), shape=(args.train_iterations, batch_size))
# These are collected here before we add the optimizer, because depending
# on the optimizer, it might add extra slots, which are also global
# variables, with the exact same prefix.
model_variables = tf.get_collection(
tf.GraphKeys.GLOBAL_VARIABLES, body_prefix)
# Define the optimizer and the learning-rate schedule.
# Unfortunately, we get NaNs if we don't handle no-decay separately.
global_step = tf.Variable(0, name='global_step', trainable=False) # 'global_step' means the number of batches seen
# by graph
if 0 <= args.decay_start_iteration < args.train_iterations:
learning_rate = tf.train.exponential_decay(
args.learning_rate,
tf.maximum(0, global_step - args.decay_start_iteration), # decay every 'lr_decay_steps' after the
# 'decay_start_iteration'
# args.train_iterations - args.decay_start_iteration, args.weight_decay_factor)
args.lr_decay_steps, args.lr_decay_factor, staircase=True)
else:
learning_rate = args.learning_rate # the case when we set 'decay_start_iteration' as -1
tf.summary.scalar('learning_rate', learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate,epsilon=1e-3)
# Feel free to try others!
# optimizer = tf.train.AdadeltaOptimizer(learning_rate)
# Update_ops are used to update batchnorm stats.
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
train_op = optimizer.minimize(loss_mean, global_step=global_step)
# Define a saver for the complete model.
checkpoint_saver = tf.train.Saver(max_to_keep=0)
with tf.Session(config=config) as sess:
if args.resume:
# In case we're resuming, simply load the full checkpoint to init.
if args.checkpoint is None:
last_checkpoint = tf.train.latest_checkpoint(args.experiment_root)
log.info('Restoring from checkpoint: {}'.format(last_checkpoint))
checkpoint_saver.restore(sess, last_checkpoint)
else:
ckpt_path = os.path.join(args.experiment_root, args.checkpoint)
log.info('Restoring from checkpoint: {}'.format(args.checkpoint))
checkpoint_saver.restore(sess, ckpt_path)
else:
# But if we're starting from scratch, we may need to load some
# variables from the pre-trained weights, and random init others.
sess.run(tf.global_variables_initializer())
if args.initial_checkpoint is not None:
saver = tf.train.Saver(model_variables)
saver.restore(sess, args.initial_checkpoint) # restore the pre-trained parameter from online model
# In any case, we also store this initialization as a checkpoint,
# such that we could run exactly reproduceable experiments.
checkpoint_saver.save(sess, os.path.join(
args.experiment_root, 'checkpoint'), global_step=0)
merged_summary = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(args.experiment_root, sess.graph)
start_step = sess.run(global_step)
log.info('Starting training from iteration {}.'.format(start_step))
# Finally, here comes the main-loop. This `Uninterrupt` is a handy
# utility such that an iteration still finishes on Ctrl+C and we can
# stop the training cleanly.
with lb.Uninterrupt(sigs=[SIGINT, SIGTERM], verbose=True) as u:
for i in range(start_step, args.train_iterations):
# Compute gradients, update weights, store logs!
start_time = time.time()
_, summary, step, b_prec_at_k, b_embs, b_loss, b_fids = \
sess.run([train_op, merged_summary, global_step,
prec_at_k, endpoints['emb'], losses, fids], feed_dict={input_images:images_train.eval(),
pids:pids_train.eval(),
fids:fids_train.eval()})
elapsed_time = time.time() - start_time
# Compute the iteration speed and add it to the summary.
# We did observe some weird spikes that we couldn't track down.
summary2 = tf.Summary()
summary2.value.add(tag='secs_per_iter', simple_value=elapsed_time)
summary_writer.add_summary(summary2, step)
summary_writer.add_summary(summary, step)
if args.detailed_logs:
log_embs[i], log_loss[i], log_fids[i] = b_embs, b_loss, b_fids
# Do a huge print out of the current progress.
seconds_todo = (args.train_iterations - step) * elapsed_time
log.info('iter:{:6d}, loss min|avg|max: {:.3f}|{:.3f}|{:6.3f}, '
'batch-p@{}: {:.2%}, ETA: {} ({:.2f}s/it)'.format(
step,
float(np.min(b_loss)),
float(np.mean(b_loss)),
float(np.max(b_loss)),
args.batch_k-1, float(b_prec_at_k),
timedelta(seconds=int(seconds_todo)),
elapsed_time))
sys.stdout.flush()
sys.stderr.flush()
# Save a checkpoint of training every so often.
if (args.checkpoint_frequency > 0 and
step % args.checkpoint_frequency == 0):
checkpoint_saver.save(sess, os.path.join(
args.experiment_root, 'checkpoint'), global_step=step)
#get validation results
if (args.validation_frequency > 0 and
step % args.validation_frequency == 0):
b_prec_at_k_val, b_loss, b_fids = \
sess.run([prec_at_k, losses, fids], feed_dict={input_images : images_val.eval(),
pids:pids_val.eval(),
fids:fids_val.eval()})
log.info('Validation @:{:6d} iteration, loss min|avg|max: {:.3f}|{:.3f}|{:6.3f}, '
'batch-p@{}: {:.2%}'.format(
step,
float(np.min(b_loss)),
float(np.mean(b_loss)),
float(np.max(b_loss)),
args.batch_k - 1, float(b_prec_at_k_val)
))
sys.stdout.flush()
sys.stderr.flush()
summary3 = tf.Summary()
summary3.value.add(tag='secs_per_iter', simple_value=float(np.mean(b_loss)))
summary_writer.add_summary(summary3, step)
summary_writer.add_summary(summary3, step)
# Stop the main-loop at the end of the step, if requested.
if u.interrupted:
log.info("Interrupted on request!")
break
# Store one final checkpoint. This might be redundant, but it is crucial
# in case intermediate storing was disabled and it saves a checkpoint
# when the process was interrupted.
checkpoint_saver.save(sess, os.path.join(
args.experiment_root, 'checkpoint'), global_step=step)
def train(self, trainImagesLabelsTup, valImagesLabelsTup=None):
#prep data
windowsArr, labelAnsArr = self.extractWindowsAndLabels(trainImagesLabelsTup)
#prep val data (done at test time now)
# if valImagesLabelsTup:
# valImages, valLabels = valImagesLabelsTup
# valImages, valLabels = np.repeat(valImages, int(c.BATCH_SZ/c.NUM_TEST_IMGS), axis=0), np.repeat(valLabels, int(c.BATCH_SZ/c.NUM_TEST_IMGS)) #hack to fit in batch size
# valWindows, valLabel = self.extractWindowsAndLabels(valImagesLabelsTup)
#train
step = 0
num_batches_per_e = int(c.NUM_TRAIN_IMGS/c.BATCH_SZ)
num_steps = num_batches_per_e*c.NUM_EPOCHS
for epoch in range(c.NUM_EPOCHS):
if c.STOCHASTIC_GD:#shuffle data
permutation = np.random.permutation(len(labelAnsArr))
windowsArr, labelAnsArr = windowsArr[permutation], labelAnsArr[permutation]
# Begin Epoch Train #
for b_num in range(num_batches_per_e):
if step < tf.train.global_step(self.sess, self.glob_step):
#catch up to saved state if resuming training. (dont do anything if step/epoch is too early)
step += 1
continue
if c.STOCHASTIC_GD:
print("\nTrain Step:", step)
else:
print("\nTrain Step (Epoch):", step)
print(100.0*step/num_steps, "percent done")
start_index = c.BATCH_SZ*b_num
stop_index = start_index + c.BATCH_SZ
data, labels = windowsArr[start_index:stop_index], labelAnsArr[start_index:stop_index]
feedDict = {self.img_batch_in: data, self.labels: labels}
if self.saveable:
sessArgs = [self.accuracy, self.loss, self.train_loss_summary, self.trainOp]
acc, lossReturned, summary, _ = self.sess.run(sessArgs, feed_dict=feedDict)
else:
sessArgs = [self.accuracy, self.loss, self.trainOp]
acc, lossReturned, _ = self.sess.run(sessArgs, feed_dict=feedDict)
print("loss -", lossReturned)
print("accuracy -", acc)
step += 1
# End Epoch Train #
#save model/summary and validate
if self.saveable and step >= tf.train.global_step(self.sess, self.glob_step):
if (epoch%c.SAVE_FREQ == 0) or (epoch==c.NUM_EPOCHS-1):
self.save()
if (epoch%c.SUMMARY_FREQ == 0) or (epoch==c.NUM_EPOCHS-1):
#note, this train summary is currently only for the last batch
self.summary_writer.add_summary(summary, global_step=step)
if valImagesLabelsTup:
print("\n\nvalidating...")
# feedDict = {self.img_batch_in: valWindows, self.labels: valLabel}
# acc, valSummary = self.sess.run([self.accuracy, self.test_loss_summary], feed_dict=feedDict)
val_acc = self.test(valImagesLabelsTup, verbose=False)
valSummary = tf.Summary(value=[tf.Summary.Value(tag="test_accuracy", simple_value=val_acc)])
self.summary_writer.add_summary(valSummary, global_step=step)
print("val accuracy::", val_acc, "\n\n")
epoch = model.epoch.eval()
random_idxs = range(len(data_queries))
random.shuffle(random_idxs)
data_queries = [data_queries[i] for i in random_idxs]
data_docs = np.reshape(data_docs, (len(data_queries), -1))
data_docs = [data_docs[i] for i in random_idxs]
data_docs = np.reshape(data_docs, len(data_queries) * (FLAGS.neg_num + 1))
start_time = time.time()
loss = train(model, sess, data_queries, data_docs)
epoch_time = time.time() - start_time
total_train_time += epoch_time
# test loss
test_loss = test(model, sess, test_queries, test_docs, ground_truths)
summary = tf.Summary()
summary.value.add(tag='loss/train', simple_value=loss)
summary.value.add(tag='loss/test', simple_value=test_loss)
cur_lr = model.learning_rate.eval()
summary.value.add(tag='lr/train', simple_value=cur_lr)
summary_writer.add_summary(summary, epoch)
model.saver.save(sess, '%s/checkpoint' % FLAGS.train_dir, global_step=model.global_step)
print("epoch %d learning rate %.10f epoch-time %.4f loss %.8f test loss %.8f" % (
epoch, cur_lr, epoch_time, loss, test_loss))
with open(os.path.join(FLAGS.train_dir, FLAGS.time_log_path), 'a') as fp:
fp.writelines(['total training time: %f\n' % total_train_time, 'last test loss: %.8f' % test_loss])
def main():
"""Create the model and start the training."""
hvd.init()
args = get_arguments()
args.snapshot_dir = args.snapshot_dir.replace(
'DeepDICD/', 'DeepDICD/' + args.model_name + '-' + args.domain + '-')
print(toMagenta(args.snapshot_dir))
ss = args.domain.split('-')
if ss[0] == 'D':
args.list1 = args.list1.replace('amazon.txt', 'dslr.txt')
elif ss[0] == 'W':
args.list1 = args.list1.replace('amazon.txt', 'webcam.txt')
if ss[1] == 'A':
args.list2 = args.list2.replace('dslr.txt', 'amazon.txt')
elif ss[1] == 'W':
args.list2 = args.list2.replace('dslr.txt', 'webcam.txt')
print(toMagenta(args.list1))
print(toMagenta(args.list2))
start_steps = args.start_steps
h = args.h
w = args.w
# construct data generator
file1 = open(args.list1)
num1 = len(file1.readlines())
file2 = open(args.list2)
num2 = len(file2.readlines())
file1.close()
file2.close()
steps_per_epoch = int((num1 / (args.batch_size)))
num_steps = int(steps_per_epoch * args.num_epochs)
val_num_steps = int(num2 / args.batch_size)
print(toCyan('src domain: {:d}, tar domain {:d}'.format(num1, num2)))
print(
toCyan('steps_per_epoch x num_epochs:{:d} x {:d}'.format(
steps_per_epoch, args.num_epochs)))
# Chong
# split_batch_size=int(args.batch_size/hvd.size())
myDataloader = Dataloader(args.img_dir, args.list1, args.list2,
args.batch_size, args.h, args.w,
args.num_threads)
src_img = myDataloader.simg_batch
src_label = myDataloader.slabel_batch
tar_img = myDataloader.timg_batch
tar_label = myDataloader.tlabel_batch
coord = tf.train.Coordinator()
# Learning Startegy Settings
baseLR1 = tf.constant(args.lr1)
baseLR2 = tf.constant(args.lr2)
step_ph = tf.placeholder(dtype=tf.float32, shape=())
if args.learning_strategy == 0:
lr1 = baseLR1 / tf.pow(1 + 0.001 * step_ph / steps_per_epoch, 0.75)
lr2 = baseLR2 / tf.pow(1 + 0.001 * step_ph / steps_per_epoch, 0.75)
elif args.learning_strategy == 1:
lr1 = baseLR1 / tf.pow(1 + 0.0005 * step_ph / steps_per_epoch, 0.75)
lr2 = baseLR2 / tf.pow(1 + 0.0005 * step_ph / steps_per_epoch, 0.75)
elif args.learning_strategy == 2:
lr1 = baseLR1 / tf.pow(1 + 0.005 * step_ph / steps_per_epoch, 0.75)
lr2 = baseLR2 / tf.pow(1 + 0.005 * step_ph / steps_per_epoch, 0.75)
elif args.learning_strategy == 3: # consistent with paper
lr1 = baseLR1 / tf.pow(1 + 0.001 * step_ph, 0.75)
lr2 = baseLR2 / tf.pow(1 + 0.001 * step_ph, 0.75)
elif args.learning_strategy == 4:
lr1 = baseLR1 / tf.pow(1 + 0.005 * step_ph, 0.75)
lr2 = baseLR2 / tf.pow(1 + 0.005 * step_ph, 0.75)
elif args.learning_strategy == 5:
lr1 = baseLR1 / tf.pow(1 + 0.00005 * step_ph, 0.75)
lr2 = baseLR2 / tf.pow(1 + 0.00005 * step_ph, 0.75)
keep_prob = tf.placeholder(dtype=tf.float32, shape=())
# p = (1 - tf.scalar_mul(1., tf.pow((1 - step_ph / num_steps), args.power)))
p = adaptation_factor(step_ph / MAX_STEP / 6)
# p = adaptation_factor(step_ph/MAX_STEP)
# p2 = adaptation_factor(step_ph/(2*MAX_STEP))
alpha1 = p
# alpha1 = tf.constant(1.,tf.float32)
alpha2 = 0.30 * p
# alpha2 = tf.constant(0.,tf.float32)
alpha3 = 1 * p
# alpha2=p2
# loss_balance=tf.constant(0.001,tf.float32)
# boundaries = [np.float32(np.int32((1/14) * num_steps))]
# values = [0., 0.01]
# loss_balance = tf.train.piecewise_constant(step_ph, boundaries, values)
#
model = DeepDICDModel(args, keep_prob, src_img, src_label, tar_img,
tar_label)
centroid_update_ops = model.build_losses(alpha1, alpha2, alpha3)
model.build_outputs()
summary_ = model.build_summary()
all_trainable_var = [v for v in tf.trainable_variables()]
fine_tune_var = [
v for v in all_trainable_var if 'fc8' not in v.name
and 'fc9' not in v.name and 'domain' not in v.name
]
fine_tune_var_weights = [v for v in fine_tune_var if 'weights' in v.name]
fine_tune_var_bias = [v for v in fine_tune_var if 'bias' in v.name]
retrain_var = [
v for v in all_trainable_var if 'fc8' in v.name or 'fc9' in v.name
]
retrain_var_weights = [v for v in retrain_var if 'weights' in v.name]
retrain_var_bias = [v for v in retrain_var if 'bias' in v.name]
domain_var = [v for v in all_trainable_var if 'domain' in v.name]
domain_var_weights = [v for v in domain_var if 'weights' in v.name]
domain_var_bias = [v for v in domain_var if 'bias' in v.name]
if hvd.rank() == 0:
print(toGreen('----fine tune var----'))
for v in fine_tune_var:
print(toCyan(v.name))
print(toGreen('----retrain var----'))
for v in retrain_var:
print(toCyan(v.name))
print(toGreen('----domain var----'))
for v in domain_var:
print(toCyan(v.name))
# Chong: broadcast every iter
bcast = hvd.broadcast_global_variables(0)
with tf.control_dependencies([centroid_update_ops]):
opt_1_1 = tf.train.MomentumOptimizer(lr1 * hvd.size(), args.momentum)
opt_1_1 = hvd.DistributedOptimizer(opt_1_1)
# Chong: different with tf.gradients(), which just return grads
# While, compute_gradients() return (gradients,var) tuple
grads_1_1 = opt_1_1.compute_gradients(model.F_loss,
fine_tune_var_weights)
train_op_1_1 = opt_1_1.apply_gradients(grads_1_1)
opt_1_2 = tf.train.MomentumOptimizer(2 * lr1 * hvd.size(),
args.momentum)
opt_1_2 = hvd.DistributedOptimizer(opt_1_2)
grads_1_2 = opt_1_2.compute_gradients(model.F_loss, fine_tune_var_bias)
train_op_1_2 = opt_1_2.apply_gradients(grads_1_2)
opt_2_1 = tf.train.MomentumOptimizer(lr2 * hvd.size(), args.momentum)
opt_2_1 = hvd.DistributedOptimizer(opt_2_1)
grads_2_1 = opt_2_1.compute_gradients(model.F_loss,
retrain_var_weights)
train_op_2_1 = opt_2_1.apply_gradients(grads_2_1)
opt_2_2 = tf.train.MomentumOptimizer(2 * lr2 * hvd.size(),
args.momentum)
opt_2_2 = hvd.DistributedOptimizer(opt_2_2)
grads_2_2 = opt_2_2.compute_gradients(model.F_loss, retrain_var_bias)
train_op_2_2 = opt_2_2.apply_gradients(grads_2_2)
opt_3_1 = tf.train.MomentumOptimizer(lr2 * hvd.size(), args.momentum)
opt_3_1 = hvd.DistributedOptimizer(opt_3_1)
grads_3_1 = opt_3_1.compute_gradients(
model.dregular_loss + model.D_loss, domain_var_weights)
train_op_3_1 = opt_3_1.apply_gradients(grads_3_1)
opt_3_2 = tf.train.MomentumOptimizer(2 * lr2 * hvd.size(),
args.momentum)
opt_3_2 = hvd.DistributedOptimizer(opt_3_2)
grads_3_2 = opt_3_2.compute_gradients(
model.dregular_loss + model.D_loss, domain_var_bias)
train_op_3_2 = opt_3_2.apply_gradients(grads_3_2)
# Chong: broadcast ever iter
train_op = tf.group(train_op_1_1, train_op_1_2, train_op_2_1,
train_op_2_2, train_op_3_1, train_op_3_2, bcast)
# Set up tf session and initialize variables.
#
config = tf.ConfigProto() # Chong
config.gpu_options.allow_growth = True
config.gpu_options.visible_device_list = str(hvd.local_rank())
config.gpu_options.per_process_gpu_memory_fraction = 0.4
sess = tf.Session(config=config)
init_local = tf.local_variables_initializer()
init = tf.global_variables_initializer()
# construct summary
summary_.append(tf.summary.scalar('train/lr1', lr1))
summary_.append(tf.summary.scalar('train/lr2', lr2))
summary_.append(tf.summary.scalar('train/alpha1', alpha1))
summary_.append(tf.summary.scalar('train/alpha2', alpha2))
summary_merged = tf.summary.merge(summary_)
if hvd.rank() == 0:
FinalSummary = tf.summary.FileWriter(args.snapshot_dir, sess.graph)
# init
sess.run([init_local, init])
sess.run(bcast)
# Saver for storing checkpoints of the model.
var = tf.global_variables()
skip_var = ['fc8', 'fc9']
saver = tf.train.Saver(var_list=var, max_to_keep=5)
ckpt = tf.train.get_checkpoint_state(args.resume_from)
if ckpt and ckpt.model_checkpoint_path and args.resume:
loader = tf.train.Saver(var_list=var)
load_step = int(
os.path.basename(ckpt.model_checkpoint_path).split('-')[1])
load(loader, sess, ckpt.model_checkpoint_path)
elif not args.not_load_pretrained:
print(toRed('Restore from pre-trained model...' + args.restore_from))
model.load_initial_weights(sess, args.restore_from,
skip_var) # Chong:0531
# Start queue threads.
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
# Iterate over training steps.
acc2_history = 0
for step in range(start_steps, num_steps):
start_time = time.time()
feed_dict = {step_ph: step, keep_prob: 0.5}
summary, total_loss, _ = sess.run(
[summary_merged, model.F_loss, train_op], feed_dict=feed_dict)
if hvd.rank() == 0:
FinalSummary.add_summary(summary, step)
duration = time.time() - start_time
remain_time = duration * (num_steps - step) / 3600
print('\r', toCyan('{:s}:{:d}-{:d}-{:d} loss = {:.3f},({:.3f} sec/step, ERT: {:.3f})'\
.format(args.model_name + '-'\
+ args.domain, step % steps_per_epoch,\
step // steps_per_epoch, args.num_epochs,\
total_loss, duration, remain_time)), end='')
if step % args.test_every == 0:
acc1, acc2 = 0, 0
for jj in range(val_num_steps):
feed_dict = {keep_prob: 1}
src_acc, tar_acc = sess.run([model.src_acc, model.tar_acc],
feed_dict=feed_dict)
acc1 += np.sum(src_acc)
acc2 += np.sum(tar_acc)
acc1 = acc1 / (val_num_steps * args.batch_size)
acc2 = acc2 / (val_num_steps * args.batch_size)
# pdb.set_trace()
test_summary = tf.Summary()
test_summary.value.add(tag='test/source_accuracy',
simple_value=acc1)
test_summary.value.add(tag='test/target_accuracy',
simple_value=acc2)
FinalSummary.add_summary(test_summary, step)
if acc2 > acc2_history:
save(saver, sess, args.snapshot_dir, step)
acc2_history = acc2
coord.request_stop()
coord.join(threads)
sess.close()
def __enter__(self):
self.summary = tf.Summary()
return self
def evaluate_localization_thread(global_step, mode, nearest_d_dist,
nearest_d_indices, nearest_latent_indices,
out_name, query_image_info, query_xy,
ref_image_info, ref_xy, writer):
d_to_nearest_latent = np.empty(nearest_latent_indices.shape)
for i in range(NUM_EVAL_QUERIES):
for j in range(nearest_latent_indices.shape[1]):
other_index = nearest_latent_indices[i][j]
d_to_nearest_latent[i, j] = np.linalg.norm(query_xy[i, :] -
ref_xy[other_index, :])
top_n = np.empty(nearest_latent_indices.shape)
for i in range(NUM_EVAL_QUERIES):
for j in range(nearest_latent_indices.shape[1]):
top_n[i, j] = min(d_to_nearest_latent[i, 0:(j + 1)])
# Sorting top_n
x = [[] for n in range(top_n.shape[1] + 1)]
y = [[] for n in range(top_n.shape[1] + 1)]
for n in range(top_n.shape[1]):
x[n] = np.sort(top_n[:, n])
y[n] = np.array(range(NUM_EVAL_QUERIES)) / float(NUM_EVAL_QUERIES)
x[-1] = np.sort(np.array(nearest_d_dist).reshape(-1))
y[-1] = np.array(range(NUM_EVAL_QUERIES)) / float(NUM_EVAL_QUERIES)
summary = tf.Summary()
full_auc = sklearn.metrics.auc(x[0], y[0])
summary.value.add(tag='full_auc@Top1', simple_value=full_auc)
x_partial = x # not actually a copy (x will be changed when modifiying x_partial)
y_partial = y
for rad in [1.0, 10.0]:
plt.clf()
for n in range(top_n.shape[1] + 1):
x_partial[n] = [p for p in x_partial[n] if p <= rad]
y_partial[n] = [y_partial[n][k] for k in range(len(x_partial[n]))]
plt.plot(x_partial[n], y_partial[n])
plt.legend(['Top-1', 'Top-2', 'Top-3', 'Top-4', 'Top-5', 'Optimum'])
plt.ylabel('Correctly localized')
plt.xlabel('Tolerance [m]')
plt.xlim(0, rad)
title = os.path.basename(
os.path.dirname(OUT_DIR)) + '\n' + os.path.basename(
OUT_DIR) + '\n' + mode + ' ' + out_name
plt.title(title)
if len(x_partial[0]) > 1:
auc = sklearn.metrics.auc(x_partial[0], y_partial[0])
summary.value.add(tag='{}m-auc@Top1'.format(rad), simple_value=auc)
plt.text(0.5 * float(rad), 0.08, 'AUC@Top1={:7.2f}'.format(auc))
correct_fraction = len(x_partial[0]) / len(top_n[:, 0])
summary.value.add(tag='%<{}m@Top1'.format(rad),
simple_value=correct_fraction)
plt.text(0.5 * float(rad), 0.02,
'%<{}m@Top1={:7.2f}'.format(rad, correct_fraction))
plt.savefig(
os.path.join(OUT_DIR,
mode + '_' + out_name + '_{}.pdf'.format(rad)))
writer.add_summary(summary, global_step)
# Save visual examples
example_img_dir = os.path.join(OUT_DIR, mode + '_' + out_name)
os.mkdir(example_img_dir)
for index in np.random.choice(NUM_EVAL_QUERIES, 10, replace=False):
# Query image
query_file_path = img_path(query_image_info[index])
query_image = load_img(query_file_path)
query_image = put_text('Query', query_image)
# Retrieved image
file_path = img_path(ref_image_info[nearest_latent_indices[index][0]])
retrieved_image = load_img(file_path)
dist = d_to_nearest_latent[index][0]
retrieved_image = put_text('Retrieved {}'.format(dist),
retrieved_image)
# Optimal image
file_path = img_path(ref_image_info[nearest_d_indices[index][0]])
optimal_image = load_img(file_path)
dist = nearest_d_dist[index][0]
optimal_image = put_text('Optimal {}'.format(dist), optimal_image)
merged_images = merge_images(query_image, retrieved_image)
merged_images = merge_images(merged_images, optimal_image)
save_img(
merged_images,
os.path.join(example_img_dir, os.path.basename(query_file_path)))
def log_to_tensorboard(self, tag, group, value, index):
summary = tf.Summary()
tag = group + '/' + tag
summary.value.add(tag=tag, simple_value=value)
self.stat_writer.add_summary(summary, index)
def eval(self, model):
"""
Iterate through all mini-batches in a dataset, computing:
(1) Average predictive loss (i.e. NLL) across all samples in the dataset
(2) Regularization loss (i.e. negative log prior)
(3) Total loss (i.e. loss used as a training objective by the model)
Additionally, the function computes both targets and predictions for all samples in the dataset.
The method returns a tf.Summary object containing the value values of all three losses, as well as the targets
and model predictions for all samples in the dataset.
:param model: An instantiated object of any class inheriting from BasicModel. It is assumed that the
computational graph of the model has been already built and that all variables are initialised.
:return: A tf.Summary object containing the value values of the average predictive loss, regularization loss
and total loss across all samples in the dataset. Two NumPy arrays containing the targets and predictions
respectively are also returned.
"""
# Initialize variables
batches_seen, n_samples = 0, 0
pred_loss, reg_loss, total_loss = 0, 0, 0
targets, predictions = [], []
# Iterate across all model batches, accumulating output along the way
while batches_seen < model.get_n_batches():
# Compute loss (predictive, regularization and total), original targets and model predictions for the
# mini-batch
tensors = model.get_losses(keys=['prediction', 'regularization', 'total']) + \
model.get_inputs(keys=['target']) + \
model.get_outputs(keys=['mlp/out'])
pred_loss_batch, reg_loss_batch, total_loss_batch, targets_batch, predictions_batch = self.sess.run(
tensors)
batch_size = targets_batch.shape[
0] # Handle potential variable-size mini-batches
# Update losses
pred_loss += batch_size * pred_loss_batch
reg_loss += batch_size * reg_loss_batch # Not strictly necessary, as it is constant across batches
total_loss += batch_size * total_loss_batch
# Update targets and predictions
targets.append(targets_batch)
predictions.append(predictions_batch)
# Update number of examples
n_samples += batch_size
# Increase counter of batches processed
batches_seen += 1
# Create TensorFlow Summary, adding the three basic model losses
summary = tf.Summary()
summary.value.add(tag='Predictive_loss',
simple_value=pred_loss / n_samples)
summary.value.add(tag='Regularization_loss',
simple_value=reg_loss / n_samples)
summary.value.add(tag='Total_loss',
simple_value=total_loss / n_samples)
# Concatenate targets and predictions for each mini-batch into single NumPy arrays
targets, predictions = np.concatenate(targets, axis=0), np.concatenate(
predictions, axis=0)
return summary, targets, predictions
def log_metric(log, name, value, step=0):
summary = tf.Summary(value=[tf.Summary.Value(tag=name, simple_value=value)])
log.add_summary(summary, global_step=step)
def deep_q_learning(sess,
env,
q_estimator,
target_estimator,
state_processor,
num_episodes,
experiment_dir,
replay_memory_size=500000,
replay_memory_init_size=50000,
update_target_estimator_every=10000,
discount_factor=0.99,
epsilon_start=1.0,
epsilon_end=0.1,
epsilon_decay_steps=500000,
batch_size=32,
record_video_every=50):
"""
Q-Learning algorithm for off-policy TD control using Function Approximation.
Finds the optimal greedy policy while following an epsilon-greedy policy.
Args:
sess: Tensorflow Session object
env: OpenAI environment
q_estimator: Estimator object used for the q values
target_estimator: Estimator object used for the targets
state_processor: A StateProcessor object
num_episodes: Number of episodes to run for
experiment_dir: Directory to save Tensorflow summaries in
replay_memory_size: Size of the replay memory
replay_memory_init_size: Number of random experiences to sample when initializing
the reply memory.
update_target_estimator_every: Copy parameters from the Q estimator to the
target estimator every N steps
discount_factor: Gamma discount factor
epsilon_start: Chance to sample a random action when taking an action.
Epsilon is decayed over time and this is the start value
epsilon_end: The final minimum value of epsilon after decaying is done
epsilon_decay_steps: Number of steps to decay epsilon over
batch_size: Size of batches to sample from the replay memory
record_video_every: Record a video every N episodes
Returns:
An EpisodeStats object with two numpy arrays for episode_lengths and episode_rewards.
"""
Transition = namedtuple(
"Transition", ["state", "action", "reward", "next_state", "done"])
# The replay memory
replay_memory = []
# Make model copier object
estimator_copy = ModelParametersCopier(q_estimator, target_estimator)
# Keeps track of useful statistics
stats = plotting.EpisodeStats(episode_lengths=np.zeros(num_episodes),
episode_rewards=np.zeros(num_episodes))
# For 'system/' summaries, usefull to check if currrent process looks healthy
current_process = psutil.Process()
# Create directories for checkpoints and summaries
checkpoint_dir = os.path.join(experiment_dir, "checkpoints")
checkpoint_path = os.path.join(checkpoint_dir, "model")
monitor_path = os.path.join(experiment_dir, "monitor")
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
if not os.path.exists(monitor_path):
os.makedirs(monitor_path)
saver = tf.train.Saver()
# Load a previous checkpoint if we find one
latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
if latest_checkpoint:
print("Loading model checkpoint {}...\n".format(latest_checkpoint))
saver.restore(sess, latest_checkpoint)
# Get the current time step
# total_t = sess.run(tf.contrib.framework.get_global_step())
total_t = sess.run(tf.train.get_global_step())
# The epsilon decay schedule
epsilons = np.linspace(epsilon_start, epsilon_end, epsilon_decay_steps)
# The policy we're following
policy = make_epsilon_greedy_policy(q_estimator, len(VALID_ACTIONS))
# Populate the replay memory with initial experience
print("Populating replay memory...")
state = env.reset()
state = state_processor.process(sess, state)
state = np.stack([state] * 4, axis=2)
for i in range(replay_memory_init_size):
action_probs = policy(sess, state,
epsilons[min(total_t, epsilon_decay_steps - 1)])
action = np.random.choice(np.arange(len(action_probs)), p=action_probs)
next_state, reward, done, _ = env.step(VALID_ACTIONS[action])
next_state = state_processor.process(sess, next_state)
next_state = np.append(state[:, :, 1:],
np.expand_dims(next_state, 2),
axis=2)
replay_memory.append(
Transition(state, action, reward, next_state, done))
if done:
state = env.reset()
state = state_processor.process(sess, state)
state = np.stack([state] * 4, axis=2)
else:
state = next_state
# Record videos
# Add env Monitor wrapper
env = Monitor(env,
directory=monitor_path,
video_callable=lambda count: count % record_video_every == 0,
resume=True)
for i_episode in range(num_episodes):
# Save the current checkpoint
saver.save(tf.get_default_session(), checkpoint_path)
# Reset the environment
state = env.reset()
state = state_processor.process(sess, state)
state = np.stack([state] * 4, axis=2)
loss = None
# One step in the environment
for t in itertools.count():
# Epsilon for this time step
epsilon = epsilons[min(total_t, epsilon_decay_steps - 1)]
# Maybe update the target estimator
if total_t % update_target_estimator_every == 0:
estimator_copy.make(sess)
print("\nCopied model parameters to target network.")
# Print out which step we're on, useful for debugging.
print("\rStep {} ({}) @ Episode {}/{}, loss: {}".format(
t, total_t, i_episode + 1, num_episodes, loss),
end="")
sys.stdout.flush()
# Take a step
action_probs = policy(sess, state, epsilon)
action = np.random.choice(np.arange(len(action_probs)),
p=action_probs)
next_state, reward, done, _ = env.step(VALID_ACTIONS[action])
next_state = state_processor.process(sess, next_state)
next_state = np.append(state[:, :, 1:],
np.expand_dims(next_state, 2),
axis=2)
# If our replay memory is full, pop the first element
if len(replay_memory) == replay_memory_size:
replay_memory.pop(0)
# Save transition to replay memory
replay_memory.append(
Transition(state, action, reward, next_state, done))
# Update statistics
stats.episode_rewards[i_episode] += reward
stats.episode_lengths[i_episode] = t
# Sample a minibatch from the replay memory
samples = random.sample(replay_memory, batch_size)
states_batch, action_batch, reward_batch, next_states_batch, done_batch = map(
np.array, zip(*samples))
# Calculate q values and targets
q_values_next = target_estimator.predict(sess, next_states_batch)
targets_batch = reward_batch + np.invert(done_batch).astype(
np.float32) * discount_factor * np.amax(q_values_next, axis=1)
# Perform gradient descent update
states_batch = np.array(states_batch)
loss = q_estimator.update(sess, states_batch, action_batch,
targets_batch)
if done:
break
state = next_state
total_t += 1
# Add summaries to tensorboard
episode_summary = tf.Summary()
episode_summary.value.add(simple_value=epsilon, tag="episode/epsilon")
episode_summary.value.add(
simple_value=stats.episode_rewards[i_episode],
tag="episode/reward")
episode_summary.value.add(
simple_value=stats.episode_lengths[i_episode],
tag="episode/length")
episode_summary.value.add(simple_value=current_process.cpu_percent(),
tag="system/cpu_usage_percent")
episode_summary.value.add(
simple_value=current_process.memory_percent(memtype="vms"),
tag="system/v_memeory_usage_percent")
q_estimator.summary_writer.add_summary(episode_summary, i_episode)
q_estimator.summary_writer.flush()
yield total_t, plotting.EpisodeStats(
episode_lengths=stats.episode_lengths[:i_episode + 1],
episode_rewards=stats.episode_rewards[:i_episode + 1])
return stats
def log_scalar(tag, value, step, w):
summary = tf.Summary(value=[tf.Summary.Value(tag=tag,
simple_value=value)])
w.add_summary(summary, step)
def eval_once(saver, summary_writer, output, labels, summary_op, last_step,
num_classes, batch_size, checkpoint_dir, restore_step, log_dir,
num_examples, unlabeled, min_angle, max_angle):
"""Run Eval once.
Args:
saver: Saver.
summary_writer: Summary writer.
eval_op: Evaluation op.
summary_op: Summary op.
"""
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
if not restore_step:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
else:
saver.restore(
sess,
os.path.join(checkpoint_dir,
'model.ckpt-{}'.format(restore_step)))
global_step = restore_step
#global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
print('{}: Checkpoint step: {}'.format(datetime.now(),
global_step))
else:
print('{}: No checkpoint found'.format(datetime.now()))
return last_step
if global_step == last_step:
print('{}: Checkpoint already evaluated'.format(datetime.now()))
return last_step
else:
last_step = global_step
# Start the queue runners.
coord = tf.train.Coordinator()
try:
threads = []
for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
threads.extend(
qr.create_threads(sess,
coord=coord,
daemon=True,
start=True))
result = np.array([])
example_count = 0
step = 0
while example_count < num_examples and not coord.should_stop():
start_time = time.time()
#label_value, output_value, imgs = sess.run([labels, output, images])
label_value, output_value = sess.run([labels, output])
duration = time.time() - start_time
if num_classes > 1:
# back from vectors to angles...
output_value = [
nvidia_input.vec_to_angle(ov, num_classes, max_angle,
min_angle)
for ov in output_value
]
if len(label_value.shape) > 1:
label_value = [
nvidia_input.vec_to_angle(lv, num_classes,
max_angle, min_angle)
for lv in label_value
]
else:
output_value = [
nvidia_input.angle_from_normalized(
ov, max_angle, min_angle) for ov in output_value
]
if not unlabeled:
label_value = [
nvidia_input.angle_from_normalized(
lv, max_angle, min_angle) for lv in label_value
]
output_value = np.reshape([output_value], [-1, 1])
label_value = np.reshape([label_value], [-1, 1])
rows = np.hstack((label_value, output_value))
result = np.append(result, rows)
result = np.reshape(result, [-1, 2])
example_count += output_value.shape[0]
if step % 10 == 0:
#print(label_value[:3], output_value[:3])
examples_per_sec = batch_size / duration
sec_per_batch = float(duration)
format_str = ('%s: step %d (%.1f examples/sec; %.3f '
'sec/batch)')
print(format_str % (datetime.now(), step, examples_per_sec,
sec_per_batch))
step += 1
eval_dir = os.path.join(checkpoint_dir, log_dir)
makedirs(eval_dir)
if not unlabeled:
result = pd.DataFrame(result,
columns=['label', 'steering_angle'])
rmse = np.sqrt(np.mean((output_value - label_value)**2))
print('Root mean square error: {:.6f}'.format(rmse))
result.iloc[:num_examples + 1].to_csv(os.path.join(
eval_dir, 'eval-{0:010d}.csv'.format(last_step)),
index=False)
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
summary.value.add(tag='Root mean square error',
simple_value=float(rmse))
summary_writer.add_summary(summary, last_step)
else: # just generate submission file
result = pd.DataFrame(result,
columns=['frame_id', 'steering_angle'])
result['frame_id'] = result.frame_id.apply(lambda x: '%.f' %
(x))
result.iloc[:num_examples + 1].to_csv(os.path.join(
eval_dir, 'test-{0:010d}.csv'.format(last_step)),
index=False)
except Exception as e:
coord.request_stop(e)
print(e)
coord.request_stop()
coord.join(threads, stop_grace_period_secs=10)
return last_step
def log_scalar1(tag, value, step):
summary = tf.Summary(value=[tf.Summary.Value(tag=tag,
simple_value=value)])
writer1.add_summary(summary, step)
def _train(self):
agents = self.remote_evaluators
config = self.config
model = self.local_evaluator
if (config["num_workers"] * config["min_steps_per_task"] >
config["timesteps_per_batch"]):
print(
"WARNING: num_workers * min_steps_per_task > "
"timesteps_per_batch. This means that the output of some "
"tasks will be wasted. Consider decreasing "
"min_steps_per_task or increasing timesteps_per_batch.")
print("===> iteration", self.iteration)
iter_start = time.time()
weights = ray.put(model.get_weights())
[a.set_weights.remote(weights) for a in agents]
samples = collect_samples(agents, config, self.local_evaluator)
def standardized(value):
# Divide by the maximum of value.std() and 1e-4
# to guard against the case where all values are equal
return (value - value.mean()) / max(1e-4, value.std())
samples.data["advantages"] = standardized(samples["advantages"])
rollouts_end = time.time()
print("Computing policy (iterations=" + str(config["num_sgd_iter"]) +
", stepsize=" + str(config["sgd_stepsize"]) + "):")
names = [
"iter", "total loss", "policy loss", "vf loss", "kl", "entropy"]
print(("{:>15}" * len(names)).format(*names))
samples.shuffle()
shuffle_end = time.time()
tuples_per_device = model.load_data(
samples, self.iteration == 0 and config["full_trace_data_load"])
load_end = time.time()
rollouts_time = rollouts_end - iter_start
shuffle_time = shuffle_end - rollouts_end
load_time = load_end - shuffle_end
sgd_time = 0
for i in range(config["num_sgd_iter"]):
sgd_start = time.time()
batch_index = 0
num_batches = (
int(tuples_per_device) // int(model.per_device_batch_size))
loss, policy_loss, vf_loss, kl, entropy = [], [], [], [], []
permutation = np.random.permutation(num_batches)
# Prepare to drop into the debugger
if self.iteration == config["tf_debug_iteration"]:
model.sess = tf_debug.LocalCLIDebugWrapperSession(model.sess)
while batch_index < num_batches:
full_trace = (
i == 0 and self.iteration == 0 and
batch_index == config["full_trace_nth_sgd_batch"])
batch_loss, batch_policy_loss, batch_vf_loss, batch_kl, \
batch_entropy = model.run_sgd_minibatch(
permutation[batch_index] * model.per_device_batch_size,
self.kl_coeff, full_trace,
self.file_writer)
loss.append(batch_loss)
policy_loss.append(batch_policy_loss)
vf_loss.append(batch_vf_loss)
kl.append(batch_kl)
entropy.append(batch_entropy)
batch_index += 1
loss = np.mean(loss)
policy_loss = np.mean(policy_loss)
vf_loss = np.mean(vf_loss)
kl = np.mean(kl)
entropy = np.mean(entropy)
sgd_end = time.time()
print(
"{:>15}{:15.5e}{:15.5e}{:15.5e}{:15.5e}{:15.5e}".format(
i, loss, policy_loss, vf_loss, kl, entropy))
values = []
if i == config["num_sgd_iter"] - 1:
metric_prefix = "ppo/sgd/final_iter/"
values.append(tf.Summary.Value(
tag=metric_prefix + "kl_coeff",
simple_value=self.kl_coeff))
values.extend([
tf.Summary.Value(
tag=metric_prefix + "mean_entropy",
simple_value=entropy),
tf.Summary.Value(
tag=metric_prefix + "mean_loss",
simple_value=loss),
tf.Summary.Value(
tag=metric_prefix + "mean_kl",
simple_value=kl)])
if self.file_writer:
sgd_stats = tf.Summary(value=values)
self.file_writer.add_summary(sgd_stats, self.global_step)
self.global_step += 1
sgd_time += sgd_end - sgd_start
if kl > 2.0 * config["kl_target"]:
self.kl_coeff *= 1.5
elif kl < 0.5 * config["kl_target"]:
self.kl_coeff *= 0.5
info = {
"kl_divergence": kl,
"kl_coefficient": self.kl_coeff,
"rollouts_time": rollouts_time,
"shuffle_time": shuffle_time,
"load_time": load_time,
"sgd_time": sgd_time,
"sample_throughput": len(samples["observations"]) / sgd_time
}
FilterManager.synchronize(
self.local_evaluator.filters, self.remote_evaluators)
res = self._fetch_metrics_from_remote_evaluators()
res = res._replace(info=info)
return res
if savedir is None:
# Careful! This will not get cleaned up. Docker spoils the developers.
savedir = tempfile.TemporaryDirectory().name
else:
container = None
# Create and seed the env.
env, monitored_env = make_env(args.env)
if args.seed > 0:
set_global_seeds(args.seed)
env.unwrapped.seed(args.seed)
subdir = (datetime.datetime.now()
).strftime("%m-%d-%Y-%H:%M:%S") + " " + args.comment
tf_writer = tf.summary.FileWriter(os.path.join(args.log_dir, subdir),
tf.get_default_graph())
value_summary = tf.Summary()
qec_summary = tf.Summary()
value_summary.value.add(tag='reward_mean')
qec_summary.value.add(tag='qec_mean')
qec_summary.value.add(tag='qec_fount')
value_summary.value.add(tag='steps')
with U.make_session(4) as sess:
# EMDQN
ec_buffer = []
buffer_size = 1000000
latent_dim = 2 * args.latent_dim
# input_dim = 1024
for i in range(env.action_space.n):
ec_buffer.append(LRU_KNN(buffer_size, latent_dim, 'game'))
def main(args):
#network = importlib.import_module(args.model_def, 'inception_v3')
network = importlib.import_module(args.model_def)
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir)
if not os.path.isdir(
log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
if not os.path.isdir(
model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
with open(os.path.join(model_dir, 'args.txt'), 'w') as f:
for arg in vars(args):
f.write(arg + ' ' + str(getattr(args, arg)) + '\n')
# Store some git revision info in a text file in the log directory
src_path, _ = os.path.split(os.path.realpath(__file__))
facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv))
np.random.seed(seed=args.seed)
#train_set = facenet.get_dataset(args.data_dir)
train_set = facenet.get_dataset_with_enhanced(args.data_dir)
nrof_classes = len(train_set)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
pretrained_model = None
if args.pretrained_model:
pretrained_model = os.path.expanduser(args.pretrained_model)
print('Pre-trained model: %s' % pretrained_model)
if args.lfw_dir:
print('LFW directory: %s' % args.lfw_dir)
# Read the file containing the pairs used for testing
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
lfw_paths, actual_issame = lfw.get_paths(
os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# Get a list of image paths and their labels
image_list, label_list = facenet.get_image_paths_and_labels(train_set)
#image_list, label_list, dataset_ind_flat, dataset_paths = facenet.get_image_paths_and_labels_and_dataset_ind(args.data_dir)
del train_set
# Read data and apply label preserving distortions
image_batch, label_batch = facenet.read_and_augument_data(
image_list,
label_list,
args.image_size,
args.batch_size,
args.max_nrof_epochs,
random_rotate=args.random_rotate,
random_crop=args.random_crop,
random_flip=args.random_flip,
nrof_preprocess_threads=args.nrof_preprocess_threads,
padding_size=args.padding_size,
patch_type=args.patch_type)
#image_batch, label_batch = facenet.read_and_augument_data_reduced(image_list, label_list, dataset_ind_flat, dataset_paths, args.image_size,
# args.batch_size, args.max_nrof_epochs, args.random_rotate,args.random_crop, args.random_flip, args.nrof_preprocess_threads,args.padding_size,args.patch_type)
#nrof_classes = np.max(label_list)+1
print('Total number of classes: %d' % nrof_classes)
print('Total number of examples: %d' % len(image_list))
# Node for input images
image_batch = tf.identity(image_batch, name='input')
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Placeholder for keep probability
keep_probability_placeholder = tf.placeholder(tf.float32,
name='keep_prob')
# Build the inference graph
# prelogits = network.inference(image_batch, keep_probability_placeholder,
# phase_train=phase_train_placeholder, weight_decay=args.weight_decay)
batch_norm_params = {
# Decay for the moving averages
'decay': 0.995,
# epsilon to prevent 0s in variance
'epsilon': 0.001,
# force in-place updates of mean and variance estimates
'updates_collections': None,
# Moving averages ends up in the trainable variables collection
'variables_collections': [tf.GraphKeys.TRAINABLE_VARIABLES],
# Only update statistics during training mode
'is_training': phase_train_placeholder
}
#prelogits, _ = network.inception_v3(image_batch, num_classes=len(train_set),is_training=True)
prelogits, _ = network.inference(image_batch,
args.keep_probability,
phase_train=phase_train_placeholder,
weight_decay=args.weight_decay)
#prelogits = tf.identity(prelogits, name="prelogits")
bottleneck = _fully_connected(prelogits,
args.embedding_size,
name='pre_embedding')
#bottleneck = tf.nn.l2_normalize(bottleneck, dim=1,name='embedding')
logits = _fully_connected_classifier(bottleneck,
nrof_classes,
name='logits')
"""
bottleneck = slim.fully_connected(prelogits, args.embedding_size, activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
weights_regularizer=slim.l2_regularizer(args.weight_decay),
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
scope='Bottleneck', reuse=False)
logits = slim.fully_connected(bottleneck, len(train_set), activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
weights_regularizer=slim.l2_regularizer(args.weight_decay),
scope='Logits', reuse=False)
logits = tf.identity(logits, name="logits")
"""
# Add DeCov regularization loss
if args.decov_loss_factor > 0.0:
logits_decov_loss = facenet.decov_loss(
logits) * args.decov_loss_factor
tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES,
logits_decov_loss)
# Add center loss
update_centers = tf.no_op('update_centers')
if args.center_loss_factor > 0.0:
prelogits_center_loss, update_centers = facenet.center_loss(
bottleneck, label_batch, args.center_loss_alfa, nrof_classes)
tf.add_to_collection(
tf.GraphKeys.REGULARIZATION_LOSSES,
prelogits_center_loss * args.center_loss_factor)
#embeddings = tf.nn.l2_normalize(bottleneck, 1, 1e-10, name='embeddings')
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the average cross entropy loss across the batch
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=label_batch,
logits=logits,
name='cross_entropy_per_example')
cross_entropy_mean = tf.reduce_mean(cross_entropy,
name='cross_entropy')
"""
# Multi-label loss: sigmoid loss
sigmoid_loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=label_batch, logits=logits, name='sigmoid_loss_per_example')
sigmoid_loss_mean = tf.reduce_mean(sigmoid_loss, name='sigmoid_loss')
"""
tf.add_to_collection('losses', cross_entropy_mean)
# Calculate the total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([cross_entropy_mean] + regularization_losses,
name='total_loss')
#total_loss = tf.add_n([cross_entropy_mean], name='total_loss')
# prediction
prediction = tf.argmax(logits, axis=1, name='prediction')
acc = slim.metrics.accuracy(predictions=tf.cast(prediction,
dtype=tf.int32),
labels=tf.cast(label_batch,
dtype=tf.int32))
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op = facenet.train(total_loss, global_step, args.optimizer,
learning_rate, args.moving_average_decay,
tf.global_variables())
# Create a saver
# save_variables = list(set(tf.all_variables())-set([w])-set([b]))
save_variables = tf.trainable_variables()
saver = tf.train.Saver(save_variables, max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
# sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
tf.train.start_queue_runners(sess=sess)
with sess.as_default():
if pretrained_model:
saver.restore(sess, pretrained_model)
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, epoch, phase_train_placeholder,
learning_rate_placeholder, keep_probability_placeholder,
global_step, total_loss, acc, train_op, summary_op,
summary_writer, regularization_losses,
args.learning_rate_schedule_file, update_centers)
# Evaluate on LFW
if args.lfw_dir:
start_time = time.time()
_, _, accuracy, val, val_std, far = lfw.validate(
sess,
lfw_paths,
actual_issame,
args.seed,
args.batch_size,
image_batch,
phase_train_placeholder,
keep_probability_placeholder,
embeddings,
nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' %
(np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' %
(val, val_std, far))
lfw_time = time.time() - start_time
# Add validation loss and accuracy to summary
summary = tf.Summary()
#pylint: disable=maybe-no-member
summary.value.add(tag='lfw/accuracy',
simple_value=np.mean(accuracy))
summary.value.add(tag='lfw/val_rate', simple_value=val)
summary.value.add(tag='time/lfw', simple_value=lfw_time)
summary_writer.add_summary(summary, step)
with open(os.path.join(log_dir, 'lfw_result.txt'),
'at') as f:
f.write('%d\t%.5f\t%.5f\n' %
(step, np.mean(accuracy), val))
# Save variables and the metagraph if it doesn't exist already
save_variables_and_metagraph(sess, saver, summary_writer,
model_dir, subdir, step)
return model_dir
[model.cls_loss, model.pred_class], feed_dict=vfeed)
vcls_l, vloc_gt_l, vloc_t1_l, vcls_cor, vloc_gt_cor, vloc_t1_cor = \
sess.run([model.cls_loss, model.loc_loss_gt, model.loc_loss_t1,
model.corrections, model.correct_and_iou_gt, model.correct_and_iou_t1],
feed_dict=vfeed)
cls_loss += vcls_l
loc_gt_loss += vloc_gt_l
loc_t1_loss += vloc_t1_l
cls_corrections.extend(vcls_cor)
loc_gt_corrections.extend(vloc_gt_cor)
loc_t1_corrections.extend(vloc_t1_cor)
val_cls_loss_sum = tf.Summary(value=[
tf.Summary.Value(tag="val_cls_loss", simple_value=cls_loss)
])
summary_writer.add_summary(val_cls_loss_sum, counter)
val_loc_gt_loss_sum = tf.Summary(value=[
tf.Summary.Value(tag="val_loc_gt_loss",
simple_value=loc_gt_loss)
])
summary_writer.add_summary(val_loc_gt_loss_sum, counter)
val_loc_t1_loss_sum = tf.Summary(value=[
tf.Summary.Value(tag="val_loc_t1_loss",
simple_value=loc_t1_loss)
])
summary_writer.add_summary(val_loc_t1_loss_sum, counter)
val_cls_acc = sum(cls_corrections) / len(cls_corrections)
val_cls_acc_sum = tf.Summary(value=[
def _write_eval_dict_to_summary(eval_dict, tag, summary_writer, global_step):
summary = tf.Summary()
for name, result in eval_dict:
summary.value.add(tag=tag + '/' + name, simple_value=result)
summary_writer.add_summary(summary, global_step)
return
def train(self,
max_iter,
train_eval_step,
validation_eval_step,
display_step,
checkpoint_step = None):
# Keep training until reach max iterations
for _ in range (max_iter):
if self.global_step % self.num_batch == 0:
self.data_train ,self.ground_truth_train = self.shuffle(self.data_train, self.ground_truth_train)
batch_idx = self.global_step % self.num_batch
data_idx = np.arange (batch_idx * self.batch_size,
min ((batch_idx+1) * self.batch_size,
self.data_train.shape[0])).astype('int32')
batch_x = self.data_train[data_idx]
batch_y = self.ground_truth_train[data_idx]
if self.global_step % train_eval_step == 0:
print("Training: " + str(self.global_step))
eval_result = self.evaluate_model(self.model, self.sess, batch_x, batch_y)
#summary np.array
auc_summary_str_train = tf.Summary(value = [
tf.Summary.Value(tag = 'train/'+key, simple_value = eval_result[key])
for key in eval_result])
self.summary_writer.add_summary(auc_summary_str_train, global_step = self.global_step)
self.summary_writer.flush()
if self.global_step % validation_eval_step == 0:
print("Validation: " + str(self.global_step))
eval_result = self.evaluate_model(self.model, self.sess, self.data_validation, self.ground_truth_validation)
#summary np.array
auc_summary_str_valid = tf.Summary(value = [
tf.Summary.Value(tag = 'validation/'+key, simple_value = eval_result[key])
for key in eval_result])
self.summary_writer.add_summary(auc_summary_str_valid, global_step = self.global_step)
self.summary_writer.flush()
#optimization part
_, summary_str, loss, debug_info = self.sess.run((self.model.optimizer, self.summary, self.model.cost, self.model.debug_info),
feed_dict={self.model.x: batch_x,
self.model.y: batch_y})
#print debug_info
self.summary_writer.add_summary(summary_str, global_step = self.global_step)
self.summary_writer.flush()
if self.global_step % display_step == 0:
print "Minibatch Loss= {:.6f}".format(loss)
if checkpoint_step is not None and self.global_step % checkpoint_step == 0:
self.save_model(self.checkpoint_path)
self.global_step += 1
print " Optimization Finished!"
def main():
experiment_dir = os.path.dirname(os.path.abspath(__file__))
# generating the dataset
X_train, X_val, y_train, y_val = gen_dataset(config.op, config.op_sym, config.training_size, config.digits)
# define input placeholders
with tf.name_scope('inputs'):
input_seq = tf.placeholder(tf.float32, [None, config.maxlen, config.numbers_alphabet_size + 2], name='input_seq') # tensor of shape <batch_size, seq_len, embedding size>
expected_ouput_seq = tf.placeholder(tf.float32, [None, config.maxlen, config.numbers_alphabet_size + 1], name='ouput_seq') # tensor of shape <batch_size, seq_len, numbers_alphabet_size>
# construct layers
nn_output_probs = construct_layers(input_seq)
nn_ouput_probs_rsh = tf.reshape(nn_output_probs, [-1, config.numbers_alphabet_size + 1])
expected_ouput_seq_rsh = tf.reshape(expected_ouput_seq, [-1, config.numbers_alphabet_size + 1])
# define loss
with tf.name_scope('loss'):
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=nn_ouput_probs_rsh, labels=expected_ouput_seq_rsh))
#tf.losses.softmax_cross_entropy(onehot_labels=expected_ouput_seq_rsh, logits=nn_ouput_probs_rsh)
loss_summary = tf.summary.scalar('loss', loss)
# define accuracy
with tf.name_scope('accuracy'):
correct_prediction = tf.equal(tf.argmax(expected_ouput_seq_rsh, 1), tf.argmax(nn_ouput_probs_rsh, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
accuracy_summary = tf.summary.scalar('accuracy', accuracy)
# optimization
optimizer = tf.train.AdamOptimizer(config.lr)
global global_step
global_step = tf.train.get_or_create_global_step()
train_op = slim.learning.create_train_op(loss, optimizer, global_step=global_step)
# config magic
tf_config = tf.ConfigProto(log_device_placement = False)
tf_config.gpu_options.allow_growth = True
tf_config.gpu_options.allocator_type = 'BFC'
try:
with tf.train.MonitoredTrainingSession(checkpoint_dir=experiment_dir,
save_checkpoint_secs=300,
save_summaries_steps=200, config=tf_config) as sess:
global_step_init = get_global_step_init(experiment_dir) #TODO
if global_step_init != 0:
print('Last run was aborted on global_step_init :{}'.format(global_step_init))
else:
print('Previous runs not found (You are begining this experiment).')
for inputs, targets in utils.iterate_minibatches_global(X_train, y_train, batchsize=config.batch_size, start_it=global_step_init, iters=config.iters):
train_loss = sess.run([train_op, loss, accuracy], feed_dict={input_seq : inputs, expected_ouput_seq : targets})
gs = sess.run(global_step)
if gs % config.print_loss_every == 0:
print("Step = {}; Train loss: {}".format(gs, train_loss))
if gs % config.calc_val_loss_every == 0:
val_loss, val_accuracy = calc_validation_loss(sess, loss, accuracy, input_seq, expected_ouput_seq, X_val, y_val)
val_loss_summary = tf.Summary()
val_loss_summary.value.add(tag="loss/val_loss", simple_value=val_loss)
val_loss_summary.value.add(tag="accuracy/val_accuracy", simple_value=val_accuracy)
sess._hooks[1]._summary_writer.add_summary(val_loss_summary, gs)
print("=========== Step = {}; Val loss: {}; Val accuracy: {}".format(gs, val_loss, val_accuracy))
except KeyboardInterrupt:
print('Train process was interrupted')
print('Done')
def scalar_summary(self, tag, value, step):
summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value)])
self.writer.add_summary(summary, step)
def evaluate(evalDataSet, time, model_time, name='train'):
with tf.Graph().as_default() as g, tf.device('/cpu:0'):
# Placeholders for input, output and dropout
input_x = tf.placeholder(tf.int32, [None, OPTION.SEQUENCE_LEN],
name="input_x")
features_before = tf.placeholder(tf.float32, [None, model_time, None],
name="features_before")
textcnn = TextCNNpn_model.Model(
sequence_length=OPTION.SEQUENCE_LEN,
num_classes=OPTION.NUM_CLASSES,
vocab_size=None,
embedding_size=OPTION.EMEBEDDING_DIMENSION,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
Word2vec=True,
Trainable=False)
# inference model.
_, features = textcnn.inference(input_x,
features_before,
OPTION.EVAL_BATCH_SIZE,
eval_data=True)
# get model paramaters
# paramaters_list_reshape = textcnn.get_paramaters_list_reshape()
# Restore the moving average version of the learned variables for eval. # ?????????????????????????
variable_averages = tf.train.ExponentialMovingAverage(
OPTION.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(OPTION.EVAL_DIR, g)
# Start running operations on the Graph. allow_soft_placement must be set to
# True to build towers on GPU, as some of the ops do not have GPU implementations.
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)) as sess:
if os.path.exists(
os.path.join(OPTION.EVAL_DIR, 'model.ckpt-best.index')):
# new_saver = tf.train.import_meta_graph(
# os.path.join(OPTION.TRAIN_DIR, 'model.ckpt-' + checkpoint + '.meta'))
saver.restore(sess,
os.path.join(OPTION.EVAL_DIR, 'model.ckpt-best'))
else:
print('No checkpoint file found')
return
max_steps_per_epoch = int(
math.ceil(evalDataSet.get_dataset_size() /
float(OPTION.EVAL_BATCH_SIZE)))
total_predicted_value = []
for step in range(max_steps_per_epoch):
test_data, test_features = evalDataSet.next_batch(
OPTION.EVAL_BATCH_SIZE)
predicted_value = sess.run(features,
feed_dict={
input_x: test_data,
features_before: test_features
})
total_predicted_value.append(predicted_value)
# test_data, test_label = evalDataSet.next_batch(OPTION.EVAL_BATCH_SIZE)
summary = tf.Summary()
# summary.ParseFromString(sess.run(summary_op, feed_dict={input_x: test_data, input_y: test_label}))
total_predicted_value = np.concatenate(total_predicted_value,
axis=0)
total_predicted_value = total_predicted_value[0:evalDataSet.
get_dataset_size()]
assert evalDataSet.get_dataset_size(
) == total_predicted_value.shape[0], 'sample_count error!'
detail_filename = os.path.join(
OPTION.MODELPARA_DIR,
'features_%s_%d_%d' % (name, time, model_time))
if os.path.exists(detail_filename):
os.remove(detail_filename)
np.savetxt(detail_filename, total_predicted_value, fmt='%.4f')
def attack(self, X: np.ndarray, Y: np.ndarray, target_class: list = None, threshold: float = 0.,
verbose: bool = False, print_every: int = 100, log_every: int = 100) \
-> Tuple[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
"""
Find a counterfactual (CF) for instance X using a fast iterative shrinkage-thresholding algorithm (FISTA).
Parameters
----------
X
Instance to attack
Y
Labels for X as one-hot-encoding
target_class
List with target classes used to find closest prototype. If None, the nearest prototype
except for the predict class on the instance is used.
threshold
Threshold level for the ratio between the distance of the counterfactual to the prototype of the
predicted class for the original instance over the distance to the prototype of the predicted class
for the counterfactual. If the trust score is below the threshold, the proposed counterfactual does
not meet the requirements.
verbose
Print intermediate results of optimization if True
print_every
Print frequency if verbose is True
log_every
Tensorboard log frequency if write directory is specified
Returns
-------
Overall best attack and gradients for that attack.
"""
# make sure nb of instances in X equals batch size
assert self.batch_size == X.shape[0]
def compare(x: Union[float, int, np.ndarray], y: int) -> bool:
"""
Compare predictions with target labels and return whether counterfactual conditions hold.
Parameters
----------
x
Predicted class probabilities or labels
y
Target or predicted labels
Returns
-------
Bool whether counterfactual conditions hold.
"""
if not isinstance(x, (float, int, np.int64)):
x = np.copy(x)
x[y] += self.kappa
x = np.argmax(x)
return x != y
# define target classes for prototype if not specified yet
if target_class is None and self.enc_or_kdtree:
target_class = list(range(self.classes))
target_class.remove(np.argmax(Y, axis=1))
if verbose:
print('Predicted class: {}'.format(np.argmax(Y, axis=1)))
print('Target classes: {}'.format(target_class))
# find closest prototype in the target class list
dist_proto = {}
if self.enc_model:
for k, v in self.class_proto.items():
if k not in target_class:
continue
dist_proto[k] = np.linalg.norm(self.enc.predict(X) - v)
elif self.use_kdtree:
self.class_proto = {}
for c in range(self.classes):
if c not in target_class:
continue
dist_c, idx_c = self.kdtrees[c].query(X, k=1)
dist_proto[c] = dist_c[0]
self.class_proto[c] = self.X_by_class[c][idx_c[0]]
if self.enc_or_kdtree:
self.id_proto = min(dist_proto, key=dist_proto.get)
proto_val = self.class_proto[self.id_proto]
if verbose:
print('Prototype class: {}'.format(self.id_proto))
else: # no prototype loss term used
proto_val = np.zeros(self.shape_enc)
# set the lower and upper bounds for the constant 'c' to scale the attack loss term
# these bounds are updated for each c_step iteration
const_lb = np.zeros(self.batch_size)
const = np.ones(self.batch_size) * self.c_init
const_ub = np.ones(self.batch_size) * 1e10
# init values for the best attack instances for each instance in the batch
overall_best_dist = [1e10] * self.batch_size
overall_best_attack = [np.zeros(self.shape[1:])] * self.batch_size
overall_best_grad = (np.zeros(self.shape), np.zeros(self.shape))
# keep track of counterfactual evolution
self.cf_global = {i: [] for i in range(self.c_steps)} # type: dict
# iterate over nb of updates for 'c'
for _ in range(self.c_steps):
# init variables
self.sess.run(self.init)
# reset current best distances and scores
current_best_dist = [1e10] * self.batch_size
current_best_proba = [-1] * self.batch_size
# assign variables for the current iteration
self.sess.run(
self.setup, {
self.assign_orig: X,
self.assign_target: Y,
self.assign_const: const,
self.assign_adv: X,
self.assign_adv_s: X,
self.assign_target_proto: proto_val
})
X_der_batch, X_der_batch_s = [], []
for i in range(self.max_iterations):
# numerical gradients
grads_num = np.zeros(self.shape)
grads_num_s = np.zeros(self.shape)
# check if numerical gradient computation is needed
if not self.model and (self.c_init != 0. or self.c_steps > 1):
X_der = self.adv.eval(session=self.sess)
X_der_s = self.adv_s.eval(session=self.sess)
X_der_batch.append(X_der)
X_der_batch_s.append(X_der_s)
if i % self.update_num_grad == 0 and i > 0: # compute numerical gradients
c = self.const.eval(session=self.sess)
X_der_batch = np.concatenate(X_der_batch)
X_der_batch_s = np.concatenate(X_der_batch_s)
grads_num = self.get_gradients(X_der_batch, Y) * c
grads_num_s = self.get_gradients(X_der_batch_s, Y) * c
# clip gradients
grads_num = np.clip(grads_num, self.clip[0],
self.clip[1])
grads_num_s = np.clip(grads_num_s, self.clip[0],
self.clip[1])
X_der_batch, X_der_batch_s = [], []
# compute and clip gradients defined in graph
grads_vars_graph = self.sess.run(self.compute_grads)
grads_graph = [g for g, _ in grads_vars_graph][0]
grads_graph = np.clip(grads_graph, self.clip[0], self.clip[1])
# apply gradients
grads = grads_graph + grads_num_s
self.sess.run(self.apply_grads,
feed_dict={self.grad_ph: grads})
# update adv and adv_s with perturbed instances
self.sess.run([
self.adv_updater, self.adv_updater_s, self.delta,
self.delta_s
])
# compute overall and attack loss, L1+L2 loss, prediction probabilities
# on perturbed instances and new adv
# L1+L2 and prediction probabilities used to see if adv is better than the current best adv under FISTA
if self.model:
loss_tot, loss_attack, loss_l1_l2, pred_proba, adv = \
self.sess.run([self.loss_total, self.loss_attack, self.l1_l2, self.pred_proba, self.adv])
else:
X_der = self.adv.eval(
session=self.sess) # get updated perturbed instances
pred_proba = self.predict(X_der)
# compute attack, total and L1+L2 losses as well as new perturbed instance
loss_attack = self.loss_fn(pred_proba, Y)
feed_dict = {self.loss_attack: loss_attack}
loss_tot, loss_l1_l2, adv = self.sess.run(
[self.loss_total, self.l1_l2, self.adv],
feed_dict=feed_dict)
if i % log_every == 0 or i % print_every == 0:
loss_l2, loss_l1, loss_ae, loss_proto = \
self.sess.run([self.loss_l2, self.loss_l1, self.loss_ae, self.loss_proto])
target_proba = np.sum(pred_proba * Y)
nontarget_proba_max = np.max((1 - Y) * pred_proba)
loss_opt = loss_l1_l2 + loss_attack + loss_ae + loss_proto
if i % log_every == 0 and self.writer is not None:
lr, zt, gs = self.sess.run(
[self.learning_rate, self.zt, self.global_step])
# add values and images to tensorboard
summary = tf.Summary()
summary.value.add(tag='loss/Optimized',
simple_value=loss_opt)
summary.value.add(tag='loss/Total', simple_value=loss_tot)
summary.value.add(tag='loss/L1', simple_value=loss_l1)
summary.value.add(tag='loss/L2', simple_value=loss_l2)
summary.value.add(tag='loss/AutoEncoder',
simple_value=loss_ae)
summary.value.add(tag='loss/ClassPrototype',
simple_value=loss_proto)
summary.value.add(tag='loss/PredScale',
simple_value=const[0])
summary.value.add(tag='loss/PredLoss',
simple_value=loss_attack)
summary.value.add(tag='training/lr', simple_value=lr)
summary.value.add(tag='training/z', simple_value=zt)
summary.value.add(tag='training/GlobalStep',
simple_value=gs)
self.writer.add_summary(summary)
self.writer.flush()
if verbose and i % print_every == 0:
print('\nIteration: {}; Const: {}'.format(i, const[0]))
print('Loss total: {:.3f}, loss attack: {:.3f}'.format(
loss_tot, loss_attack))
print('L2: {:.3f}, L1: {:.3f}, loss AE: {:.3f}'.format(
loss_l2, loss_l1, loss_ae))
print('Loss proto: {:.3f}'.format(loss_proto))
print('Target proba: {:.2f}, max non target proba: {:.2f}'.
format(target_proba, nontarget_proba_max))
print('Gradient graph min/max: {:.3f}/{:.3f}'.format(
grads_graph.min(), grads_graph.max()))
print('Gradient graph mean/abs mean: {:.3f}/{:.3f}'.format(
np.mean(grads_graph), np.mean(np.abs(grads_graph))))
if not self.model:
print(
'Gradient numerical attack min/max: {:.3f}/{:.3f}'.
format(grads_num.min(), grads_num.max()))
print(
'Gradient numerical mean/abs mean: {:.3f}/{:.3f}'.
format(np.mean(grads_num),
np.mean(np.abs(grads_num))))
sys.stdout.flush()
# update best perturbation (distance) and class probabilities
# if beta * L1 + L2 < current best and predicted label is different from the initial label:
# update best current step or global perturbations
for batch_idx, (dist, proba, adv_idx) in enumerate(
zip(loss_l1_l2, pred_proba, adv)):
Y_class = np.argmax(Y[batch_idx])
# calculate trust score
if threshold > 0.:
score = self.score(np.expand_dims(adv_idx, axis=0),
np.argmax(pred_proba), Y_class)
above_threshold = score > threshold
else:
above_threshold = True
# current step
if dist < current_best_dist[batch_idx] and compare(
proba, Y_class) and above_threshold:
current_best_dist[batch_idx] = dist
current_best_proba[batch_idx] = np.argmax(proba)
# global
if dist < overall_best_dist[batch_idx] and compare(
proba, Y_class) and above_threshold:
if verbose:
print('\nNew best counterfactual found!')
overall_best_dist[batch_idx] = dist
overall_best_attack[batch_idx] = adv_idx
overall_best_grad = (grads_graph, grads_num)
self.best_attack = True
self.cf_global[_].append(adv_idx)
# adjust the 'c' constant for the first loss term
for batch_idx in range(self.batch_size):
if (compare(current_best_proba[batch_idx],
np.argmax(Y[batch_idx]))
and current_best_proba[batch_idx] != -1):
# want to refine the current best solution by putting more emphasis on the regularization terms
# of the loss by reducing 'c'; aiming to find a perturbation closer to the original instance
const_ub[batch_idx] = min(const_ub[batch_idx],
const[batch_idx])
if const_ub[batch_idx] < 1e9:
const[batch_idx] = (const_lb[batch_idx] +
const_ub[batch_idx]) / 2
else:
# no valid current solution; put more weight on the first loss term to try and meet the
# prediction constraint before finetuning the solution with the regularization terms
const_lb[batch_idx] = max(
const_lb[batch_idx],
const[batch_idx]) # update lower bound to constant
if const_ub[batch_idx] < 1e9:
const[batch_idx] = (const_lb[batch_idx] +
const_ub[batch_idx]) / 2
else:
const[batch_idx] *= 10
# return best overall attack
best_attack = np.concatenate(overall_best_attack, axis=0)
if best_attack.shape != self.shape:
best_attack = np.expand_dims(best_attack, axis=0)
return best_attack, overall_best_grad
def train(args, sess, dataset, epoch, image_paths_placeholder, labels_placeholder, labels_batch,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step,
embeddings, loss, train_op, summary_op, summary_writer, learning_rate_schedule_file,
embedding_size, anchor, positive, negative, triplet_loss):
batch_number = 0
if args.learning_rate>0.0:
lr = args.learning_rate
else:
lr = facenet.get_learning_rate_from_file(learning_rate_schedule_file, epoch)
while batch_number < args.epoch_size:
# Sample people randomly from the dataset
image_paths, num_per_class = sample_people(dataset, args.people_per_batch, args.images_per_person)
print('Running forward pass on sampled images: ', end='')
start_time = time.time()
nrof_examples = args.people_per_batch * args.images_per_person
labels_array = np.reshape(np.arange(nrof_examples),(-1,3))
image_paths_array = np.reshape(np.expand_dims(np.array(image_paths),1), (-1,3))
sess.run(enqueue_op, {image_paths_placeholder: image_paths_array, labels_placeholder: labels_array})
emb_array = np.zeros((nrof_examples, embedding_size))
nrof_batches = int(np.ceil(nrof_examples / args.batch_size))
for i in range(nrof_batches):
batch_size = min(nrof_examples-i*args.batch_size, args.batch_size)
emb, lab = sess.run([embeddings, labels_batch], feed_dict={batch_size_placeholder: batch_size,
learning_rate_placeholder: lr, phase_train_placeholder: True})
emb_array[lab,:] = emb
print('%.3f' % (time.time()-start_time))
# Select triplets based on the embeddings
print('Selecting suitable triplets for training')
triplets, nrof_random_negs, nrof_triplets = select_triplets(emb_array, num_per_class,
image_paths, args.people_per_batch, args.alpha)
selection_time = time.time() - start_time
print('(nrof_random_negs, nrof_triplets) = (%d, %d): time=%.3f seconds' %
(nrof_random_negs, nrof_triplets, selection_time))
# Perform training on the selected triplets
nrof_batches = int(np.ceil(nrof_triplets*3/args.batch_size))
triplet_paths = list(itertools.chain(*triplets))
labels_array = np.reshape(np.arange(len(triplet_paths)),(-1,3))
triplet_paths_array = np.reshape(np.expand_dims(np.array(triplet_paths),1), (-1,3))
sess.run(enqueue_op, {image_paths_placeholder: triplet_paths_array, labels_placeholder: labels_array})
nrof_examples = len(triplet_paths)
train_time = 0
i = 0
emb_array = np.zeros((nrof_examples, embedding_size))
loss_array = np.zeros((nrof_triplets,))
summary = tf.Summary()
step = 0
while i < nrof_batches:
start_time = time.time()
batch_size = min(nrof_examples-i*args.batch_size, args.batch_size)
feed_dict = {batch_size_placeholder: batch_size, learning_rate_placeholder: lr, phase_train_placeholder: True}
err, _, step, emb, lab = sess.run([loss, train_op, global_step, embeddings, labels_batch], feed_dict=feed_dict)
emb_array[lab,:] = emb
loss_array[i] = err
duration = time.time() - start_time
print('Epoch: [%d][%d/%d]\tTime %.3f\tLoss %2.3f' %
(epoch, batch_number+1, args.epoch_size, duration, err))
batch_number += 1
i += 1
train_time += duration
summary.value.add(tag='loss', simple_value=err)
# Add validation loss and accuracy to summary
#pylint: disable=maybe-no-member
summary.value.add(tag='time/selection', simple_value=selection_time)
summary_writer.add_summary(summary, step)
return step
def q_learning(env,
sess,
qlearn_estimator,
target_estimator,
num_episodes,
num_epoches,
replay_memory_size=500000,
replay_memory_init_size=50000,
experiment_dir='./log/',
update_target_estimator_every=10000,
discount_factor=0.99,
epsilon_start=1.0,
epsilon_end=0.1,
epsilon_decay_steps=500000,
batch_size=512,
num_label_propagation=20,
num_active_learning=5,
test=0):
"""
Q-Learning algorithm for off-policy TD control using Function Approximation.
Finds the optimal greedy policy while following an epsilon-greedy policy.
Args:
env: The environment.
estimator: Action-Value function estimator
num_episodes: Number of episodes to run for.
discount_factor: Lambda time discount factor.
epsilon: Chance the sample a random action. Float betwen 0 and 1.
epsilon_decay: Each episode, epsilon is decayed by this factor
Returns:
NULL
"""
# 1. Define some useful variable
# To memory
Transition = namedtuple("Transition",
["state", "reward", "next_state", "done"])
# The replay memory
replay_memory = []
# Create directories for checkpoints and summaries
checkpoint_dir = os.path.join(experiment_dir, "checkpoints")
checkpoint_path = os.path.join(checkpoint_dir, "model")
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
# Load a previous checkpoint if we find one
saver = tf.train.Saver()
latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
if latest_checkpoint:
print("Loading model checkpoint {}...\n".format(latest_checkpoint))
saver.restore(sess, latest_checkpoint)
if test:
return
# Get the time step
total_t = sess.run(tf.contrib.framework.get_global_step())
# The epsilon decay schedule
epsilons = np.linspace(epsilon_start, epsilon_end, epsilon_decay_steps)
# The policy we're following
policy = make_epsilon_greedy_policy(qlearn_estimator, env.action_space_n)
num_label = 0
# 2. Populate the replay memory with initial experience by SVM
popu_time = time.time()
# warm up with active learning
print('Warm up starting...')
outliers_fraction = 0.01
data_train = []
for num in range(env.datasetsize):
env.reset()
# remove time window
data_train.extend(env.states_list)
# Isolation Forest model
model = WarmUp().warm_up_isolation_forest(outliers_fraction, data_train)
# label propagation model
lp_model = label_propagation.LabelSpreading()
for t in itertools.count():
env.reset()
data = np.array(env.states_list).transpose(2, 0, 1).reshape(
2, -1)[0].reshape(-1, n_steps)[:, -1].reshape(-1, 1)
anomaly_score = model.decision_function(data) # [-0.5, 0.5]
pred_score = [-1 * s + 0.5 for s in anomaly_score] # [0, 0.5]
#threshold = stats.scoreatpercentile(pred_score, 100 * outliers_fraction)
warm_samples = np.argsort(pred_score)[:5]
warm_samples = np.append(warm_samples, np.argsort(pred_score)[-5:])
# al.label(warm_samples)
# retrieve input for label propagation
state_list = np.array(env.states_list).transpose(2, 0, 1)[0]
label_list = [-1] * len(state_list) # remove labels
for sample in warm_samples:
# pick up a state from warm_up samples
state = env.states_list[sample]
# update the cursor
env.timeseries_curser = sample + n_steps
action_probs = policy(
state, epsilons[min(total_t, epsilon_decay_steps - 1)])
action = np.random.choice(np.arange(len(action_probs)),
p=action_probs)
# mark the sample to labeled
env.timeseries['label'][env.timeseries_curser] = env.timeseries[
'anomaly'][env.timeseries_curser]
num_label += 1
# retrieve label for propagation
label_list[sample] = int(
env.timeseries['anomaly'][env.timeseries_curser])
next_state, reward, done, _ = env.step(action)
replay_memory.append(Transition(state, reward, next_state, done))
# label propagation main process:
unlabeled_indices = [i for i, e in enumerate(label_list) if e == -1]
label_list = np.array(label_list)
lp_model.fit(state_list, label_list)
pred_entropies = stats.distributions.entropy(
lp_model.label_distributions_.T)
# select up to N samples that is most certain about
certainty_index = np.argsort(pred_entropies)
certainty_index = certainty_index[np.in1d(
certainty_index, unlabeled_indices)][:num_label_propagation]
# give them pseudo labels
for index in certainty_index:
pseudo_label = lp_model.transduction_[index]
env.timeseries['label'][index + n_steps] = pseudo_label
if len(replay_memory) >= replay_memory_init_size:
break
'''
# warm up without active learning
state = env.reset()
while env.datasetidx > env.datasetrng * validation_separate_ratio:
env.reset()
print('double reset')
for i in range(replay_memory_init_size):
action_probs = policy(state, epsilons[min(total_t, epsilon_decay_steps - 1)])
action = np.random.choice(np.arange(len(action_probs)), p=action_probs)
# mark the sample to labeled
env.timeseries['labeled'][env.timeseries_curser] = 1
num_label += 1
next_state, reward, done, _ = env.step(action)
replay_memory.append(Transition(state, reward, next_state, done))
if done:
state = env.reset()
while env.datasetidx > env.datasetrng * validation_separate_ratio:
env.reset()
print('double reset')
else:
state = next_state[action]
'''
popu_time = time.time() - popu_time
print("Populating replay memory with time {}".format(popu_time))
# 3. Start the main loop2
dict = {}
for i_episode in range(num_episodes):
# Save the current checkpoint
if i_episode % 50 == 49:
print("Save checkpoint in episode {}/{}".format(
i_episode + 1, num_episodes))
saver.save(tf.get_default_session(), checkpoint_path)
per_loop_time1 = time.time()
# Reset the environment
state = env.reset()
while env.datasetidx > env.datasetrng * validation_separate_ratio:
env.reset()
print('double reset')
# Active learning:
# if a AL is needed
# index of already labeled samples of this TS
labeled_index = [
i for i, e in enumerate(env.timeseries['label']) if e != -1
]
# transform to match state_list
labeled_index = [item for item in labeled_index if item >= 25]
labeled_index = [item - n_steps for item in labeled_index]
al = active_learning(env=env,
N=num_active_learning,
strategy='margin_sampling',
estimator=qlearn_estimator,
already_selected=labeled_index)
# find the samples need to be labeled by human
al_samples = al.get_samples()
print('labeling samples: ' + str(al_samples) + 'in env' +
str(env.datasetidx))
# al.label(al_samples)
# add the new labeled samples
labeled_index.extend(al_samples)
num_label += len(al_samples)
# retrieve input for label propagation
state_list = np.array(env.states_list).transpose(2, 0, 1)[0]
label_list = np.array(env.timeseries['label'][n_steps:])
for new_sample in al_samples:
label_list[new_sample] = env.timeseries['anomaly'][n_steps +
new_sample]
env.timeseries['label'][
n_steps + new_sample] = env.timeseries['anomaly'][n_steps +
new_sample]
for samples in labeled_index:
env.timeseries_curser = samples + n_steps
# 3.1 Some Preprocess
# Epsilon for this time step
epsilon = epsilons[min(total_t, epsilon_decay_steps - 1)]
state = env.states_list[samples]
# 3.2 The main work
# Choose an action to take
action_probs = policy(state, epsilon)
action = np.random.choice(np.arange(len(action_probs)),
p=action_probs)
# Take a step
next_state, reward, done, _ = env.step(action)
# 3.3 Control replay memory
if len(replay_memory) == replay_memory_size:
replay_memory.pop(0)
replay_memory.append(Transition(state, reward, next_state, done))
# label propagation main process:
unlabeled_indices = [i for i, e in enumerate(label_list) if e == -1]
label_list = np.array(label_list)
lp_model.fit(state_list, label_list)
pred_entropies = stats.distributions.entropy(
lp_model.label_distributions_.T)
# select up to N samples that is most certain about
certainty_index = np.argsort(pred_entropies)
certainty_index = certainty_index[np.in1d(
certainty_index, unlabeled_indices)][:num_label_propagation]
# give them pseudo labels
for index in certainty_index:
pseudo_label = lp_model.transduction_[index]
env.timeseries['label'][index + n_steps] = pseudo_label
'''
ori_idx = env.datasetidx
if env.datasetidx >= 0:
if dict.has_key(env.datasetidx) is False:
already_selected = []
dict[env.datasetidx] = already_selected
al = active_learning(env=env, N=28, strategy='margin_sampling',
estimator=qlearn_estimator, already_selected=dict[env.datasetidx])
active_samples = al.get_samples()
#active_samples = al.get_samples_by_score(threshold=1.5)
# Label the samples
# al.label(active_samples)
# Add new-labeled samples
dict[env.datasetidx].extend(active_samples)
print 'add labeled samples: ' + str(active_samples) + 'in env ' + str(env.datasetidx)
# One step in the environment
for ids in dict.keys():
env.reset_to(ids)
print 'Training on ' + str(ids)
for samples in dict[ids]:
env.timeseries_curser = samples + n_steps
# 3.1 Some Preprocess
# Epsilon for this time step
epsilon = epsilons[min(total_t, epsilon_decay_steps - 1)]
state = env.states_list[samples]
# 3.2 The main work
# Choose an action to take
action_probs = policy(state, epsilon)
action = np.random.choice(np.arange(len(action_probs)), p=action_probs)
# Take a step
if env.timeseries['labeled'][env.timeseries_curser] == 0:
env.timeseries['labeled'][env.timeseries_curser] = 1
num_label += 1
next_state, reward, done, _ = env.step(action)
# 3.3 Control replay memory
if len(replay_memory) == replay_memory_size:
replay_memory.pop(0)
replay_memory.append(Transition(state, reward, next_state, done))
print 'num_label: ' + str(num_label)
env.datasetidx = ori_idx
else:
# One step in the environment
for t in itertools.count():
# 3.1 Some Preprocess
# Epsilon for this time step
epsilon = epsilons[min(total_t, epsilon_decay_steps - 1)]
# 3.2 The main work
# Choose an action to take
action_probs = policy(state, epsilon)
action = np.random.choice(np.arange(len(action_probs)), p=action_probs)
# Take a step
next_state, reward, done, _ = env.step(action)
# 3.3 Control replay memory
if len(replay_memory) == replay_memory_size:
replay_memory.pop(0)
# if the sample for this step is unlabeled, skip
if env.timeseries['labeled'][env.timeseries_curser] != 0:
replay_memory.append(Transition(state, reward, next_state, done))
print 'memory stored'
else:
print 'unlabeled -> skip'
if done:
break
state = next_state[action]
'''
per_loop_time2 = time.time()
# Update the model
for i_epoch in range(num_epoches):
# Add epsilon to Tensorboard
if qlearn_estimator.summary_writer:
episode_summary = tf.Summary()
qlearn_estimator.summary_writer.add_summary(
episode_summary, total_t)
# Update the target estimator
if total_t % update_target_estimator_every == 0:
copy_model_parameters(sess, qlearn_estimator, target_estimator)
print("\nCopied model parameters to target network.\n")
# Sample a minibatch from the replay memory
samples = random.sample(replay_memory, batch_size)
states_batch, reward_batch, next_states_batch, done_batch = map(
np.array, zip(*samples))
if discount_factor > 0:
# Calculate q values and targets
next_states_batch = np.squeeze(
np.split(next_states_batch, 2, axis=1))
next_states_batch0 = next_states_batch[0]
next_states_batch1 = next_states_batch[1]
q_values_next0 = target_estimator.predict(
state=next_states_batch0)
q_values_next1 = target_estimator.predict(
state=next_states_batch1)
targets_batch = reward_batch + (discount_factor * np.stack(
(np.amax(q_values_next0,
axis=1), np.amax(q_values_next1, axis=1)),
axis=-1))
else:
targets_batch = reward_batch
# Perform gradient descent update
qlearn_estimator.update(state=states_batch,
target=targets_batch.astype(np.float32))
total_t += 1
# Print out which step we're on, useful for debugging.
per_loop_time_popu = per_loop_time2 - per_loop_time1
per_loop_time_updt = time.time() - per_loop_time2
print("Global step {} @ Episode {}/{}, time: {} + {}".format(
total_t, i_episode + 1, num_episodes, per_loop_time_popu,
per_loop_time_updt))
return
