def main(_):
if not FLAGS.dataset_dir:
raise ValueError('You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
tf_global_step = slim.get_or_create_global_step()
######################
# Select the dataset #
######################
dataset = dataset_factory.get_dataset(
FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir)
num_classes = dataset.num_classes
####################
# Select the model #
####################
network_fn = nets_factory.get_network_fn(
FLAGS.model_name,
num_classes=num_classes,
is_training=False)
##############################################################
# Create a dataset provider that loads data from the dataset #
##############################################################
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
shuffle=False,
common_queue_capacity=2 * FLAGS.batch_size,
common_queue_min=FLAGS.batch_size)
[image, label] = provider.get(['image', 'label'])
#####################################
# Select the preprocessing function #
#####################################
preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name
image_preprocessing_fn = preprocessing_factory.get_preprocessing(
preprocessing_name,
is_training=False)
eval_image_size = FLAGS.eval_image_size or network_fn.default_image_size
image, label = image_preprocessing_fn(image, eval_image_size, eval_image_size,
label=label)
images, labels = tf.train.batch(
[image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size)
labels_one_hot = slim.one_hot_encoding(labels, num_classes)
####################
# Define the model #
####################
logits, _, _ = network_fn(images)
logits = tf.image.resize_bilinear(logits,
size=(eval_image_size, eval_image_size), align_corners=True)
labels_one_hot = tf.reshape(labels_one_hot, logits.get_shape())
my_loss = tf.losses.softmax_cross_entropy(
labels_one_hot, logits, label_smoothing=0.0)
variables_to_restore = slim.get_variables_to_restore()
predictions = tf.argmax(logits, 3)
labels = tf.squeeze(labels)
predictions = tf.squeeze(predictions)
predictions = tf.reshape(predictions, [-1, ])
labels = tf.reshape(labels, [-1, ])
indices = tf.squeeze(tf.where(tf.not_equal(labels, 0)), 1)
labels = tf.cast(tf.gather(labels, indices), tf.int32)
predictions = tf.gather(predictions, indices)
predictions = tf.add(predictions, tf.constant(1, dtype=tf.int64))
# Define the metrics:
pixel_acc = tf.contrib.metrics.streaming_accuracy(predictions, labels)
if FLAGS.dataset_name == 'ade20k':
mean_iou = tf.contrib.metrics.streaming_mean_iou(predictions, labels, num_classes + 1)
else:
mean_iou = tf.contrib.metrics.streaming_mean_iou(predictions, labels, num_classes)
names_to_values, names_to_updates = \
tf.contrib.metrics.aggregate_metric_map({
'Pixel_ACC': pixel_acc,
'IOU': mean_iou
})
# Print the summaries to screen.
for name, value in names_to_values.items():
summary_name = 'eval/%s' % name
op = tf.summary.scalar(summary_name, value, collections=[])
op = tf.Print(op, [value], summary_name)
tf.add_to_collection(tf.GraphKeys.SUMMARIES, op)
num_batches = math.ceil(dataset.num_samples / float(FLAGS.batch_size))
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
tf.logging.info('Evaluating %s' % checkpoint_path)
session_config = tf.ConfigProto()
session_config.gpu_options.allow_growth = True
my_loss_t = slim.evaluation.evaluate_once(
session_config=session_config,
master='',
checkpoint_path=checkpoint_path,
logdir=FLAGS.eval_dir,
num_evals=num_batches,
eval_op=list(names_to_updates.values()),
variables_to_restore=variables_to_restore,
final_op=[my_loss])
print(my_loss_t)
def main(_):
if not FLAGS.dataset_dir:
raise ValueError('You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.DEBUG)
with tf.Graph().as_default():
deploy_config = model_deploy.DeploymentConfig(
num_clones=FLAGS.num_clones,
clone_on_cpu=FLAGS.clone_on_cpu,
replica_id=FLAGS.task,
num_replicas=FLAGS.worker_replicas,
num_ps_tasks=FLAGS.num_ps_tasks)
# Create global_step
with tf.device(deploy_config.variables_device()):
global_step = slim.create_global_step()
net = model_cmc.Model()
with tf.device(deploy_config.inputs_device()):
if (FLAGS.model == 'unet'):
batch_queue = \
load_batch.get_batch(FLAGS.dataset_dir,
FLAGS.num_readers,
FLAGS.batch_size,
None,
FLAGS,
file_pattern = FLAGS.file_pattern,
is_training = True,
shuffe = FLAGS.shuffle_data)
elif (FLAGS.model == 'patch'):
batch_queue = \
load_batch_patch.get_batch(FLAGS.dataset_dir,
FLAGS.num_readers,
FLAGS.batch_size,
None,
FLAGS,
file_pattern = FLAGS.file_pattern,
is_training = True,
shuffe = FLAGS.shuffle_data)
elif (FLAGS.model == 'cmc'):
batch_queue = \
load_batch_cmc.get_batch(FLAGS.dataset_dir,
FLAGS.num_readers,
FLAGS.batch_size,
None,
FLAGS,
file_pattern = FLAGS.file_pattern,
is_training = True,
shuffe = FLAGS.shuffle_data)
# =================================================================== #
# Define the model running on every GPU.
# =================================================================== #
def clone_fn(batch_queue):
batch_shape = [1]*3
b_image, label = batch_queue
logits, end_points = net.net(b_image)
# Add loss function.
loss, mean_iou = net.weighted_losses(logits, label)
return end_points, mean_iou
summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES))
clones = model_deploy.create_clones(deploy_config, clone_fn, [batch_queue])
first_clone_scope = deploy_config.clone_scope(0)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, first_clone_scope)
end_points, mean_iou = clones[0].outputs
update_ops.append(mean_iou[1])
#for end_point in end_points:
# x = end_points[end_point]
# summaries.add(tf.summary.histogram('activations/' + end_point, x))
for loss in tf.get_collection('EXTRA_LOSSES',first_clone_scope):
summaries.add(tf.summary.scalar(loss.op.name, loss))
#
#for variable in slim.get_model_variables():
# summaries.add(tf.summary.histogram(variable.op.name, variable))
#################################
# Configure the moving averages #
#################################
if FLAGS.moving_average_decay:
moving_average_variables = slim.get_model_variables()
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, global_step)
else:
moving_average_variables, variable_averages = None, None
#########################################
# Configure the optimization procedure. #
#########################################
with tf.device(deploy_config.optimizer_device()):
learning_rate = tf_utils.configure_learning_rate(FLAGS,
FLAGS.num_samples,
global_step)
optimizer = tf_utils.configure_optimizer(FLAGS, learning_rate)
summaries.add(tf.summary.scalar('learning_rate', learning_rate))
if FLAGS.fine_tune:
gradient_multipliers = pickle.load(open('nets/multiplier_300.pkl','rb'))
else:
gradient_multipliers = None
if FLAGS.moving_average_decay:
# Update ops executed locally by trainer.
update_ops.append(variable_averages.apply(moving_average_variables))
# Variables to train.
variables_to_train = tf_utils.get_variables_to_train(FLAGS)
# and returns a train_tensor and summary_op
total_loss, clones_gradients = model_deploy.optimize_clones(
clones,
optimizer,
var_list=variables_to_train)
# Add total_loss to summary.
summaries.add(tf.summary.scalar('total_loss', total_loss))
if gradient_multipliers:
with ops.name_scope('multiply_grads'):
clones_gradients = slim.learning.multiply_gradients(clones_gradients, gradient_multipliers)
if FLAGS.clip_gradient_norm > 0:
with ops.name_scope('clip_grads'):
clones_gradients = slim.learning.clip_gradient_norms(clones_gradients, FLAGS.clip_gradient_norm)
# Create gradient updates.
grad_updates = optimizer.apply_gradients(clones_gradients,
global_step=global_step)
update_ops.append(grad_updates)
update_op = tf.group(*update_ops)
train_tensor = control_flow_ops.with_dependencies([update_op], total_loss,
name='train_op')
#train_tensor = slim.learning.create_train_op(total_loss, optimizer, gradient_multipliers=gradient_multipliers)
# Add the summaries from the first clone. These contain the summaries
# created by model_fn and either optimize_clones() or _gather_clone_loss().
summaries |= set(tf.get_collection(tf.GraphKeys.SUMMARIES,
first_clone_scope))
# Merge all summaries together.
summary_op = tf.summary.merge(list(summaries), name='summary_op')
# =================================================================== #
# Kicks off the training.
# =================================================================== #
def train_step_fn(session, *args, **kwargs):
# visualizer = Beholder(session=session, logdir=FLAGS.train_dir)
total_loss, should_stop = train_step(session, *args, **kwargs)
if train_step_fn.step % FLAGS.validation_check == 0:
_mean_iou = session.run(train_step_fn.mean_iou)
print('evaluation step %d - loss = %.4f mean_iou = %.2f%%' %\
(train_step_fn.step, total_loss, _mean_iou ))
# evaluated_tensors = session.run([end_points['conv4'], end_points['up1']])
# example_frame = session.run(end_points['up2'])
# visualizer.update(arrays=evaluated_tensors, frame=example_frame)
train_step_fn.step += 1
return [total_loss, should_stop]
train_step_fn.step = 0
train_step_fn.end_points = end_points
train_step_fn.mean_iou = mean_iou[0]
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=FLAGS.gpu_memory_fraction,
allocator_type="BFC")
config = tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False,
allow_soft_placement = True,
inter_op_parallelism_threads = 0,
intra_op_parallelism_threads = 1,)
saver = tf.train.Saver(max_to_keep=5,
keep_checkpoint_every_n_hours=1.0,
write_version=2,
pad_step_number=False)
slim.learning.train(
train_tensor,
logdir=FLAGS.train_dir,
master='',
is_chief=True,
train_step_fn=train_step_fn,
init_fn=tf_utils.get_init_fn(FLAGS),
summary_op=summary_op,
number_of_steps=FLAGS.max_number_of_steps,
log_every_n_steps=FLAGS.log_every_n_steps,
save_summaries_secs=FLAGS.save_summaries_secs,
saver=saver,
save_interval_secs=FLAGS.save_interval_secs,
session_config=config,
sync_optimizer=None)
import sys
import os
import glob
import shutil
import numpy as np
import PIL.Image as Image
from PIL import ImageDraw
import tensorflow as tf
import matplotlib.pyplot as plt
from cityscapesscripts.helpers.labels import trainId2label
from object_detection.data_decoders.tf_example_decoder import TfExampleDecoder
with tf.Graph().as_default():
file_pattern = 'object_detection/data/records/cityscapes_mini/00000-of-00004.record'
tfrecords = glob.glob(file_pattern)
with tf.device('/cpu:0'):
filename_queue = tf.train.string_input_producer(
tfrecords, capacity=len(tfrecords))
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue)
example = TfExampleDecoder().decode(serialized_example)
print(example.keys())
sess = tf.Session()
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
def main():
cfg = TrainConfig().parse()
print (cfg.name)
result_dir = os.path.join(cfg.result_root,
cfg.name+'_'+datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S'))
if not os.path.isdir(result_dir):
os.makedirs(result_dir)
utils.write_configure_to_file(cfg, result_dir)
np.random.seed(seed=cfg.seed)
# prepare dataset
train_session = cfg.train_session
train_set = prepare_multimodal_dataset(cfg.feature_root, train_session, cfg.feat, cfg.label_root)
train_set = train_set[:cfg.label_num]
batch_per_epoch = len(train_set)//cfg.sess_per_batch
val_session = cfg.val_session
val_set = prepare_multimodal_dataset(cfg.feature_root, val_session, cfg.feat, cfg.label_root)
# construct the graph
with tf.Graph().as_default():
tf.set_random_seed(cfg.seed)
global_step = tf.Variable(0, trainable=False)
lr_ph = tf.placeholder(tf.float32, name='learning_rate')
####################### Load models here ########################
with tf.variable_scope("modality_core"):
# load backbone model
if cfg.network == "convtsn":
model_emb = networks.ConvTSN(n_seg=cfg.num_seg, emb_dim=cfg.emb_dim)
elif cfg.network == "convrtsn":
model_emb = networks.ConvRTSN(n_seg=cfg.num_seg, emb_dim=cfg.emb_dim)
else:
raise NotImplementedError
input_ph = tf.placeholder(tf.float32, shape=[None, cfg.num_seg, None, None, None])
dropout_ph = tf.placeholder(tf.float32, shape=[])
model_emb.forward(input_ph, dropout_ph) # for lstm has variable scope
with tf.variable_scope("modality_sensors"):
sensors_emb_dim = 32
model_emb_sensors = networks.RTSN(n_seg=cfg.num_seg, emb_dim=sensors_emb_dim)
input_sensors_ph = tf.placeholder(tf.float32, shape=[None, cfg.num_seg, 8])
model_emb_sensors.forward(input_sensors_ph, dropout_ph)
var_list = {}
for v in tf.global_variables():
if v.op.name.startswith("modality_sensors"):
var_list[v.op.name.replace("modality_sensors/","")] = v
restore_saver_sensors = tf.train.Saver(var_list)
with tf.variable_scope("modality_segment"):
segment_emb_dim = 32
model_emb_segment = networks.RTSN(n_seg=cfg.num_seg, emb_dim=segment_emb_dim, n_input=357)
input_segment_ph = tf.placeholder(tf.float32, shape=[None, cfg.num_seg, 357])
model_emb_segment.forward(input_segment_ph, dropout_ph)
var_list = {}
for v in tf.global_variables():
if v.op.name.startswith("modality_segment"):
var_list[v.op.name.replace("modality_segment/","")] = v
restore_saver_segment = tf.train.Saver(var_list)
############################# Forward Pass #############################
# Core branch
if cfg.normalized:
embedding = tf.nn.l2_normalize(model_emb.hidden, axis=-1, epsilon=1e-10)
embedding_sensors = tf.nn.l2_normalize(model_emb_sensors.hidden, axis=-1, epsilon=1e-10)
embedding_hal_sensors = tf.nn.l2_normalize(hal_emb_sensors.hidden, axis=-1, epsilon=1e-10)
embedding_segment = tf.nn.l2_normalize(model_emb_segment.hidden, axis=-1, epsilon=1e-10)
embedding_hal_segment = tf.nn.l2_normalize(hal_emb_segment.hidden, axis=-1, epsilon=1e-10)
else:
embedding = model_emb.hidden
embedding_sensors = model_emb_sensors.hidden
embedding_hal_sensors = hal_emb_sensors.hidden
embedding_segment = model_emb_segment.hidden
embedding_hal_segment = hal_emb_segment.hidden
# variable for visualizing the embeddings
emb_var = tf.Variable([0.0], name='embeddings')
set_emb = tf.assign(emb_var, embedding, validate_shape=False)
# calculated for monitoring all-pair embedding distance
diffs = utils.all_diffs_tf(embedding, embedding)
all_dist = utils.cdist_tf(diffs)
tf.summary.histogram('embedding_dists', all_dist)
# split embedding into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(tf.reshape(embedding, [-1,3,cfg.emb_dim]), 3, 1)
anc_sensors, pos_sensors, neg_sensors = tf.unstack(tf.reshape(embedding_sensors, [-1,3,sensors_emb_dim]), 3, 1)
anc_hal_sensors, pos_hal_sensors, neg_hal_sensors = tf.unstack(tf.reshape(embedding_hal_sensors, [-1,3,sensors_emb_dim]), 3, 1)
anc_segment, pos_segment, neg_segment = tf.unstack(tf.reshape(embedding_segment, [-1,3,segment_emb_dim]), 3, 1)
anc_hal_segment, pos_hal_segment, neg_hal_segment = tf.unstack(tf.reshape(embedding_hal_segment, [-1,3,segment_emb_dim]), 3, 1)
# a fusion embedding
anc_fused = tf.concat((anchor, anc_hal_sensors, anc_hal_segment), axis=1)
pos_fused = tf.concat((positive, pos_hal_sensors, anc_hal_segment), axis=1)
neg_fused = tf.concat((negative, neg_hal_sensors, anc_hal_segment), axis=1)
############################# Calculate loss #############################
# triplet loss
metric_loss = networks.triplet_loss(anchor, positive, negative, cfg.alpha) + \
networks.triplet_loss(anc_sensors, pos_sensors, neg_sensors, cfg.alpha) + \
networks.triplet_loss(anc_hal_sensors, pos_hal_sensors, neg_hal_sensors, cfg.alpha) + \
networks.triplet_loss(anc_segment, pos_segment, neg_segment, cfg.alpha) + \
networks.triplet_loss(anc_hal_segment, pos_hal_segment, neg_hal_segment, cfg.alpha) + \
networks.triplet_loss(anc_fused, pos_fused, neg_fused, cfg.alpha)
# hallucination loss (regression loss)
hal_loss_sensors = tf.nn.l2_loss(embedding_sensors - embedding_hal_sensors)
hal_loss_segment = tf.nn.l2_loss(embedding_segment - embedding_hal_segment)
hal_loss = hal_loss_sensors + hal_loss_segment
regularization_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
# use lambda_multimodal for hal_loss
total_loss = metric_loss + cfg.lambda_multimodal * hal_loss + regularization_loss * cfg.lambda_l2
tf.summary.scalar('learning_rate', lr_ph)
train_op = utils.optimize(total_loss, global_step, cfg.optimizer,
lr_ph, tf.global_variables())
saver = tf.train.Saver(max_to_keep=10)
summary_op = tf.summary.merge_all() # not logging histogram of variables because it will cause problem when only unimodal_train_op is called
#########################################################################
# session iterator for session sampling
feat_paths_ph = tf.placeholder(tf.string, shape=[None, cfg.sess_per_batch])
feat2_paths_ph = tf.placeholder(tf.string, shape=[None, cfg.sess_per_batch])
feat3_paths_ph = tf.placeholder(tf.string, shape=[None, cfg.sess_per_batch])
label_paths_ph = tf.placeholder(tf.string, shape=[None, cfg.sess_per_batch])
train_data = multimodal_session_generator(feat_paths_ph, feat2_paths_ph, feat3_paths_ph, label_paths_ph, sess_per_batch=cfg.sess_per_batch, num_threads=2, shuffled=False, preprocess_func=[model_emb.prepare_input, model_emb_sensors.prepare_input, model_emb_segment.prepare_input])
train_sess_iterator = train_data.make_initializable_iterator()
next_train = train_sess_iterator.get_next()
# prepare validation data
val_sess = []
val_feats = []
val_feats2 = []
val_feats3 = []
val_labels = []
val_boundaries = []
for session in val_set:
session_id = os.path.basename(session[1]).split('_')[0]
eve_batch, lab_batch, boundary = load_data_and_label(session[0], session[-1], model_emb.prepare_input_test) # use prepare_input_test for testing time
val_feats.append(eve_batch)
val_labels.append(lab_batch)
val_sess.extend([session_id]*eve_batch.shape[0])
val_boundaries.extend(boundary)
eve2_batch, _,_ = load_data_and_label(session[1], session[-1], model_emb_sensors.prepare_input_test)
val_feats2.append(eve2_batch)
eve3_batch, _,_ = load_data_and_label(session[2], session[-1], model_emb_segment.prepare_input_test)
val_feats3.append(eve3_batch)
val_feats = np.concatenate(val_feats, axis=0)
val_feats2 = np.concatenate(val_feats2, axis=0)
val_feats3 = np.concatenate(val_feats3, axis=0)
val_labels = np.concatenate(val_labels, axis=0)
print ("Shape of val_feats: ", val_feats.shape)
# generate metadata.tsv for visualize embedding
with open(os.path.join(result_dir, 'metadata_val.tsv'), 'w') as fout:
fout.write('id\tlabel\tsession_id\tstart\tend\n')
for i in range(len(val_sess)):
fout.write('{0}\t{1}\t{2}\t{3}\t{4}\n'.format(i, val_labels[i,0], val_sess[i],
val_boundaries[i][0], val_boundaries[i][1]))
#########################################################################
# Start running the graph
if cfg.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.gpu
gpu_options = tf.GPUOptions(allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
summary_writer = tf.summary.FileWriter(result_dir, sess.graph)
with sess.as_default():
sess.run(tf.global_variables_initializer())
print ("Restoring sensors model: %s" % cfg.sensors_path)
restore_saver_sensors.restore(sess, cfg.sensors_path)
print ("Restoring segment model: %s" % cfg.segment_path)
restore_saver_segment.restore(sess, cfg.segment_path)
# load pretrain model, if needed
if cfg.model_path:
print ("Restoring pretrained model: %s" % cfg.model_path)
saver.restore(sess, cfg.model_path)
################## Training loop ##################
epoch = -1
while epoch < cfg.max_epochs-1:
step = sess.run(global_step, feed_dict=None)
epoch = step // batch_per_epoch
# learning rate schedule, reference: "In defense of Triplet Loss"
if epoch < cfg.static_epochs:
learning_rate = cfg.learning_rate
else:
learning_rate = cfg.learning_rate * \
0.01**((epoch-cfg.static_epochs)/(cfg.max_epochs-cfg.static_epochs))
# prepare data for this epoch
random.shuffle(train_set)
paths = list(zip(*[iter(train_set)]*cfg.sess_per_batch))
feat_paths = [[p[0] for p in path] for path in paths]
feat2_paths = [[p[1] for p in path] for path in paths]
feat3_paths = [[p[2] for p in path] for path in paths]
label_paths = [[p[-1] for p in path] for path in paths]
sess.run(train_sess_iterator.initializer, feed_dict={feat_paths_ph: feat_paths,
feat2_paths_ph: feat2_paths,
feat3_paths_ph: feat3_paths,
label_paths_ph: label_paths})
# for each epoch
batch_count = 1
while True:
try:
##################### Data loading ########################
start_time = time.time()
eve, eve_sensors, eve_segment, lab, batch_sess = sess.run(next_train)
load_time = time.time() - start_time
##################### Triplet selection #####################
start_time = time.time()
# Get the embeddings of all events
eve_embedding = np.zeros((eve.shape[0], cfg.emb_dim), dtype='float32')
for start, end in zip(range(0, eve.shape[0], cfg.batch_size),
range(cfg.batch_size, eve.shape[0]+cfg.batch_size, cfg.batch_size)):
end = min(end, eve.shape[0])
emb = sess.run(embedding, feed_dict={input_ph: eve[start:end], dropout_ph: 1.0})
eve_embedding[start:end] = np.copy(emb)
# sample triplets within sampled sessions
all_diff = utils.all_diffs(eve_embedding, eve_embedding)
triplet_input_idx, active_count = utils.select_triplets_facenet(lab,utils.cdist(all_diff,metric=cfg.metric),cfg.triplet_per_batch,cfg.alpha,num_negative=cfg.num_negative)
if triplet_input_idx is None:
continue
triplet_input = eve[triplet_input_idx]
sensors_input = eve_sensors[triplet_input_idx]
segment_input = eve_segment[triplet_input_idx]
select_time = time.time() - start_time
if len(triplet_input.shape) > 5: # debugging
pdb.set_trace()
##################### Start training ########################
err, metric_err, hal_err, _, step, summ = sess.run(
[total_loss, metric_loss, hal_loss, train_op, global_step, summary_op],
feed_dict = {input_ph: triplet_input,
input_sensors_ph: sensors_input,
input_segment_ph: segment_input,
dropout_ph: cfg.keep_prob,
lr_ph: learning_rate})
print ("%s\tEpoch: [%d][%d/%d]\tEvent num: %d\tTriplet num: %d\tLoad time: %.3f\tSelect time: %.3f\tMetric Loss %.4f\tHal Loss %.4f" % \
(cfg.name, epoch+1, batch_count, batch_per_epoch, eve.shape[0], triplet_input.shape[0]//3, load_time, select_time, metric_err, hal_err))
summary = tf.Summary(value=[tf.Summary.Value(tag="train_loss", simple_value=err),
tf.Summary.Value(tag="active_count", simple_value=active_count),
tf.Summary.Value(tag="metric_loss", simple_value=metric_err),
tf.Summary.Value(tag="hallucination_loss", simple_value=hal_err)])
summary_writer.add_summary(summary, step)
summary_writer.add_summary(summ, step)
batch_count += 1
except tf.errors.OutOfRangeError:
print ("Epoch %d done!" % (epoch+1))
break
# validation on val_set
print ("Evaluating on validation set...")
val_embeddings, hal_err, _ = sess.run([embedding, hal_loss, set_emb],
feed_dict = {input_ph: val_feats,
input_sensors_ph: val_feats2,
input_segment_ph: val_feats3,
dropout_ph: 1.0})
mAP, mPrec = utils.evaluate_simple(val_embeddings, val_labels)
summary = tf.Summary(value=[tf.Summary.Value(tag="Valiation mAP", simple_value=mAP),
tf.Summary.Value(tag="Validation [email protected]", simple_value=mPrec),
tf.Summary.Value(tag="Validation hal loss", simple_value=hal_err)])
summary_writer.add_summary(summary, step)
print ("Epoch: [%d]\tmAP: %.4f\tmPrec: %.4f" % (epoch+1,mAP,mPrec))
# config for embedding visualization
config = projector.ProjectorConfig()
visual_embedding = config.embeddings.add()
visual_embedding.tensor_name = emb_var.name
visual_embedding.metadata_path = os.path.join(result_dir, 'metadata_val.tsv')
projector.visualize_embeddings(summary_writer, config)
# save model
saver.save(sess, os.path.join(result_dir, cfg.name+'.ckpt'), global_step=step)
def create_image(network_type):
# set parameters
if network_type in ("model_conv_num_balls_1_beta_0.1", "model_conv_num_balls_1_beta_0.5", "model_conv_num_balls_1_beta_1.0"):
FLAGS.model="conv"
FLAGS.num_balls=1
if network_type in ("model_conv_num_balls_2_beta_0.1", "model_conv_num_balls_2_beta_0.5", "model_conv_num_balls_2_beta_1.0"):
FLAGS.model="conv"
FLAGS.num_balls=2
elif network_type in ("model_fully_connected_num_balls_1_beta_0.1", "model_fully_connected_num_balls_1_beta_0.5", "model_fully_connected_num_balls_1_beta_1.0"):
FLAGS.model="fully_connected"
FLAGS.num_balls=1
FLAGS.hidden_size=10
elif network_type in ("model_fully_connected_num_balls_2_beta_0.1", "model_fully_connected_num_balls_2_beta_0.5", "model_fully_connected_num_balls_2_beta_1.0"):
FLAGS.model="fully_connected"
FLAGS.num_balls=2
FLAGS.hidden_size=10
elif network_type in ("model_all_conv_num_balls_1_beta_0.1", "model_all_conv_num_balls_1_beta_0.5", "model_all_conv_num_balls_1_beta_1.0"):
FLAGS.model="all_conv"
FLAGS.num_balls=1
FLAGS.hidden_size=1
elif network_type in ("model_all_conv_num_balls_2_beta_0.1", "model_all_conv_num_balls_2_beta_0.5", "model_all_conv_num_balls_2_beta_1.0"):
FLAGS.model="all_conv"
FLAGS.num_balls=2
FLAGS.hidden_size=1
"""Eval net to get stddev."""
with tf.Graph().as_default():
# make inputs
x = tf.placeholder(tf.float32, [FLAGS.batch_size, 32, 32, 1])
# no dropout on testing
keep_prob = 1.0
# make model
if FLAGS.model=="fully_connected":
mean, stddev, y_sampled, x_prime = arc.fully_connected_model(x, keep_prob)
elif FLAGS.model=="conv":
mean, stddev, y_sampled, x_prime = arc.conv_model(x, keep_prob)
elif FLAGS.model=="all_conv":
mean, stddev, y_sampled, x_prime = arc.all_conv_model(x, keep_prob)
else:
print("model requested not found, now some errors!")
# List of all Variables
variables = tf.all_variables()
# Load weights operator
print('save file is ./checkpoints/train_store_' + network_type)
ckpt = tf.train.get_checkpoint_state('./checkpoints/train_store_' + network_type)
weight_saver = tf.train.Saver(variables)
# Summary op
summary_op = tf.merge_all_summaries()
# Start running operations on the Graph.
sess = tf.Session()
# init if this is the very time training
weight_saver.restore(sess, ckpt.model_checkpoint_path)
print("restored from" + ckpt.model_checkpoint_path)
# Summary op
graph_def = sess.graph.as_graph_def(add_shapes=True)
dat = b.bounce_vec(32, FLAGS.num_balls, FLAGS.batch_size)
stddev_r = np.sum(sess.run([stddev],feed_dict={x:dat})[0], axis=0)/FLAGS.batch_size
sample_y = sess.run([y_sampled],feed_dict={x:dat})[0]
print(sample_y[0])
# create grid
y_p, x_p = np.mgrid[0:1:32j, 0:1:32j]
for i in xrange(10):
index = np.argmin(stddev_r)
for j in xrange(5):
z_f = np.copy(sample_y)
z_f[0,index] = 1.5*j - 3.0
print(sample_y[0])
print(z_f[0])
plt.subplot(10,5,j+5*i + 1)
plt.pcolor(x_p, y_p, sess.run([x_prime],feed_dict={y_sampled:z_f})[0][0,:,:,0])
if i == 9:
plt.xlabel(str(1.5*j - 3.0))
if j == 0:
plt.ylabel("{0:.2f}".format(stddev_r[index]))
plt.tick_params(axis='both', which='both', bottom='off', top='off', left='off', right='off', labelbottom='off', labelleft='off')
#plt.axis(frameon=False)
# just make it big to get out of the way
stddev_r[index] = 2.0
plt.savefig("figures/heat_map_" + network_type + ".png")
def from_pipe(opts):
command = ["ffprobe",
'-v', "quiet",
'-print_format', 'json',
'-show_streams', opts.in_path]
info = json.loads(str(subprocess.check_output(command), encoding="utf8"))
width = int(info["streams"][0]["width"])
height = int(info["streams"][0]["height"])
fps = round(eval(info["streams"][0]["r_frame_rate"]))
command = ["ffmpeg",
'-loglevel', "quiet",
'-i', opts.in_path,
'-f', 'image2pipe',
'-pix_fmt', 'rgb24',
'-vcodec', 'rawvideo', '-']
pipe_in = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=10 ** 9, stdin=None, stderr=None)
command = ["ffmpeg",
'-loglevel', "info",
'-y', # (optional) overwrite output file if it exists
'-f', 'rawvideo',
'-vcodec', 'rawvideo',
'-s', str(width) + 'x' + str(height), # size of one frame
'-pix_fmt', 'rgb24',
'-r', str(fps), # frames per second
'-i', '-', # The imput comes from a pipe
'-an', # Tells FFMPEG not to expect any audio
'-c:v', 'libx264',
'-preset', 'slow',
'-crf', '18',
opts.out]
pipe_out = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=None, stderr=None)
g = tf.Graph()
soft_config = tf.ConfigProto(allow_soft_placement=True)
soft_config.gpu_options.allow_growth = True
with g.as_default(), g.device(opts.device), \
tf.Session(config=soft_config) as sess:
batch_shape = (opts.batch_size, height, width, 3)
img_placeholder = tf.placeholder(tf.float32, shape=batch_shape,
name='img_placeholder')
preds = transform.net(img_placeholder)
saver = tf.train.Saver()
if os.path.isdir(opts.checkpoint):
ckpt = tf.train.get_checkpoint_state(opts.checkpoint)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise Exception("No checkpoint found...")
else:
saver.restore(sess, opts.checkpoint)
X = np.zeros(batch_shape, dtype=np.float32)
nbytes = 3 * width * height
read_input = True
last = False
while read_input:
count = 0
while count < opts.batch_size:
raw_image = pipe_in.stdout.read(width * height * 3)
if len(raw_image) != nbytes:
if count == 0:
read_input = False
else:
last = True
X = X[:count]
batch_shape = (count, height, width, 3)
img_placeholder = tf.placeholder(tf.float32, shape=batch_shape,
name='img_placeholder')
preds = transform.net(img_placeholder)
break
image = numpy.fromstring(raw_image, dtype='uint8')
image = image.reshape((height, width, 3))
X[count] = image
count += 1
if read_input:
if last:
read_input = False
_preds = sess.run(preds, feed_dict={img_placeholder: X})
for i in range(0, batch_shape[0]):
img = np.clip(_preds[i], 0, 255).astype(np.uint8)
try:
pipe_out.stdin.write(img)
except IOError as err:
ffmpeg_error = pipe_out.stderr.read()
error = (str(err) + ("\n\nFFMPEG encountered"
"the following error while writing file:"
"\n\n %s" % ffmpeg_error))
read_input = False
print(error)
pipe_out.terminate()
pipe_in.terminate()
pipe_out.stdin.close()
pipe_in.stdout.close()
del pipe_in
del pipe_out
# ...
#
# * Then you can run the operations on this graph as many times as you want by calling `session.run()`, providing it outputs to fetch from the graph that get returned. This runtime operation is all contained in the block below:
#
# with tf.Session(graph=graph) as session:
# ...
#
# Let's load all the data into TensorFlow and build the computation graph corresponding to our training:
# In[7]:
# With gradient descent training, even this much data is prohibitive.
# Subset the training data for faster turnaround.
train_subset = 10000
graph = tf.Graph()
with graph.as_default():
# Input data.
# Load the training, validation and test data into constants that are
# attached to the graph.
tf_train_dataset = tf.constant(train_dataset[:train_subset, :])
tf_train_labels = tf.constant(train_labels[:train_subset])
tf_valid_dataset = tf.constant(valid_dataset)
tf_test_dataset = tf.constant(test_dataset)
# Variables.
# These are the parameters that we are going to be training. The weight
# matrix will be initialized using random values following a (truncated)
# normal distribution. The biases get initialized to zero.
weights = tf.Variable(
def main(_):
pipeline_proto = _load_pipeline_proto(FLAGS.pipeline_proto)
tf.logging.info("Pipeline configure: %s", '=' * 128)
tf.logging.info(pipeline_proto)
g = tf.Graph()
with g.as_default():
# Infer saliency.
model = builder.build(pipeline_proto.model, is_training=False)
predictions = model.build_prediction(
examples={}, prediction_task=GAPPredictionTasks.word_saliency)
saver = tf.train.Saver()
invalid_variable_names = tf.report_uninitialized_variables()
with tf.Session(graph=g) as sess:
sess.run(tf.tables_initializer())
# Load the latest checkpoint.
checkpoint_path = tf.train.latest_checkpoint(pipeline_proto.model_dir)
assert checkpoint_path is not None
saver.restore(sess, checkpoint_path)
assert len(sess.run(invalid_variable_names)) == 0
predictions = sess.run(predictions)
# Process kNN retrieval.
name_to_class_id = {}
with open(FLAGS.name_to_class_id_file, 'r') as fid:
for line in fid.readlines():
name, class_id = line.strip('\n').split('\t')
name_to_class_id[name] = class_id
(vocabulary, word_saliency,
word_embedding) = (predictions[GAPPredictions.vocabulary],
predictions[GAPPredictions.word_saliency],
predictions[GAPPredictions.word_embedding])
queries = list(name_to_class_id)
synonyms_list = _knn_retrieval(queries, vocabulary, word_embedding,
word_saliency)
# Print to the terminal.
expanded_name_to_class_id = []
for query, synonyms in zip(queries, synonyms_list):
elems = []
for synonym in synonyms:
if synonym['saliency'] < FLAGS.saliency_threshold:
continue
if synonym['similarity'] < FLAGS.similarity_threshold:
continue
elems.append(synonym['word'])
expanded_name_to_class_id.append((synonym['word'],
name_to_class_id[query]))
print('%s\t%s' % (query, ','.join(elems)))
# Write to output file.
with open(FLAGS.expanded_name_to_class_id_file, 'w') as fid:
for word, class_id in expanded_name_to_class_id:
fid.write('%s\t%s\n' % (word, class_id))
tf.logging.info('Done')
def main(_):
os.environ["CUDA_VISIBLE_DEVICES"] = FLAGS.cuda_visible_devices
gm = GPUManager()
with gm.auto_choice():
tf.logging.set_verbosity(tf.logging.INFO)
tf.reset_default_graph()
graph = tf.Graph()
with graph.as_default() as g:
####################
# Select the model #
####################
network_fn = nets_factory.get_network_fn(
FLAGS.model_name,
num_classes=(FLAGS.num_classes - FLAGS.labels_offset),
is_training=False)
#####################################
# Select the preprocessing function #
#####################################
preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name
image_preprocessing_fn = preprocessing_factory.get_preprocessing(
preprocessing_name, is_training=False)
test_image_size = FLAGS.test_image_size or network_fn.default_image_size
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(
FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
batch_size = FLAGS.batch_size
# tensor_input = tf.placeholder(tf.float32, [None, test_image_size, test_image_size, 3])
tensor_input = tf.placeholder(
tf.float32, [batch_size, test_image_size, test_image_size, 3])
logits, _ = network_fn(tensor_input)
#logits = tf.nn.top_k(logits, 5)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
print(FLAGS.test_dir)
jpg_list = ListFile(FLAGS.test_dir)
tot = len(jpg_list)
with tf.Session(config=config, graph=g) as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, checkpoint_path)
time_start = time.time()
with open(os.path.join(FLAGS.test_dir, 'test.txt'), 'w') as f:
for idx in range(0, tot, batch_size):
images = list()
idx_end = min(tot, idx + batch_size)
print(idx)
for i in range(idx, idx_end):
image_id = jpg_list[i]
test_path = os.path.join(FLAGS.test_dir,
'jpg_data', image_id)
image = open(test_path, 'rb').read()
image = tf.image.decode_jpeg(image, channels=3)
processed_image = image_preprocessing_fn(
image, test_image_size, test_image_size)
processed_image = sess.run(processed_image)
images.append(processed_image)
images = np.array(images)
predictions = sess.run(
logits, feed_dict={tensor_input: images})
for i in range(idx, idx_end):
# if predictions[i-idx][0]-predictions[i-idx][1] <= 0.8:
# continue
f.write('{}:{}\n'.format(
jpg_list[i], np.argmax(predictions[i - idx])))
#print(np.argmax(predictions[i - idx]))
#print('{}:{}\n'.format(jpg_list[i], sess.run(tf.argmax(predictions[i - idx]))))
#print('{} {}'.format(jpg_list[i], predictions[i - idx]))
time_total = time.time() - time_start
print('total time: {}, total images: {}, average time: {}'.
format(time_total, tot, time_total / tot))
def main():
pnet, rnet, onet = create_network_face_detection(gpu_memory_fraction)
timer = str(datetime.now().time())
fileCount = 0
with tf.Graph().as_default():
with tf.Session() as sess:
facenet.load_model(model_dir)
while True:
args = parse_args()
time.sleep(0.1)
newFileCount = len(os.listdir(input_dir))
start_time = datetime.strptime(timer, '%H:%M:%S.%f')
end_time = datetime.strptime(str(datetime.now().time()),
'%H:%M:%S.%f')
diff = end_time - start_time
elapsed_time = int((diff.seconds * 1000) +
(diff.microseconds / 1000))
if newFileCount > fileCount and elapsed_time > args.cluster_update:
print('Updating cluster...')
fileCount = newFileCount
timer = str(datetime.now().time())
root = etree.Element("root")
blacklist = {}
try:
tree = etree.parse(cluster_filename)
for i in tree.iter():
if i.tag == 'root':
continue
if len(i):
blacklist.update({i.tag: []})
if 'grp-' in i.tag:
for j in i.iter():
if not len(j):
blacklist[i.tag].append(
[j.tag, j.text])
except:
pass
HumanNames = os.listdir(pre_img)
HumanNames.sort()
classifier_filename_exp = os.path.expanduser(
classifier_filename)
with open(classifier_filename_exp, 'rb') as infile:
(model, class_names) = pickle.load(infile)
image_list = load_images_from_folder(input_dir)
images = align_data(image_list, image_size, args.margin,
args.bb_area, pnet, rnet, onet)
images_placeholder = sess.graph.get_tensor_by_name(
"input:0")
embeddings = sess.graph.get_tensor_by_name("embeddings:0")
phase_train_placeholder = sess.graph.get_tensor_by_name(
"phase_train:0")
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb = sess.run(embeddings, feed_dict=feed_dict)
embedding_size = embeddings.get_shape()[1]
nrof_images = len(images)
matrix = np.zeros((nrof_images, nrof_images))
tagged = {}
for i in range(nrof_images):
emb_array = np.zeros((1, embedding_size))
emb_array[0, :] = emb[i]
predictions = model.predict_proba(emb_array)
best_class_indices = np.argmax(predictions, axis=1)
best_class_probabilities = predictions[
np.arange(len(best_class_indices)),
best_class_indices]
if best_class_probabilities > args.class_probability:
for H_i in HumanNames:
if HumanNames[best_class_indices[0]] == H_i:
tagged.update(
{i: HumanNames[best_class_indices[0]]})
# get euclidean distance matrices
for i in range(nrof_images):
for j in range(nrof_images):
dist = np.sqrt(
np.sum(
np.square(np.subtract(
emb[i, :], emb[j, :]))))
matrix[i][j] = dist
# DBSCAN is the only algorithm that doesn't require the number of clusters to be defined.
db = DBSCAN(eps=cluster_threshold,
min_samples=min_cluster_size,
metric='precomputed')
db.fit(matrix)
labels = db.labels_
# get number of clusters
no_clusters = len(set(labels)) - (1 if -1 in labels else 0)
print('No of clusters:', no_clusters)
if no_clusters > 0:
for i in range(no_clusters):
for j in np.nonzero(labels == i)[0]:
# path = os.path.join(output_dir, (tagged[j] if j in tagged else str(i)))
# if not os.path.exists(path):
# os.makedirs(path)
# misc.imsave(os.path.join(path, image_list[j][0]), image_list[j][1])
tag = ("grp-" +
tagged[j] if j in tagged else "unk-" +
str(i))
group = root.find(tag)
exclude = False
for x in blacklist:
for y in blacklist[x]:
if y[1] == image_list[j][0]:
exclude = True
break
if exclude:
break
if not exclude:
if group is None:
group = etree.SubElement(root, tag)
etree.SubElement(
group, "face" +
str(j)).text = image_list[j][0]
for x in blacklist:
for y in blacklist[x]:
group = root.find(x)
if group is None:
group = etree.SubElement(root, x)
etree.SubElement(group, y[0]).text = y[1]
tree = etree.ElementTree(root)
tree.write(cluster_filename)
def main(model_config, train_config, track_config):
os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu()
# Create training directory which will be used to save: configurations, model files, TensorBoard logs
train_dir = train_config['train_dir']
if not osp.isdir(train_dir):
logging.info('Creating training directory: %s', train_dir)
mkdir_p(train_dir)
g = tf.Graph()
with g.as_default():
# Set fixed seed for reproducible experiments
random.seed(train_config['seed'])
np.random.seed(train_config['seed'])
tf.set_random_seed(train_config['seed'])
# Build the training and validation model
model = siamese_model.SiameseModel(model_config,
train_config,
mode='train')
model.build()
model_va = siamese_model.SiameseModel(model_config,
train_config,
mode='validation')
model_va.build(reuse=True)
# Save configurations for future reference
save_cfgs(train_dir, model_config, train_config, track_config)
learning_rate = _configure_learning_rate(train_config,
model.global_step)
optimizer = _configure_optimizer(train_config, learning_rate)
tf.summary.scalar('learning_rate', learning_rate)
# Set up the training ops
opt_op = tf.contrib.layers.optimize_loss(
loss=model.total_loss,
global_step=model.global_step,
learning_rate=learning_rate,
optimizer=optimizer,
clip_gradients=train_config['clip_gradients'],
learning_rate_decay_fn=None,
summaries=['learning_rate'])
with tf.control_dependencies([opt_op]):
train_op = tf.no_op(name='train')
saver = tf.train.Saver(
tf.global_variables(),
max_to_keep=train_config['max_checkpoints_to_keep'])
summary_writer = tf.summary.FileWriter(train_dir, g)
summary_op = tf.summary.merge_all()
global_variables_init_op = tf.global_variables_initializer()
local_variables_init_op = tf.local_variables_initializer()
g.finalize() # Finalize graph to avoid adding ops by mistake
# Dynamically allocate GPU memory
gpu_options = tf.GPUOptions(allow_growth=True)
sess_config = tf.ConfigProto(gpu_options=gpu_options)
sess = tf.Session(config=sess_config)
model_path = tf.train.latest_checkpoint(train_config['train_dir'])
if not model_path:
sess.run(global_variables_init_op)
sess.run(local_variables_init_op)
start_step = 0
if model_config['embed_config']['embedding_checkpoint_file']:
model.init_fn(sess)
else:
logging.info('Restore from last checkpoint: {}'.format(model_path))
sess.run(local_variables_init_op)
saver.restore(sess, model_path)
start_step = tf.train.global_step(sess, model.global_step.name) + 1
# Training loop
data_config = train_config['train_data_config']
total_steps = int(data_config['epoch'] *
data_config['num_examples_per_epoch'] /
data_config['batch_size'])
logging.info('Train for {} steps'.format(total_steps))
for step in range(start_step, total_steps):
start_time = time.time()
_, loss, batch_loss = sess.run(
[train_op, model.total_loss, model.batch_loss])
duration = time.time() - start_time
if step % 10 == 0:
examples_per_sec = data_config['batch_size'] / float(duration)
time_remain = data_config['batch_size'] * (
total_steps - step) / examples_per_sec
m, s = divmod(time_remain, 60)
h, m = divmod(m, 60)
format_str = (
'%s: step %d, total loss = %.2f, batch loss = %.2f (%.1f examples/sec; %.3f '
'sec/batch; %dh:%02dm:%02ds remains)')
logging.info(format_str %
(datetime.now(), step, loss, batch_loss,
examples_per_sec, duration, h, m, s))
if step % 100 == 0:
summary_str = sess.run(summary_op)
summary_writer.add_summary(summary_str, step)
if step % train_config['save_model_every_n_step'] == 0 or (
step + 1) == total_steps:
checkpoint_path = osp.join(train_config['train_dir'],
'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
def evaluate():
"""Evaluate."""
assert FLAGS.dataset == 'KITTI', \
'Currently only supports KITTI dataset'
os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu
with tf.Graph().as_default() as g:
assert FLAGS.net == 'vgg16' or FLAGS.net == 'resnet50' \
or FLAGS.net == 'squeezeDet' or FLAGS.net == 'squeezeDet+', \
'Selected neural net architecture not supported: {}'.format(FLAGS.net)
if FLAGS.net == 'vgg16':
mc = kitti_vgg16_config()
mc.BATCH_SIZE = 1 # TODO(bichen): allow batch size > 1
mc.LOAD_PRETRAINED_MODEL = False
model = VGG16ConvDet(mc)
elif FLAGS.net == 'resnet50':
mc = kitti_res50_config()
mc.BATCH_SIZE = 1 # TODO(bichen): allow batch size > 1
mc.LOAD_PRETRAINED_MODEL = False
model = ResNet50ConvDet(mc)
elif FLAGS.net == 'squeezeDet':
mc = kitti_squeezeDet_config()
mc.BATCH_SIZE = 1 # TODO(bichen): allow batch size > 1
mc.LOAD_PRETRAINED_MODEL = False
model = SqueezeDet(mc)
elif FLAGS.net == 'squeezeDet+':
mc = kitti_squeezeDetPlus_config()
mc.BATCH_SIZE = 1 # TODO(bichen): allow batch size > 1
mc.LOAD_PRETRAINED_MODEL = False
model = SqueezeDetPlus(mc)
imdb = kitti(FLAGS.image_set, FLAGS.data_path, mc)
# add summary ops and placeholders
ap_names = []
for cls in imdb.classes:
ap_names.append(cls + '_easy')
ap_names.append(cls + '_medium')
ap_names.append(cls + '_hard')
eval_summary_ops = []
eval_summary_phs = {}
for ap_name in ap_names:
ph = tf.placeholder(tf.float32)
eval_summary_phs['APs/' + ap_name] = ph
eval_summary_ops.append(tf.summary.scalar('APs/' + ap_name, ph))
ph = tf.placeholder(tf.float32)
eval_summary_phs['APs/mAP'] = ph
eval_summary_ops.append(tf.summary.scalar('APs/mAP', ph))
ph = tf.placeholder(tf.float32)
eval_summary_phs['timing/im_detect'] = ph
eval_summary_ops.append(tf.summary.scalar('timing/im_detect', ph))
ph = tf.placeholder(tf.float32)
eval_summary_phs['timing/im_read'] = ph
eval_summary_ops.append(tf.summary.scalar('timing/im_read', ph))
ph = tf.placeholder(tf.float32)
eval_summary_phs['timing/post_proc'] = ph
eval_summary_ops.append(tf.summary.scalar('timing/post_proc', ph))
ph = tf.placeholder(tf.float32)
eval_summary_phs['num_det_per_image'] = ph
eval_summary_ops.append(tf.summary.scalar('num_det_per_image', ph))
saver = tf.train.Saver(model.model_params)
summary_writer = tf.summary.FileWriter(FLAGS.eval_dir, g)
ckpts = set()
while True:
if FLAGS.run_once:
# When run_once is true, checkpoint_path should point to the exact
# checkpoint file.
eval_once(saver, FLAGS.checkpoint_path, summary_writer,
eval_summary_ops, eval_summary_phs, imdb, model)
return
else:
# When run_once is false, checkpoint_path should point to the directory
# that stores checkpoint files.
ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_path)
if ckpt and ckpt.model_checkpoint_path:
if ckpt.model_checkpoint_path in ckpts:
# Do not evaluate on the same checkpoint
print(
'Wait {:d}s for new checkpoints to be saved ... '.
format(FLAGS.eval_interval_secs))
time.sleep(FLAGS.eval_interval_secs)
else:
ckpts.add(ckpt.model_checkpoint_path)
print('Evaluating {}...'.format(
ckpt.model_checkpoint_path))
eval_once(saver, ckpt.model_checkpoint_path,
summary_writer, eval_summary_ops,
eval_summary_phs, imdb, model)
else:
print('No checkpoint file found')
if not FLAGS.run_once:
print(
'Wait {:d}s for new checkpoints to be saved ... '.
format(FLAGS.eval_interval_secs))
time.sleep(FLAGS.eval_interval_secs)
def main(_):
if not FLAGS.dataset_dir:
raise ValueError('You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
tf_global_step = slim.get_or_create_global_step()
######################
# Select the dataset #
######################
dataset = dataset_factory.get_dataset(
FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir)
####################
# Select the model #
####################
network_fn = nets_factory.get_network_fn(
FLAGS.model_name,
num_classes=(dataset.num_classes - FLAGS.labels_offset),
is_training=False)
##############################################################
# Create a dataset provider that loads data from the dataset #
##############################################################
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
shuffle=False,
common_queue_capacity=2 * FLAGS.batch_size,
common_queue_min=FLAGS.batch_size,
)
[image, label] = provider.get(['image', 'label'])
label -= FLAGS.labels_offset
#####################################
# Select the preprocessing function #
#####################################
preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name
image_preprocessing_fn = preprocessing_factory.get_preprocessing(
preprocessing_name,
is_training=False)
eval_image_size = FLAGS.eval_image_size or network_fn.default_image_size
image = image_preprocessing_fn(image, eval_image_size, eval_image_size)
images, labels = tf.train.batch(
[image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size,
)
####################
# Define the model #
####################
logits, _ = network_fn(images)
if FLAGS.moving_average_decay:
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, tf_global_step)
variables_to_restore = variable_averages.variables_to_restore(
slim.get_model_variables())
variables_to_restore[tf_global_step.op.name] = tf_global_step
else:
variables_to_restore = slim.get_variables_to_restore()
predictions = tf.argmax(logits, 1)
labels = tf.squeeze(labels)
# Define the metrics:
names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({
'Accuracy': slim.metrics.streaming_accuracy(predictions, labels),
# 'Recall_5': slim.metrics.streaming_recall_at_k(
# logits, labels, 5),
})
# Print the summaries to screen.
for name, value in names_to_values.items():
summary_name = 'eval/%s' % name
op = tf.summary.scalar(summary_name, value, collections=[])
op = tf.Print(op, [value], summary_name)
tf.add_to_collection(tf.GraphKeys.SUMMARIES, op)
# TODO(sguada) use num_epochs=1
if FLAGS.max_num_batches:
num_batches = FLAGS.max_num_batches
else:
# This ensures that we make a single pass over all of the data.
num_batches = math.ceil(dataset.num_samples / float(FLAGS.batch_size))
if tf.gfile.IsDirectory(FLAGS.checkpoint_path):
checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
else:
checkpoint_path = FLAGS.checkpoint_path
# # checkpoint_path_list = ['/home/cp/git/tensorflow/models/research/slim/logs/train/vgg16/model.ckpt-330','/home/cp/git/tensorflow/models/research/slim/logs/train/vgg16/model.ckpt-382']
#
# for checkpoint_path in checkpoint_path_list:
tf.logging.info('Evaluating %s' % checkpoint_path)
slim.evaluation.evaluate_once(
master=FLAGS.master,
checkpoint_path=checkpoint_path,
logdir=FLAGS.eval_dir,
num_evals=num_batches,
eval_op=list(names_to_updates.values()),
variables_to_restore=variables_to_restore)
def train(word2vec_path):
"""Training TextCNN-one-label model."""
# Load sentences, labels, and training parameters
logger.info("✔︎ Loading data...")
logger.info("✔︎ Training data processing...")
train_data = feed.load_data_and_labels_one_label(
FLAGS.training_data_file,
FLAGS.num_classes,
FLAGS.embedding_dim,
word2vec_path=word2vec_path,
data_aug_flag=False)
logger.info("✔︎ Validation data processing...")
val_data = feed.load_data_and_labels_one_label(FLAGS.validation_data_file,
FLAGS.num_classes,
FLAGS.embedding_dim,
word2vec_path=word2vec_path,
data_aug_flag=False)
logger.info("Recommended padding Sequence length for GOV_MEASURE is: "
"{}".format(FLAGS.pad_seq_len_gov))
logger.info("Recommended padding Sequence length for Article is: "
"{}".format(FLAGS.pad_seq_len_art))
logger.info("✔︎ GOV MEASURE padding...")
x_train_gov, x_train_art, y_train = feed.pad_data_one_label(
train_data, FLAGS.pad_seq_len_gov, FLAGS.pad_seq_len_art)
print("x_train_gov: ", len(x_train_gov))
print("x_train_art: ", len(x_train_art))
logger.info("✔︎ Validation data padding...")
x_val_gov, x_val_art, y_val = feed.pad_data_one_label(
val_data, FLAGS.pad_seq_len_gov, FLAGS.pad_seq_len_art)
print("x_val_gov: ", len(x_val_gov))
print("x_val_art: ", len(x_val_art))
# Build vocabulary
VOCAB_SIZE = feed.load_vocab_size(FLAGS.embedding_dim,
word2vec_path=word2vec_path)
# Use pretrained W2V
pretrained_word2vec_matrix = feed.load_word2vec_matrix(
VOCAB_SIZE, FLAGS.embedding_dim, word2vec_path=word2vec_path)
# Build a graph and cnn object
with tf.Graph().as_default():
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
session_conf.gpu_options.allow_growth = \
FLAGS.gpu_options_allow_growth
sess = tf.Session(config=session_conf)
with sess.as_default():
cnn = OneLabelTextCNN(
sequence_length_gov=FLAGS.pad_seq_len_gov,
sequence_length_art=FLAGS.pad_seq_len_art,
vocab_size=VOCAB_SIZE,
fc_hidden_size=FLAGS.fc_hidden_size,
embedding_size=FLAGS.embedding_dim,
embedding_type=FLAGS.embedding_type,
filter_sizes=list(map(int, FLAGS.filter_sizes.split(','))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda,
pretrained_embedding=pretrained_word2vec_matrix)
# Define training procedure
with tf.control_dependencies(
tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
learning_rate = tf.train.exponential_decay(
learning_rate=FLAGS.learning_rate,
global_step=cnn.global_step,
decay_steps=FLAGS.decay_steps,
decay_rate=FLAGS.decay_rate,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate)
grads, variables = zip(*optimizer.compute_gradients(cnn.loss))
grads, _ = tf.clip_by_global_norm(grads,
clip_norm=FLAGS.norm_ratio)
train_op = optimizer.apply_gradients(
zip(grads, variables),
global_step=cnn.global_step,
name="train_op")
# Keep track of gradient values and sparsity (optional)
grad_summaries = []
for g, v in zip(grads, variables):
if g is not None:
grad_hist_summary = tf.summary.histogram(
"{0}/grad/hist".format(v.name), g)
sparsity_summary = tf.summary.scalar(
"{0}/grad/sparsity".format(v.name),
tf.nn.zero_fraction(g))
grad_summaries.append(grad_hist_summary)
grad_summaries.append(sparsity_summary)
grad_summaries_merged = tf.summary.merge(grad_summaries)
# Output directory for models and summaries
if FLAGS.train_or_restore == 'R':
MODEL = input("☛ Please input the checkpoints model you want "
"to restore, it should be like(1490175368): ")
# The model you want to restore
while not (MODEL.isdigit() and len(MODEL) == 10):
MODEL = input("✘ The format of your input is illegal, "
"please re-input: ")
logger.info("✔︎ The format of your input is legal, "
"now loading to next step...")
out_dir = os.path.abspath(
os.path.join(
"/home/zachary/hdd/OneLabelTextCNN", # os.path.curdir
"runs",
MODEL))
logger.info("✔︎ Writing to {0}\n".format(out_dir))
else:
timestamp = str(int(time.time()))
out_dir = os.path.abspath(
os.path.join("/home/zachary/hdd/OneLabelTextCNN", "runs",
timestamp))
logger.info("✔︎ Writing to {0}\n".format(out_dir))
checkpoint_dir = os.path.abspath(
os.path.join(out_dir, "checkpoints"))
best_checkpoint_dir = os.path.abspath(
os.path.join(out_dir, "bestcheckpoints"))
# Summaries for loss
loss_summary = tf.summary.scalar("loss", cnn.loss)
# Train summaries
train_summary_op = tf.summary.merge(
[loss_summary, grad_summaries_merged])
train_summary_dir = os.path.join(out_dir, "summaries", "train")
train_summary_writer = tf.summary.FileWriter(
train_summary_dir, sess.graph)
# Validation summaries
validation_summary_op = tf.summary.merge([loss_summary])
validation_summary_dir = os.path.join(out_dir, "summaries",
"validation")
validation_summary_writer = tf.summary.FileWriter(
validation_summary_dir, sess.graph)
saver = tf.train.Saver(tf.global_variables(),
max_to_keep=FLAGS.num_checkpoints)
# best_saver = checkpoints.BestCheckpointSaver(
# save_dir=best_checkpoint_dir,
# num_to_keep=3,
# maximize=True)
if FLAGS.train_or_restore == 'R':
# Load cnn model
logger.info("✔︎ Loading model...")
checkpoint_file = tf.train.latest_checkpoint(checkpoint_dir)
logger.info(checkpoint_file)
# Load the saved meta graph and restore variables
saver = tf.train.import_meta_graph(
"{0}.meta".format(checkpoint_file))
saver.restore(sess, checkpoint_file)
else:
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
# Embedding visualization config
config = projector.ProjectorConfig()
embedding_conf = config.embeddings.add()
embedding_conf.tensor_name = "embedding"
embedding_conf.metadata_path = FLAGS.metadata_file
projector.visualize_embeddings(train_summary_writer, config)
projector.visualize_embeddings(validation_summary_writer,
config)
# Save the embedding visualization
saver.save(
sess, os.path.join(out_dir, "embedding", "embedding.ckpt"))
current_step = sess.run(cnn.global_step)
print("current_step: ", current_step)
def train_step(x_batch_gov, x_batch_art, y_batch):
"""A single training step"""
feed_dict = {
cnn.input_x_gov: x_batch_gov,
cnn.input_x_art: x_batch_art,
cnn.input_y: y_batch,
cnn.dropout_keep_prob: FLAGS.dropout_keep_prob,
cnn.is_training: True
}
_, step, \
summaries, \
loss, \
scores, \
input_y = sess.run(
[train_op,
cnn.global_step,
train_summary_op,
cnn.loss,
cnn.scores,
cnn.input_y],
feed_dict)
count_label_one, \
count_label_zero,\
count_correct_one, \
count_correct_zero = count_correct_pred(scores, input_y)
print("'[TRAIN] num_correct_one is {} out of {}".format(
count_correct_one, count_label_one))
print("'[TRAIN] num_correct_zero is {} out of {}".format(
count_correct_zero, count_label_zero))
logger.info("step {0}: loss {1:g}".format(step, loss))
train_summary_writer.add_summary(summaries, step)
return loss
def validation_step(_x_val_gov, _x_val_art, _y_val, writer=None):
print("_x_val_gov: ", len(_x_val_gov))
print("_x_val_art: ", len(_x_val_art))
"""Evaluates model on a validation set"""
batches_validation = \
feed.batch_iter(
list(zip(_x_val_gov,
_x_val_art,
_y_val)),
FLAGS.batch_size,
num_epochs=1,
shuffle=False)
_eval_counter, _eval_loss = 0, 0.0
_eval_pre_tk = [0.0] * FLAGS.top_num
_eval_rec_tk = [0.0] * FLAGS.top_num
_eval_F_tk = [0.0] * FLAGS.top_num
true_onehot_labels = []
predicted_onehot_scores = []
predicted_onehot_labels_ts = []
predicted_onehot_labels_tk = [[] for _ in range(FLAGS.top_num)]
valid_count_correct_one = 0
valid_count_label_one = 0
valid_count_correct_zero = 0
valid_count_label_zero = 0
valid_step_count = 0
for batch_validation in batches_validation:
valid_step_count += 1
x_batch_val_gov, x_batch_val_art, y_batch_val = \
zip(*batch_validation)
feed_dict = {
cnn.input_x_gov: x_batch_val_gov,
cnn.input_x_art: x_batch_val_art,
cnn.input_y: y_batch_val,
cnn.dropout_keep_prob: 1.0,
cnn.is_training: False
}
step, \
summaries, \
scores, \
cur_loss, \
input_y = sess.run(
[cnn.global_step,
validation_summary_op,
cnn.scores,
cnn.loss,
cnn.input_y],
feed_dict)
count_label_one, \
count_label_zero, \
count_correct_one, \
count_correct_zero = count_correct_pred(scores,
input_y)
valid_count_correct_one += count_correct_one
valid_count_label_one += count_label_one
valid_count_correct_zero += count_correct_zero
valid_count_label_zero += count_label_zero
print("[VALID] num_correct_answer is {} out of {}".format(
count_correct_one, count_label_one))
print("[VALID] num_correct_answer is {} out of {}".format(
count_correct_zero, count_label_zero))
# Prepare for calculating metrics
for i in y_batch_val:
true_onehot_labels.append(i)
for j in scores:
predicted_onehot_scores.append(j)
# Predict by threshold
batch_predicted_onehot_labels_ts = \
feed.get_onehot_label_threshold(scores=scores,
threshold=FLAGS.
threshold)
for k in batch_predicted_onehot_labels_ts:
predicted_onehot_labels_ts.append(k)
# Predict by topK
for _top_num in range(FLAGS.top_num):
batch_predicted_onehot_labels_tk = feed.\
get_onehot_label_topk(scores=scores,
top_num=_top_num + 1)
for i in batch_predicted_onehot_labels_tk:
predicted_onehot_labels_tk[_top_num].append(i)
_eval_loss = _eval_loss + cur_loss
_eval_counter = _eval_counter + 1
if writer:
writer.add_summary(summaries, step)
logger.info("[VALID_FINAL] Total Correct One Answer is {} out "
"of {}".format(valid_count_correct_one,
valid_count_label_one))
logger.info("[VALID_FINAL] Total Correct Zero Answer is {} "
"out of {}".format(valid_count_correct_zero,
valid_count_label_zero))
_eval_loss = float(_eval_loss / _eval_counter)
# Calculate Precision & Recall & F1 (threshold & topK)
_eval_pre_ts = precision_score(
y_true=np.array(true_onehot_labels),
y_pred=np.array(predicted_onehot_labels_ts),
average='micro')
_eval_rec_ts = recall_score(
y_true=np.array(true_onehot_labels),
y_pred=np.array(predicted_onehot_labels_ts),
average='micro')
_eval_F_ts = f1_score(
y_true=np.array(true_onehot_labels),
y_pred=np.array(predicted_onehot_labels_ts),
average='micro')
for _top_num in range(FLAGS.top_num):
_eval_pre_tk[_top_num] = precision_score(
y_true=np.array(true_onehot_labels),
y_pred=np.array(predicted_onehot_labels_tk[_top_num]),
average='micro')
_eval_rec_tk[_top_num] = recall_score(
y_true=np.array(true_onehot_labels),
y_pred=np.array(predicted_onehot_labels_tk[_top_num]),
average='micro')
_eval_F_tk[_top_num] = f1_score(
y_true=np.array(true_onehot_labels),
y_pred=np.array(predicted_onehot_labels_tk[_top_num]),
average='micro')
# Calculate the average AUC
_eval_auc = roc_auc_score(
y_true=np.array(true_onehot_labels),
y_score=np.array(predicted_onehot_scores),
average='micro')
# Calculate the average PR
_eval_prc = average_precision_score(
y_true=np.array(true_onehot_labels),
y_score=np.array(predicted_onehot_scores),
average='micro')
return _eval_loss, _eval_auc, _eval_prc, _eval_rec_ts, \
_eval_pre_ts, _eval_F_ts, _eval_rec_tk, _eval_pre_tk, \
_eval_F_tk
# Generate batches
batches_train = feed.batch_iter(
list(zip(x_train_gov, x_train_art, y_train)), FLAGS.batch_size,
FLAGS.num_epochs)
num_batches_per_epoch = \
int((len(x_train_gov) - 1) / FLAGS.batch_size) + 1
# Training loop. For each batch...
train_loss_tracker = 0
for batch_train in batches_train:
x_batch_train_gov, \
x_batch_train_art, \
y_batch_train = zip(*batch_train)
# print(x_batch_train_gov[0][100:150])
# print("x_batch_train_gov.shape", len(list(
# x_batch_train_gov)))
#
# print(x_batch_train_art[0][100:150])
# print("x_batch_train_art.shape", len(list(
# x_batch_train_art)))
one_batch_loss = train_step(x_batch_train_gov,
x_batch_train_art, y_batch_train)
train_loss_tracker += one_batch_loss
current_step = tf.train.global_step(sess, cnn.global_step)
if current_step % FLAGS.evaluate_every == 0:
logger.info("\nEvaluation:")
eval_loss, \
eval_auc, \
eval_prc, \
eval_rec_ts, \
eval_pre_ts, \
eval_F_ts, \
eval_rec_tk, \
eval_pre_tk, \
eval_F_tk = \
validation_step(x_val_gov,
x_val_art,
y_val,
writer=validation_summary_writer)
logger.info(
"All Validation set: Loss {0:g} | AUC {1:g} | AUPRC {2:g}"
.format(eval_loss, eval_auc, eval_prc))
logger.info("Train Loss: {}".format(train_loss_tracker /
FLAGS.evaluate_every))
train_loss_tracker = 0
# Predict by threshold
logger.info(
"☛ Predict by threshold: Precision {0:g}, Recall {1:g}, "
"F {2:g}".format(eval_pre_ts, eval_rec_ts, eval_F_ts))
# Predict by topK
logger.info("☛ Predict by topK:")
for top_num in range(FLAGS.top_num):
logger.info(
"Top{0}: Precision {1:g}, Recall {2:g}, F {3:g}".
format(top_num + 1, eval_pre_tk[top_num],
eval_rec_tk[top_num], eval_F_tk[top_num]))
# best_saver.handle(eval_prc, sess, current_step)
if current_step % FLAGS.checkpoint_every == 0:
checkpoint_prefix = os.path.join(checkpoint_dir, "model")
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
logger.info(
"✔︎ Saved model checkpoint to {0}\n".format(path))
if current_step % num_batches_per_epoch == 0:
current_epoch = current_step // num_batches_per_epoch
logger.info(
"✔︎ Epoch {0} has finished!".format(current_epoch))
logger.info("✔︎ Done.")
def adjective_embeddings(data_file, embeddings_file_name, num_steps,
embedding_dim):
with open(data_file) as f:
f_list = f.read().split()
vocabulary_size = 5000
batch_size = 64
embedding_size = embedding_dim
skip_window = 3
num_samples = 4
learning_rate = 0.002 # How many times to reuse an input to generate a label.
num_sampled = 64 # Sample size for negative examples.
global data_index
logs_path = './log/'
data, count, dictionary, reverse_dictionary = build_dataset(
f_list, vocabulary_size)
# Specification of test Sample:
sample_size = 20 # Random sample of words to evaluate similarity.
sample_window = 100 # Only pick samples in the head of the distribution.
sample_examples = np.random.choice(
sample_window, sample_size,
replace=False) # Randomly pick a sample of size 16
graph = tf.Graph()
#Constructing the graph...
with graph.as_default():
with tf.device('/cpu:0'):
# Placeholders to read input data.
with tf.name_scope('Inputs'):
train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])
# Look up embeddings for inputs.
with tf.name_scope('Embeddings'):
sample_dataset = tf.constant(sample_examples, dtype=tf.int32)
embeddings = tf.Variable(
tf.random_uniform([vocabulary_size, embedding_size], -1.0,
1.0))
embed = tf.nn.embedding_lookup(embeddings, train_inputs)
# Construct the variables for the NCE loss
nce_weights = tf.Variable(
tf.truncated_normal([vocabulary_size, embedding_size],
stddev=1.0 /
math.sqrt(embedding_size)))
nce_biases = tf.Variable(tf.zeros([vocabulary_size]))
# Compute the average NCE loss for the batch.
# tf.nce_loss automatically draws a new sample of the negative labels each
# time we evaluate the loss.
with tf.name_scope('Loss'):
loss = tf.reduce_mean(
tf.nn.sampled_softmax_loss(weights=nce_weights,
biases=nce_biases,
labels=train_labels,
inputs=embed,
num_sampled=num_sampled,
num_classes=vocabulary_size))
# Construct the Gradient Descent optimizer using a learning rate of 0.01.
with tf.name_scope('Gradient_Descent'):
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(
loss)
# Normalize the embeddings to avoid overfitting.
with tf.name_scope('Normalization'):
norm = tf.sqrt(
tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True))
normalized_embeddings = embeddings / norm
sample_embeddings = tf.nn.embedding_lookup(normalized_embeddings,
sample_dataset)
similarity = tf.matmul(sample_embeddings,
normalized_embeddings,
transpose_b=True)
# Add variable initializer.
init = tf.global_variables_initializer()
# Create a summary to monitor cost tensor
tf.summary.scalar("cost", loss)
# Merge all summary variables.
merged_summary_op = tf.summary.merge_all()
with tf.Session(graph=graph) as session:
# We must initialize all variables before we use them.
session.run(init)
summary_writer = tf.summary.FileWriter(logs_path,
graph=tf.get_default_graph())
print('Initializing the model')
average_loss = 0
for step in range(num_steps):
batch_inputs, batch_labels = generate_batch(
batch_size, num_samples, skip_window, data)
feed_dict = {
train_inputs: batch_inputs,
train_labels: batch_labels
}
# We perform one update step by evaluating the optimizer op using session.run()
_, loss_val, summary = session.run(
[optimizer, loss, merged_summary_op], feed_dict=feed_dict)
summary_writer.add_summary(summary, step)
average_loss += loss_val
if step % 5000 == 0:
if step > 0:
average_loss /= 5000
# The average loss is an estimate of the loss over the last 5000 batches.
print('Average loss at step ', step, ': ', average_loss)
average_loss = 0
# Evaluate similarity after every 10000 iterations.
if step % 10000 == 0:
nlp = spacy.load('en')
sim = similarity.eval() #
for i in range(sample_size):
sample_word = reverse_dictionary[sample_examples[i]]
doc = nlp(sample_word)
for token in doc:
if token.pos_ == "ADJ":
top_k = 10 # Look for top-10 neighbours for words in sample set.
nearest = (-sim[i, :]).argsort()[1:top_k + 1]
log_str = 'Nearest to %s:' % sample_word
for k in range(top_k):
close_word = reverse_dictionary[nearest[k]]
log_str = '%s %s,' % (log_str, close_word)
print(log_str)
print()
final_embeddings = normalized_embeddings.eval()
with open(embeddings_file_name, 'w', encoding="utf-8") as file:
file.write(str(len(dictionary)))
file.write(' ')
file.write(str(embedding_dim))
file.write('\n')
i = 0
for key in dictionary:
file.write(key)
file.write(' ')
for j in final_embeddings[i]:
file.write('{:.6f}'.format(j))
# file.write(str(round(int(j),6)))
file.write(' ')
file.write('\n')
i += 1
def main(unused_argv):
tf.logging.set_verbosity(tf.logging.INFO)
# Get dataset-dependent information.
dataset = segmentation_dataset.get_dataset(FLAGS.dataset,
FLAGS.eval_split,
dataset_dir=FLAGS.dataset_dir)
tf.gfile.MakeDirs(FLAGS.eval_logdir)
tf.logging.info('Evaluating on %s set', FLAGS.eval_split)
with tf.Graph().as_default():
samples = input_generator.get(dataset,
FLAGS.eval_crop_size,
FLAGS.eval_batch_size,
min_resize_value=FLAGS.min_resize_value,
max_resize_value=FLAGS.max_resize_value,
resize_factor=FLAGS.resize_factor,
dataset_split=FLAGS.eval_split,
is_training=False,
model_variant=FLAGS.model_variant)
model_options = common.ModelOptions(
outputs_to_num_classes={common.OUTPUT_TYPE: dataset.num_classes},
crop_size=FLAGS.eval_crop_size,
atrous_rates=FLAGS.atrous_rates,
output_stride=FLAGS.output_stride)
if tuple(FLAGS.eval_scales) == (1.0, ):
tf.logging.info('Performing single-scale test.')
predictions = model.predict_labels(
samples[common.IMAGE],
model_options,
image_pyramid=FLAGS.image_pyramid)
else:
tf.logging.info('Performing multi-scale test.')
predictions = model.predict_labels_multi_scale(
samples[common.IMAGE],
model_options=model_options,
eval_scales=FLAGS.eval_scales,
add_flipped_images=FLAGS.add_flipped_images)
predictions = predictions[common.OUTPUT_TYPE]
predictions = tf.reshape(predictions, shape=[-1])
labels = tf.reshape(samples[common.LABEL], shape=[-1])
weights = tf.to_float(tf.not_equal(labels, dataset.ignore_label))
# Set ignore_label regions to label 0, because metrics.mean_iou requires
# range of labels = [0, dataset.num_classes). Note the ignore_label regions
# are not evaluated since the corresponding regions contain weights = 0.
labels = tf.where(tf.equal(labels, dataset.ignore_label),
tf.zeros_like(labels), labels)
predictions_tag = 'miou'
for eval_scale in FLAGS.eval_scales:
predictions_tag += '_' + str(eval_scale)
if FLAGS.add_flipped_images:
predictions_tag += '_flipped'
# Define the evaluation metric.
metric_map = {}
metric_map[predictions_tag] = tf.metrics.mean_iou(predictions,
labels,
dataset.num_classes,
weights=weights)
metrics_to_values, metrics_to_updates = (
tf.contrib.metrics.aggregate_metric_map(metric_map))
for metric_name, metric_value in six.iteritems(metrics_to_values):
slim.summaries.add_scalar_summary(metric_value,
metric_name,
print_summary=True)
num_batches = int(
math.ceil(dataset.num_samples / float(FLAGS.eval_batch_size)))
tf.logging.info('Eval num images %d', dataset.num_samples)
tf.logging.info('Eval batch size %d and num batch %d',
FLAGS.eval_batch_size, num_batches)
num_eval_iters = None
if FLAGS.max_number_of_evaluations > 0:
num_eval_iters = FLAGS.max_number_of_evaluations
slim.evaluation.evaluation_loop(
master=FLAGS.master,
checkpoint_dir=FLAGS.checkpoint_dir,
logdir=FLAGS.eval_logdir,
num_evals=num_batches,
eval_op=list(metrics_to_updates.values()),
max_number_of_evaluations=num_eval_iters,
eval_interval_secs=FLAGS.eval_interval_secs)
def optimize(content_targets,
style_target,
content_weight,
style_weight,
tv_weight,
vgg_path,
epochs=2,
print_iterations=1000,
batch_size=4,
save_path='saver/fns.ckpt',
slow=False,
learning_rate=1e-3,
debug=True):
if slow:
batch_size = 1
mod = len(content_targets) % batch_size
if mod > 0:
print("Train set has been trimmed slightly..")
content_targets = content_targets[:-mod]
style_features = {}
batch_shape = (batch_size, 256, 256, 3)
style_shape = (1, ) + style_target.shape
print(style_shape)
# precompute style features
with tf.Graph().as_default(), tf.device('/cpu:0'), tf.Session() as sess:
style_image = tf.placeholder(tf.float32,
shape=style_shape,
name='style_image')
style_image_pre = vgg.preprocess(style_image)
net = vgg.net(vgg_path, style_image_pre)
style_pre = np.array([style_target])
for layer in STYLE_LAYERS:
features = net[layer].eval(feed_dict={style_image: style_pre})
features = np.reshape(features, (-1, features.shape[3]))
gram = np.matmul(features.T, features) / features.size
style_features[layer] = gram
with tf.Graph().as_default(), tf.Session() as sess:
X_content = tf.placeholder(tf.float32,
shape=batch_shape,
name="X_content")
X_pre = vgg.preprocess(X_content)
# precompute content features
content_features = {}
content_net = vgg.net(vgg_path, X_pre)
content_features[CONTENT_LAYER] = content_net[CONTENT_LAYER]
if slow:
preds = tf.Variable(
tf.random_normal(X_content.get_shape()) * 0.256)
preds_pre = preds
else:
preds = transform.net(X_content / 255.0)
preds_pre = vgg.preprocess(preds)
net = vgg.net(vgg_path, preds_pre)
content_size = _tensor_size(
content_features[CONTENT_LAYER]) * batch_size
assert _tensor_size(content_features[CONTENT_LAYER]) == _tensor_size(
net[CONTENT_LAYER])
content_loss = content_weight * (
2 * tf.nn.l2_loss(net[CONTENT_LAYER] -
content_features[CONTENT_LAYER]) / content_size)
style_losses = []
for style_layer in STYLE_LAYERS:
layer = net[style_layer]
bs, height, width, filters = map(lambda i: i.value,
layer.get_shape())
size = height * width * filters
feats = tf.reshape(layer, (bs, height * width, filters))
feats_T = tf.transpose(feats, perm=[0, 2, 1])
grams = tf.matmul(feats_T, feats) / size
style_gram = style_features[style_layer]
style_losses.append(2 * tf.nn.l2_loss(grams - style_gram) /
style_gram.size)
style_loss = style_weight * functools.reduce(tf.add,
style_losses) / batch_size
# total variation denoising
tv_y_size = _tensor_size(preds[:, 1:, :, :])
tv_x_size = _tensor_size(preds[:, :, 1:, :])
y_tv = tf.nn.l2_loss(preds[:, 1:, :, :] -
preds[:, :batch_shape[1] - 1, :, :])
x_tv = tf.nn.l2_loss(preds[:, :, 1:, :] -
preds[:, :, :batch_shape[2] - 1, :])
tv_loss = tv_weight * 2 * (x_tv / tv_x_size +
y_tv / tv_y_size) / batch_size
loss = content_loss + style_loss + tv_loss
# overall loss
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
sess.run(tf.global_variables_initializer())
import random
uid = random.randint(1, 100)
print("UID: %s" % uid)
for epoch in range(epochs):
num_examples = len(content_targets)
iterations = 0
while iterations * batch_size < num_examples:
start_time = time.time()
curr = iterations * batch_size
step = curr + batch_size
X_batch = np.zeros(batch_shape, dtype=np.float32)
for j, img_p in enumerate(content_targets[curr:step]):
X_batch[j] = get_img(img_p,
(256, 256, 3)).astype(np.float32)
iterations += 1
assert X_batch.shape[0] == batch_size
feed_dict = {X_content: X_batch}
print("start training")
train_step.run(feed_dict=feed_dict)
end_time = time.time()
delta_time = end_time - start_time
if debug:
print("UID: %s, batch time: %s" % (uid, delta_time))
is_print_iter = int(iterations) % print_iterations == 0
if slow:
is_print_iter = epoch % print_iterations == 0
is_last = epoch == epochs - 1 and iterations * batch_size >= num_examples
should_print = is_print_iter or is_last
if should_print:
to_get = [style_loss, content_loss, tv_loss, loss, preds]
test_feed_dict = {X_content: X_batch}
tup = sess.run(to_get, feed_dict=test_feed_dict)
_style_loss, _content_loss, _tv_loss, _loss, _preds = tup
losses = (_style_loss, _content_loss, _tv_loss, _loss)
if slow:
_preds = vgg.unprocess(_preds)
else:
saver = tf.train.Saver()
res = saver.save(sess, save_path)
yield (_preds, losses, iterations, epoch)
def __init__(self,
dim_x1,
dim_x2,
dim_z,
dim_y,
num_examples,
num_lab,
num_batches,
p_x1='gaussian',
p_x2='gaussian',
q_z='gaussian_mixture_marg',
p_z='gaussian_marg',
hidden_layers_px1=[250],
hidden_layers_px2=[250],
hidden_layers_qz=[250],
hidden_layers_qy=[250],
nonlin_px1=tf.nn.softplus,
nonlin_px2=tf.nn.softplus,
nonlin_qz=tf.nn.softplus,
nonlin_qy=tf.nn.softplus,
beta=0.1,
l2_loss=0.0,
zeta_reg=1e6):
self.dim_x1, self.dim_x2, self.dim_z, self.dim_y = dim_x1, dim_x2, dim_z, dim_y
self.zeta_reg = zeta_reg
self.distributions = {
'p_x1': p_x1,
'p_x2': p_x2,
'q_z': q_z,
'p_z': p_z,
'p_y': 'uniform'
}
self.num_examples = num_examples
self.num_batches = num_batches
self.num_lab = num_lab
self.num_ulab = self.num_examples - num_lab
# assert self.num_lab % self.num_batches == 0, '#Labelled % #Batches != 0'
# assert self.num_ulab % self.num_batches == 0, '#Unlabelled % #Batches != 0'
# assert self.num_examples % self.num_batches == 0, '#Examples % #Batches != 0'
self.num_lab_batch = self.num_lab // self.num_batches
self.num_ulab_batch = self.num_ulab // self.num_batches
self.batch_size = self.num_examples // self.num_batches
# self.alpha = beta * ( float(self.batch_size) / self.num_lab_batch )
self.alpha = beta * float(self.batch_size)
''' Create Graph '''
self.G = tf.Graph()
with self.G.as_default():
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.01)
return tf.Variable(initial)
# zeta = weight_variable([2])
init_value = (np.sqrt(1.0 / 2)).astype('float32')
zeta = tf.Variable(tf.constant(init_value, shape=[2]))
# zeta = tf.constant(init_value, shape=[2])
zeta = zeta * zeta
self.zeta1 = zeta[0]
self.zeta2 = zeta[1]
self.x1_labelled_mu = tf.placeholder(tf.float32,
[None, self.dim_x1])
self.x1_labelled_lsgms = tf.placeholder(tf.float32,
[None, self.dim_x1])
self.x1_unlabelled_mu = tf.placeholder(tf.float32,
[None, self.dim_x1])
self.x1_unlabelled_lsgms = tf.placeholder(tf.float32,
[None, self.dim_x1])
self.x2_labelled_mu = tf.placeholder(tf.float32,
[None, self.dim_x2])
self.x2_labelled_lsgms = tf.placeholder(tf.float32,
[None, self.dim_x2])
self.x2_unlabelled_mu = tf.placeholder(tf.float32,
[None, self.dim_x2])
self.x2_unlabelled_lsgms = tf.placeholder(tf.float32,
[None, self.dim_x2])
self.y_lab = tf.placeholder(tf.float32, [None, self.dim_y])
self.classifier = FullyConnected(dim_output=self.dim_y,
hidden_layers=hidden_layers_qy,
nonlinearity=nonlin_qy,
l2loss=l2_loss)
self.encoder_1 = FullyConnected(dim_output=2 * self.dim_z,
hidden_layers=hidden_layers_qz,
nonlinearity=nonlin_qz,
l2loss=l2_loss)
self.encoder_2 = FullyConnected(dim_output=2 * self.dim_z,
hidden_layers=hidden_layers_qz,
nonlinearity=nonlin_qz,
l2loss=l2_loss)
self.decoder_1 = FullyConnected(dim_output=2 * self.dim_x1,
hidden_layers=hidden_layers_px1,
nonlinearity=nonlin_px1,
l2loss=l2_loss)
self.decoder_2 = FullyConnected(dim_output=2 * self.dim_x2,
hidden_layers=hidden_layers_px2,
nonlinearity=nonlin_px2,
l2loss=l2_loss)
self._objective()
self.saver = tf.train.Saver(write_version=tf.train.SaverDef.V1)
self.session = tf.Session()
# After that, load the testing set. # # ---------------------------------------------------------------------------------------------------------- # X_train, y_train, classes_train = load_multiclass_dataset(TRAIN_FOLDER, IMAGE_HEIGHT, IMAGE_WIDTH, NUM_CHANNELS) X_train = X_train/255.#.reshape(-1, IMAGE_HEIGHT*IMAGE_WIDTH*NUM_CHANNELS)/255. X_train, y_train = shuffle(X_train, y_train, seed=42) X_train, y_train, X_val, y_val = split(X_train, y_train, SPLIT_RATE) print(X_train.shape, y_train.shape, X_val.shape, y_val.shape) # ---------------------------------------------------------------------------------------------------------- # # Description: # # Create a training graph that receives a batch of images and their respective labels and run a # # training iteration or an inference job. Train the last FC layer using fine_tuning_op or the entire # # network using full_backprop_op. A weight decay of 1e-4 is used for full_backprop_op only. # # ---------------------------------------------------------------------------------------------------------- # graph = tf.Graph() with graph.as_default(): X = tf.placeholder(tf.float32, shape = (None, IMAGE_HEIGHT, IMAGE_WIDTH, NUM_CHANNELS)) y = tf.placeholder(tf.int64, shape = (None,)) y_one_hot = tf.one_hot(y, len(classes_train)) learning_rate = tf.placeholder(tf.float32) is_training = tf.placeholder(tf.bool) print(X.shape) out = tf.layers.conv2d(X, 64, (3, 3), (2, 2), padding='valid', activation=tf.nn.relu) print(out.shape) out = tf.layers.max_pooling2d(out, (2, 2), (2, 2), padding='valid') print(out.shape) out = tf.layers.conv2d(out, 128, (3, 3), (2, 2), padding='valid', activation=tf.nn.relu) print(out.shape) out = tf.layers.max_pooling2d(out, (2, 2), (2, 2), padding='valid') print(out.shape)
def train():
"""Train CIFAR-10 for a number of steps."""
with tf.Graph().as_default():
global_step = tf.Variable(0, trainable=False)
# Get images and labels for CIFAR-10.
images, labels = cifar10.distorted_inputs()
# Build a Graph that computes the logits predictions from the
# inference model.
logits = cifar10.inference(images)
# Calculate loss.
loss = cifar10.loss(logits, labels)
# Build a Graph that trains the model with one batch of examples and
# updates the model parameters.
train_op = cifar10.train(loss, global_step)
# Create a saver.
saver = tf.train.Saver(tf.all_variables())
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Build an initialization operation to run below.
init = tf.global_variables_initializer()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(
log_device_placement=FLAGS.log_device_placement))
sess.run(init)
# Start the queue runners.
tf.train.start_queue_runners(sess=sess)
summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)
for step in xrange(FLAGS.max_steps):
start_time = time.time()
_, loss_value = sess.run([train_op, loss])
duration = time.time() - start_time
assert not np.isnan(loss_value), 'Model diverged with loss = NaN'
if step % 10 == 0:
num_examples_per_step = FLAGS.batch_size
examples_per_sec = num_examples_per_step / duration
sec_per_batch = float(duration)
format_str = (
'%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '
'sec/batch)')
print(format_str % (datetime.now(), step, loss_value,
examples_per_sec, sec_per_batch))
if step % 100 == 0:
summary_str = sess.run(summary_op)
summary_writer.add_summary(summary_str, step)
# Save the model checkpoint periodically.
if step % 1000 == 0 or (step + 1) == FLAGS.max_steps:
checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
def main(args):
sleep(random.random())
output_dir = os.path.expanduser(args.output_dir)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# 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, output_dir, ' '.join(sys.argv))
dataset = facenet.get_dataset(args.input_dir)
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, None)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
# Add a random key to the filename to allow alignment using multiple processes
random_key = np.random.randint(0, high=99999)
bounding_boxes_filename = os.path.join(output_dir, 'bounding_boxes_%05d.txt' % random_key)
with open(bounding_boxes_filename, "w") as text_file:
nrof_images_total = 0
nrof_successfully_aligned = 0
if args.random_order:
random.shuffle(dataset)
for cls in dataset:
output_class_dir = os.path.join(output_dir, cls.name)
if not os.path.exists(output_class_dir):
os.makedirs(output_class_dir)
if args.random_order:
random.shuffle(cls.image_paths)
for image_path in cls.image_paths:
nrof_images_total += 1
filename = os.path.splitext(os.path.split(image_path)[1])[0]
output_filename = os.path.join(output_class_dir, filename + '.png')
print(image_path)
if not os.path.exists(output_filename):
try:
img = imageio.imread(image_path)
except (IOError, ValueError, IndexError) as e:
errorMessage = '{}: {}'.format(image_path, e)
print(errorMessage)
else:
if img.ndim < 2:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
continue
if img.ndim == 2:
img = facenet.to_rgb(img)
img = img[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
bounding_box_size = (det[:, 2] - det[:, 0]) * (det[:, 3] - det[:, 1])
img_center = img_size / 2
offsets = np.vstack([(det[:, 0] + det[:, 2]) / 2 - img_center[1],
(det[:, 1] + det[:, 3]) / 2 - img_center[0]])
offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
index = np.argmax(
bounding_box_size - offset_dist_squared * 2.0) # some extra weight on the centering
det = det[index, :]
det = np.squeeze(det)
bb = np.zeros(4, dtype=np.int32)
# print(det[0], det[1], det[2], det[3])
bb[0] = np.maximum(det[0] - args.margin / 2, 0)
bb[1] = np.maximum(det[1] - args.margin / 2, 0)
bb[2] = np.minimum(det[2] + args.margin / 2, img_size[1])
bb[3] = np.minimum(det[3] + args.margin / 2, img_size[0])
# print(bb)
cropped = img[bb[1]:bb[3], bb[0]:bb[2], :]
# scaled = misc.imresize(cropped, (args.image_size, args.image_size), interp='bilinear')
scaled = np.array(Image.fromarray(cropped).resize((args.image_size, args.image_size)))
'''
img = scipy.misc.imresize(myImage, size=(num_px, num_px))
img = np.array(Image.fromarray(myImage).resize((num_px, num_px)))'''
nrof_successfully_aligned += 1
imageio.imsave(output_filename, scaled)
text_file.write('%s %d %d %d %d\n' % (output_filename, bb[0], bb[1], bb[2], bb[3]))
else:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
print('Total number of images: %d' % nrof_images_total)
print('Number of successfully aligned images: %d' % nrof_successfully_aligned)
def start_training(datas):
if not tf.gfile.Exists(train_log_dir):
tf.gfile.MakeDirs(train_log_dir)
with tf.Graph().as_default():
# Set up the data loading:
feature = tf.placeholder(dtype=tf.float32, shape=[None, 10])
power = tf.placeholder(dtype=tf.float32, shape=[None, 1])
# Define the model:
predictions = inference(feature)
# Specify the loss function:
absloss = tf.reduce_mean(tf.abs(power-predictions))
sqloss = tf.reduce_mean(tf.square(power - predictions))
slim.losses.add_loss(absloss)
total_loss = slim.losses.get_total_loss() # tf.losses.get_total_loss() #
# Specify the optimization scheme:
global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(0.07, global_step, 100, 0.999)
ema = tf.train.ExponentialMovingAverage(0.99, global_step)
average_op = ema.apply(tf.trainable_variables())
train_step = tf.train.AdamOptimizer(learning_rate=learning_rate) \
.minimize(total_loss, global_step=global_step)
train_op = tf.group(train_step, average_op)
# initialize var in graph`
sess = tf.Session()
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer()) # the local var is for update_op
sess.run(init_op)
# train and test data
train_indices = np.random.choice(datas.shape[0], round(datas.shape[0] * 0.9), replace=False)
test_indices = np.array(list(set(range(datas.shape[0])) - set(train_indices)))
data = datas[train_indices, :]
datat = datas[test_indices, :]
# Main Loop
restart = 0
num = data.shape[0]
shuffled_data = 0.0
start = 0
end = BATCH
for step in range(1, STEPS+1):
if step == 1 or restart:
# print('Step:%d: Start Again!!!' % sess.run(global_step))
restart = 0
start = 0
end = BATCH
permutation = np.random.permutation(num)
shuffled_data = data[permutation, :]
# print(shuffled_data[start:end, 0].reshape((end-start, 1)).shape)
_, loss_, mean_absolute_loss_ = sess.run([train_op, sqloss, absloss], feed_dict={
feature: shuffled_data[start:end, 1:11],
power: shuffled_data[start:end, 0].reshape((end-start, 1))
})
start += BATCH
end += BATCH
if end >= num:
restart = 1
end = num
if step % 1000 == 0:
# Apply the Moving Average Variables
saver = tf.train.Saver()
saver.save(sess, train_log_dir + '\model.ckpt')
saver = tf.train.Saver(ema.variables_to_restore())
saver.restore(sess, train_log_dir + '\model.ckpt')
# Test the model
loss_t, mean_absolute_loss_t = sess.run([sqloss, absloss], feed_dict={
feature: datat[:, 1:11],
power: datat[:, 0].reshape((datat.shape[0], 1))
})
print('STEP:%d'
'\nTrain: SQLOSS:%.6f, Mean_absolute_loss:%.6f'
'\nTest: SQLOSS:%.6f, Mean_absolute_loss:%.6f'
% (step, loss_, mean_absolute_loss_, loss_t, mean_absolute_loss_t))
sess.close()
import tensorflow as tf from preprocessing import process batch = None mini_batch = 9 learning_rate = 0.00000001 beta1 = 0.09 beta2 = 0.099 linear = tf.Graph() with linear.as_default(): train_data = tf.placeholder(tf.float32, [batch, 30]) label_data = tf.placeholder(tf.float32, [batch]) batch_size = tf.placeholder(tf.float32, []) #keep_prob = tf.placeholder(tf.float32, []) layer_1 = tf.contrib.layers.fully_connected(train_data, 2, weights_initializer=tf.zeros_initializer()) #layer_2 = tf.nn.dropout(tf.contrib.layers.fully_connected(layer_1, 20), keep_prob=keep_prob) #layer_3 = tf.contrib.layers.fully_connected(layer_2, 2) #layer_4 = tf.contrib.layers.fully_connected(layer_3, 2) final = tf.nn.softmax(layer_1) probability = tf.reduce_max(final, -1) prediction = tf.argmax(final, -1) train_accuracy = tf.scalar_mul(batch_size, tf.to_float(tf.count_nonzero(tf.cast(tf.equal(tf.to_int64(label_data), prediction), dtype=tf.int64))))
def train():
with tf.Graph().as_default():
with tf.device('/gpu:' + str(GPU_INDEX)):
pointclouds_pl, labels_pl = MODEL.placeholder_inputs(
BATCH_SIZE, NUM_POINT)
is_training_pl = tf.placeholder(tf.bool, shape=())
# Note the global_step=batch parameter to minimize.
# That tells the optimizer to helpfully increment the 'batch' parameter
# for you every time it trains.
batch = tf.get_variable('batch', [],
initializer=tf.constant_initializer(0),
trainable=False)
bn_decay = get_bn_decay(batch)
tf.summary.scalar('bn_decay', bn_decay)
# Get model and loss
pred, end_points = MODEL.get_model(pointclouds_pl,
is_training_pl,
bn_decay=bn_decay,
num_class=NUM_CLASSES)
MODEL.get_loss(pred, labels_pl, end_points)
losses = tf.get_collection('losses')
total_loss = tf.add_n(losses, name='total_loss')
tf.summary.scalar('total_loss', total_loss)
for l in losses + [total_loss]:
tf.summary.scalar(l.op.name, l)
correct = tf.equal(tf.argmax(pred, 1), tf.to_int64(labels_pl))
accuracy = tf.reduce_sum(tf.cast(correct,
tf.float32)) / float(BATCH_SIZE)
tf.summary.scalar('accuracy', accuracy)
print("--- Get training operator")
# Get training operator
learning_rate = get_learning_rate(batch)
tf.summary.scalar('learning_rate', learning_rate)
if OPTIMIZER == 'momentum':
optimizer = tf.train.MomentumOptimizer(learning_rate,
momentum=MOMENTUM)
elif OPTIMIZER == 'adam':
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(total_loss, global_step=batch)
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
# Create a session
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
config.log_device_placement = False
sess = tf.Session(config=config)
# Add summary writers
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(os.path.join(LOG_DIR, 'train'),
sess.graph)
test_writer = tf.summary.FileWriter(os.path.join(LOG_DIR, 'test'),
sess.graph)
# Init variables
init = tf.global_variables_initializer()
sess.run(init)
# saver.restore(sess, os.path.join(LOG_DIR,'model.ckpt'))
# log_string("Model restored.")
ops = {
'pointclouds_pl': pointclouds_pl,
'labels_pl': labels_pl,
'is_training_pl': is_training_pl,
'pred': pred,
'loss': total_loss,
'train_op': train_op,
'merged': merged,
'step': batch,
'end_points': end_points
}
best_acc = -1
for epoch in range(MAX_EPOCH):
log_string('**** EPOCH %03d ****' % (epoch))
sys.stdout.flush()
train_one_epoch(sess, ops, train_writer)
eval_one_epoch(sess, ops, test_writer)
# Save the variables to disk.
# if epoch % 10 == 0:
save_path = saver.save(sess, os.path.join(LOG_DIR, "model.ckpt"))
log_string("Model saved in file: %s" % save_path)
def test_model(self, path, model_name, type_to_restore="SavedModel", show_incorrect=True):
"""
:param path:
:param model_name:
:param type_to_restore: String, "SavedModel" or "SavedSession"
:param show_incorrect: show incorrectly guessed images
:return:
"""
print("\n{}".format("#" * 50))
# self.test_data = self.create_test_data("dataset/test", "test_data", typ="np")
test_imgs, test_lbls = self.test_data[0], self.test_data[1]
test_batch = 5
length = len(test_lbls)
n_correct = 0
total_n = length
with tf.Session(graph=tf.Graph()) as sess:
graph = tf.get_default_graph()
if type_to_restore == "SavedModel":
tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.TRAINING], path + model_name)
else:
saver = tf.train.import_meta_graph(path + model_name)
saver.restore(sess, tf.train.latest_checkpoint(path))
x_img = graph.get_tensor_by_name("x_img:0")
y_lbl = graph.get_tensor_by_name("y_lbl:0")
predictor = graph.get_tensor_by_name("accuracy/prediction:0")
keep_prob = graph.get_tensor_by_name("dropout/keep_prob:0")
i = 0
lngth = len(test_lbls)
while i < lngth:
# ensure that all images in test set are tested, even if final set has size less than `test_batch`
if (lngth - test_batch) >= i:
imgs = test_imgs[i: (i + test_batch)]
lbls = test_lbls[i: (i + test_batch)]
else:
imgs = test_imgs[i:lngth]
lbls = test_lbls[i:lngth]
print("{}\nTest batch {}".format("-" * 15, i / test_batch))
preds = sess.run(predictor, feed_dict={x_img: imgs, keep_prob: 1.0})
truths = np.asarray([t[1] for t in lbls]) # TODO: These indices should match
print("predictions: \t", preds)
print("truths: \t\t", truths)
correct = np.asarray([1 if p == t else 0 for p, t in zip(preds, truths)])
n_correct += sum(correct)
acc = float(sum(correct)) / len(correct)
print("accuracy: {:.3f}".format(acc))
acc_thresh = 0.8
if show_incorrect and acc < acc_thresh:
print("Accuracy less than {}%, displaying incorrect guesses...".format(acc_thresh))
for idx in range(len(correct)):
if correct[idx]:
continue
incorrect_img = imgs[idx]
guess = preds[idx]
# im =
plt.imshow(np.squeeze(incorrect_img, axis=2), cmap='gray')
plt.title(
(TadpoleConvNet.CLASS_ONE, TadpoleConvNet.CLASS_TWO)[guess] + " (false)"
)
plt.show()
i += test_batch # increment i with test_batch step size
accuracy = graph.get_tensor_by_name("accuracy/accuracy:0")
print("test final accuracy: ", sess.run(accuracy, feed_dict={x_img: test_imgs, y_lbl: test_lbls, keep_prob: 1.0}))
print("-" * 30)
print('Final Test Accuracy: {:.6f}'.format(
float(n_correct) / total_n)
)
print("-" * 30)
return float(n_correct) / total_n
def main(args):
with tf.Graph().as_default():
with tf.Session() as sess:
# Read the file containing the pairs used for testing
# 1. 读入之前的pairs.txt文件
# 读入后如[['Abel_Pacheco','1','4']]
pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # 剪裁好了的图片
# Get the paths for the corresponding images
# 获取文件路径和是否匹配关系对
paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext)
print("paths shape =", len(paths)) # 12000
print("paths=", paths[0:200])
print('actual_issame shape=', len(actual_issame)) # 6000
print('actual_issame', actual_issame[0:200])
# Load the model
facenet.load_model(args.model)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")
# image_size = images_placeholder.get_shape()[1] # For some reason this doesn't work for frozen graphs
image_size = args.image_size
embedding_size = embeddings.get_shape()[1] # 128
# Run forward pass to calculate embeddings
print('Runnning forward pass on LFW images')
batch_size = args.lfw_batch_size
nrof_images = len(paths) # 12000
nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size)) # 12000* 128
for i in range(nrof_batches):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = paths[start_index:end_index]
images = facenet.load_data(paths_batch, False, False, image_size)
feed_dict = {images_placeholder: images, phase_train_placeholder: False}
emb_array[start_index:end_index, :] = sess.run(embeddings, feed_dict=feed_dict)
# 输出调试信息
embeddings1 = emb_array[0::2] # 6000张图片 是每一个Paris中的第一张
embeddings2 = emb_array[1::2] # 6000张图片 是每一个Paris中的第2张
diff = np.subtract(embeddings1, embeddings2) # 每一个Paris中的两个向量相减
dist = np.sum(np.square(diff), 1) # 向量二范数的平方，两个向量之间距离的平方。 每一个Pari之间的欧几里得距离的平方
# #也可以说是两张图片之间特征向量的相似度
print('------------------------------------------------------------')
print('dist.len=', len(dist))
# 把特征向量保存到文件中去
f = open(r'E:\MyPythonProjects\HWDB1\train1\pairs/embeddingsOfCluster.txt', 'w')
for embedding in emb_array:
for data in embedding:
f.write(str(data) + ' ')
f.write('\n')
f.close()
# 把误差保存到文件中去
f = open(r'E:\MyPythonProjects\HWDB1\train1\pairs/distForCluster.txt', 'w')
for d in dist:
f.write(str(d) + '\n')
f.close()
# 对数据做聚类 k-means 10个类别
from sklearn.cluster import KMeans
kmeans=KMeans(n_clusters=10,random_state=0).fit(emb_array)
#cluster_centers_ cluster_centers_kmeans
f=open(r'E:\MyPythonProjects\HWDB1\train1\pairs/cluster_centers_kmeans.txt','w')
for centers in kmeans.cluster_centers_:
for i in centers:
f.write(str(i)+' ')
f.write('\n')
f.close()
f=open(r'E:\MyPythonProjects\HWDB1\train1\pairs/labelsForKmeansCluster.txt','w')
for label in kmeans.labels_:
f.write(str(label)+'\n') # 从数据中可以看出来，是有一定的聚类的作用。不过效果不是特别好
f.close()
print("Done")
# # 绘制三维图像
#
# import matplotlib.pyplot as plt
# from mpl_toolkits.mplot3d import Axes3D
# data =emb_array[:,0:3]
#
# x, y, z = data[:, 0], data[:, 1], data[:, 2]
#
# fig = plt.figure()
# ax = fig.add_subplot(111, projection='3d') # 创建一个三维的绘图工程
# # 将数据点分成三部分画，在颜色上有区分度
# # b: blue
# # g: green
# # r: red
# # c: cyan
# # m: magenta
# # y: yellow
# # k: black
# # w: white
#
# ax.scatter(x[0:200], y[0:200], z[0:200], c='b') # 绘制数据点
# ax.scatter(x[200:400], y[200:400], z[200:400], c='r')
# ax.scatter(x[400:600], y[400:600], z[400:600], c='g')
# ax.scatter(x[600:800], y[600:800], z[600:800], c='k')
#
# ax.set_zlabel('Z') # 坐标轴
# ax.set_ylabel('Y')
# ax.set_xlabel('X')
# plt.show()
'''
def main():
#Step 1 - download google's pre-trained neural network
# =============================================================================
# url = 'https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip'
# data_dir = '../data/'
# model_name = os.path.split(url)[-1]
# local_zip_file = os.path.join(data_dir, model_name)
# if not os.path.exists(local_zip_file):
# # Download
# model_url = urllib.request.urlopen(url)
# with open(local_zip_file, 'wb') as output:
# output.write(model_url.read())
# # Extract
# with zipfile.ZipFile(local_zip_file, 'r') as zip_ref:
# zip_ref.extractall(data_dir)
# =============================================================================
data_dir = 'F:/Deep_Dream/inception5h'
# start with a gray image with a little noise
img_noise = np.random.uniform(size=(224,224,3)) + 100.0
model_fn = 'tensorflow_inception_graph.pb'
#Step 2 - Creating Tensorflow session and loading the model
graph = tf.Graph()
sess = tf.InteractiveSession(graph=graph)
with tf.gfile.FastGFile(os.path.join(data_dir, model_fn), 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
t_input = tf.placeholder(np.float32, name='input') # define the input tensor
imagenet_mean = 117.0
t_preprocessed = tf.expand_dims(t_input-imagenet_mean, 0)
tf.import_graph_def(graph_def, {'input':t_preprocessed})
layers = [op.name for op in graph.get_operations() if op.type=='Conv2D' and 'import/' in op.name]
feature_nums = [int(graph.get_tensor_by_name(name+':0').get_shape()[-1]) for name in layers]
print('Number of layers', len(layers))
print('Total number of feature channels:', sum(feature_nums))
# Helper functions for TF Graph visualization
#pylint: disable=unused-variable
def strip_consts(graph_def, max_const_size=32):
"""Strip large constant values from graph_def."""
strip_def = tf.GraphDef()
for n0 in graph_def.node:
n = strip_def.node.add() #pylint: disable=maybe-no-member
n.MergeFrom(n0)
if n.op == 'Const':
tensor = n.attr['value'].tensor
size = len(tensor.tensor_content)
if size > max_const_size:
tensor.tensor_content = "<stripped %d bytes>"%size
return strip_def
def rename_nodes(graph_def, rename_func):
res_def = tf.GraphDef()
for n0 in graph_def.node:
n = res_def.node.add() #pylint: disable=maybe-no-member
n.MergeFrom(n0)
n.name = rename_func(n.name)
for i, s in enumerate(n.input):
n.input[i] = rename_func(s) if s[0]!='^' else '^'+rename_func(s[1:])
return res_def
def showarray(a):
a = np.uint8(np.clip(a, 0, 1)*255)
plt.axis("off")
plt.imshow(a)
plt.show()
a=cv2.cvtColor(a, cv2.COLOR_BGR2RGB)
cv2.imshow("output", a)
cv2.waitKey(0)
cv2.destroyAllWindows()
def visstd(a, s=0.1):
'''Normalize the image range for visualization'''
return (a-a.mean())/max(a.std(), 1e-4)*s + 0.5
def T(layer):
'''Helper for getting layer output tensor'''
return graph.get_tensor_by_name("import/%s:0"%layer)
def render_naive(t_obj, img0=img_noise, iter_n=20, step=1.0):
t_score = tf.reduce_mean(t_obj) # defining the optimization objective
t_grad = tf.gradients(t_score, t_input)[0] # behold the power of automatic differentiation!
img = img0.copy()
for _ in range(iter_n):
g, _ = sess.run([t_grad, t_score], {t_input:img})
# normalizing the gradient, so the same step size should work
g /= g.std()+1e-8 # for different layers and networks
img += g*step
showarray(visstd(img))
def tffunc(*argtypes):
'''Helper that transforms TF-graph generating function into a regular one.
See "resize" function below.
'''
placeholders = list(map(tf.placeholder, argtypes))
def wrap(f):
out = f(*placeholders)
def wrapper(*args, **kw):
return out.eval(dict(zip(placeholders, args)), session=kw.get('session'))
return wrapper
return wrap
def resize(img, size):
img = tf.expand_dims(img, 0)
return tf.image.resize_bilinear(img, size)[0,:,:,:]
resize = tffunc(np.float32, np.int32)(resize)
def calc_grad_tiled(img, t_grad, tile_size=512):
'''Compute the value of tensor t_grad over the image in a tiled way.
Random shifts are applied to the image to blur tile boundaries over
multiple iterations.'''
sz = tile_size
h, w = img.shape[:2]
sx, sy = np.random.randint(sz, size=2)
img_shift = np.roll(np.roll(img, sx, 1), sy, 0)
grad = np.zeros_like(img)
for y in range(0, max(h-sz//2, sz),sz):
for x in range(0, max(w-sz//2, sz),sz):
sub = img_shift[y:y+sz,x:x+sz]
g = sess.run(t_grad, {t_input:sub})
grad[y:y+sz,x:x+sz] = g
return np.roll(np.roll(grad, -sx, 1), -sy, 0)
def render_deepdream(t_obj, img0=img_noise,
iter_n=10, step=1.5, octave_n=4, octave_scale=1.4):
t_score = tf.reduce_mean(t_obj) # defining the optimization objective
t_grad = tf.gradients(t_score, t_input)[0] # behold the power of automatic differentiation!
# split the image into a number of octaves
img = img0
octaves = []
for _ in range(octave_n-1):
hw = img.shape[:2]
lo = resize(img, np.int32(np.float32(hw)/octave_scale))
hi = img-resize(lo, hw)
img = lo
octaves.append(hi)
# generate details octave by octave
for octave in range(octave_n):
if octave>0:
hi = octaves[-octave]
img = resize(img, hi.shape[:2])+hi
for _ in range(iter_n):
g = calc_grad_tiled(img, t_grad)
img += g*(step / (np.abs(g).mean()+1e-7))
#this will usually be like 3 or 4 octaves
#Step 5 output deep dream image via matplotlib
showarray(img/255.0)
#Step 3 - Pick a layer to enhance our image
layer = 'mixed4d_3x3_bottleneck_pre_relu'
channel = 139 # picking some feature channel to visualize
#open image
img0 = PIL.Image.open('test.png')
img0 = np.float32(img0)
#Step 4 - Apply gradient ascent to that layer
render_deepdream(tf.square(T('mixed4c')), img0)
def main(args):
network = importlib.import_module(args.model_def, 'inference')
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)
# 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)
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)
# 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, args.random_crop, args.random_flip, args.random_rotate,
args.nrof_preprocess_threads)
print('Total number of classes: %d' % nrof_classes)
print('Total number of examples: %d' % len(image_list))
print('Building training graph')
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate')
# Build the inference graph
prelogits, _ = network.inference(image_batch, args.keep_probability,
phase_train=True, weight_decay=args.weight_decay)
logits = slim.fully_connected(prelogits, 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)
# 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
if args.center_loss_factor>0.0:
prelogits_center_loss, _ = facenet.center_loss(prelogits, label_batch, args.center_loss_alfa, nrof_classes)
tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, prelogits_center_loss * args.center_loss_factor)
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.scalar_summary('learning_rate', learning_rate)
# Calculate the average cross entropy loss across the batch
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits, label_batch, name='cross_entropy_per_example')
cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
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')
# 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.all_variables(), args.log_histograms)
# Evaluation
print('Building evaluation graph')
lfw_label_list = range(0,len(lfw_paths))
assert (len(lfw_paths) % args.lfw_batch_size == 0), "The number of images in the LFW test set need to be divisible by the lfw_batch_size"
eval_image_batch, eval_label_batch = facenet.read_and_augument_data(lfw_paths, lfw_label_list, args.image_size,
args.lfw_batch_size, None, False, False, False, args.nrof_preprocess_threads, shuffle=False)
# Node for input images
eval_image_batch.set_shape((None, args.image_size, args.image_size, 3))
eval_image_batch = tf.identity(eval_image_batch, name='input')
eval_prelogits, _ = network.inference(eval_image_batch, 1.0,
phase_train=False, weight_decay=0.0, reuse=True)
eval_embeddings = tf.nn.l2_normalize(eval_prelogits, 1, 1e-10, name='embeddings')
# Create a saver
saver = tf.train.Saver(tf.all_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_all_summaries()
# 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))
sess.run(tf.initialize_all_variables())
sess.run(tf.initialize_local_variables())
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
tf.train.start_queue_runners(sess=sess)
with sess.as_default():
if pretrained_model:
print('Restoring pretrained model: %s' % pretrained_model)
saver.restore(sess, pretrained_model)
# Training and validation loop
print('Running training')
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, learning_rate_placeholder, global_step,
total_loss, train_op, summary_op, summary_writer, regularization_losses, args.learning_rate_schedule_file)
# Save variables and the metagraph if it doesn't exist already
save_variables_and_metagraph(sess, saver, summary_writer, model_dir, subdir, step)
# Evaluate on LFW
'''
if args.lfw_dir:
evaluate(sess, eval_embeddings, eval_label_batch, actual_issame, args.lfw_batch_size, args.seed,
args.lfw_nrof_folds, log_dir, step, summary_writer)
'''
return model_dir
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')
NUM_CLASSES = 90
opener = urllib.request.URLopener()
opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
tar_file = tarfile.open(MODEL_FILE)
for file in tar_file.getmembers():
file_name = os.path.basename(file.name)
if 'frozen_inference_graph.pb' in file_name:
tar_file.extract(file, os.getcwd())
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
import cv2
cap=cv2.VideoCapture(0) # 0 stands for very first webcam attach
filename="F:\\latest v\\open_cv_images\\output\\output11.avi"#place were i stored my output
codec=cv2.VideoWriter_fourcc('m','p','4','v')#fourcc stands for four character code
def split_graph(path_input_pb,output_folder,name_pb1,name_pb2,scopes_pb2=None,optypes_pb2=None,opnames_pb2=None,savepbtxt=False):
savepbtxt=False # now always be false
if scopes_pb2 is None and optypes_pb2 is None and opnames_pb2 is None:
print('No split!!!')
return None
ops1 = []
ops2 = []
######################################################################################################
print('Load graph: ',path_input_pb)
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(path_input_pb, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
ops = detection_graph.get_operations()
# all unimplementing op in ops2, others in ops1
for op in ops:
if is_in_these_scopes(op,scopes=scopes_pb2,optypes=optypes_pb2,names=opnames_pb2):
ops2.append(op)
else:
ops1.append(op)
#################################################################################################
print('ops1 and ops2 initialization done.')
# move op in ops1 to ops2 which has inputs(dont need control dependencies) in ops2
to_remove_in_ops1 = []
new_add = True
while(new_add):
new_add = False
for op in ops1:
if (is_op_input_in_ops(op, ops2)):
ops2.append(op)
to_remove_in_ops1.append(op)
print(op.name)
new_add = True
for op in to_remove_in_ops1:
ops1.remove(op)
to_remove_in_ops1 = []
#ensure ops2's inputs ops which are in ops1 are all with len(op.outputs)==1
need_add = True
while(need_add):
need_add = False
to_add_ops = set()
for oo in ops2:
for ooi in oo.inputs:
has,num,outdtype,_3,_4 = is_opname_in_ops(ooi.op.name,ops1)
if has and num > 1:
to_add_ops.add(ooi.op.name)
print('Ensure step: '+ooi.op.name+' to move to ops2')
need_add = True
to_remove = []
for oo in ops1:
for name in to_add_ops:
if name == oo.name:
ops2.append(oo)
to_remove.append(oo)
break
for oo in to_remove:
ops1.remove(oo)
print('Ensure step: remove '+oo.name+' from ops1')
#####################################################################################################
print('ops1 and ops2 update done.')
#for all op in ops2
#if its inputs not in ops2,
# check it in ops1, and add to placeholders
#if its control_inputs not in ops2,
# add to consts
# 3 kind of types
# not const, need a placeholder
# a const ,can create a new same const
# control like assert use a random const replace
ops_placeholder_name = []
ops_placeholder_dtype = []
ops_const_name = []
ops_true_const_node_def = []
name_inputs = set()
name_control_inputs = set()
for op in ops2:
for ci in op.control_inputs:
name_control_inputs.add(ci.name)
for t in op.inputs:
name_inputs.add(t.op.name)
##########################################################################################
print('Adding control_input as constant in pb2.')
for opname in name_control_inputs:
_0,_1,_2,_3,_4 = is_opname_in_ops(opname,ops2)
if _0:
continue
else:
ops_const_name.append(opname)
############################################################################################
print('Adding inputs for pb2: copy constants for true const inputs and create pleceholders for none-const inputs.')
for opname in name_inputs:
_0,_1,_2,_3,_4 = is_opname_in_ops(opname,ops2)
if _0:
continue
else:
ophas,outnum,outdtype,optype,op_def = is_opname_in_ops(opname,ops1)
# perhaps a const output to both ops1 and ops2, so dont't move ops2' const inputs(in ops1) to ops2
if outnum != 1:
print(opname+' in ops1, outnum > 1!')
print('outnum: '+str(outnum))
import sys
sys.exit(-1)
if ophas:
if optype == 'Const':
ops_true_const_node_def.append(op_def)
print('Add true const: '+opname)
else:
ops_placeholder_name.append(opname)
ops_placeholder_dtype.append(outdtype)
print('Add placeholder: '+opname)
else:
print(opname+' not in ops1!')
import sys
sys.exit(-1)
#########################################################################
#for all op in ops1
#if its inputs not in ops1,
# exit(-1)
#if its control_inputs not in ops1,
# add to consts
ops_const_name_1 = []
name_inputs_1 = set()
name_control_inputs_1 = set()
for op in ops1:
for ci in op.control_inputs:
name_control_inputs_1.add(ci.name)
for t in op.inputs:
name_inputs_1.add(t.op.name)
for opname in name_inputs_1:
_0,_1,_2,_3,_4 = is_opname_in_ops(opname,ops1)
if _0 is False:
print("wrong: " + str(opname) + " is not in ops1.\nexit.")
sys.exit(-1)
##########################################################################################
print('Adding control_input as constant in pb1.')
for opname in name_control_inputs_1:
_0,_1,_2,_3,_4 = is_opname_in_ops(opname,ops1)
if _0:
continue
else:
ops_const_name_1.append(opname)
############################################################################################
# add consts for ops1
# control like assert use a random const replace
with tf.Graph().as_default():
for cs in ops_const_name_1:
#controls
ops1.append(tf.constant(1.0,dtype=tf.float32,name=cs).op)
print('constant added for ops1: ')
print('\tscope name: '+cs)
# add placeholders and consts for ops2
# 3 kind of types
# not const, need a placeholder
# a const ,can create a new same const
# control like assert use a random const replace
with tf.Graph().as_default():
for tmptype,tmpname in zip(ops_placeholder_dtype,ops_placeholder_name):
ops2.append(tf.placeholder(tmptype, shape=None, name=tmpname).op)
print('placeholder added: ')
print('\tdata type: '+str(tmptype))
print('\tscope name: '+tmpname)
for cs in ops_const_name:
#controls
has = False
for nn in ops_placeholder_name:
if cs == nn:
has = True
if has:
print('In add const: opname '+cs+' already in placeholders.')
continue
else:
ops2.append(tf.constant(1.0,dtype=tf.float32,name=cs).op)
print('constant added for ops2: ')
print('\tscope name: '+cs)
#########################################################################
print('split done, follwed with saving.')
'''
with open(PATH_PLACEHOLDERS, 'w+') as plhfile:
for name in ops_placeholder_name:
plhfile.write(name+'\n')
with open(PATH_OPS1, 'w+') as opsfile1:
for o1 in ops1:
#print(o1.name)
sss = node_def_add_node(str(o1.node_def))
opsfile1.write(sss)
with open(PATH_OPS2, 'w+') as opsfile2:
for true_const_def in ops_true_const_node_def:
sss = node_def_add_node(str(true_const_def))
opsfile2.write(sss)
for o2 in ops2:
sss = node_def_add_node(str(o2.node_def))
opsfile2.write(sss)
'''
sss1 = ''
for o1 in ops1:
sss = node_def_add_node(str(o1.node_def))
sss1 = sss1 + sss
sss2 = ''
for true_const_def in ops_true_const_node_def:
sss = node_def_add_node(str(true_const_def))
sss2 = sss2 + sss
for o2 in ops2:
sss = node_def_add_node(str(o2.node_def))
sss2 = sss2 + sss
if savepbtxt:
import os
name_pbtxt1 = name_pb1 + 'txt'
name_pbtxt2 = name_pb2 + 'txt'
with open(os.path.join(output_folder+name_pbtxt1), 'w+') as opsfile1:
opsfile1.write(sss1)
print('save pbtxt1: ', os.path.join(output_folder+name_pbtxt1))
with open(os.path.join(output_folder+name_pbtxt2), 'w+') as opsfile2:
opsfile2.write(sss2)
print('save pbtxt2: ', os.path.join(output_folder+name_pbtxt2))
##########################################################################
print('start saving pb1 and pb2.')
convert_pbtxt_str_to_pb(sss1,output_folder,name_pb1)
convert_pbtxt_str_to_pb(sss2,output_folder,name_pb2)
print('saving pb1 and pb2 done.')
return ops_placeholder_name
