def testDemuxEmbeddings(self):
batch_size = 3 * 12
embedding_size = 16
alpha = 0.2
with tf.Graph().as_default():
embeddings = tf.placeholder(tf.float64,
shape=(batch_size, embedding_size),
name='embeddings')
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
alpha)
sess = tf.Session()
with sess.as_default():
np.random.seed(seed=666)
emb = np.random.uniform(size=(batch_size, embedding_size))
tf_triplet_loss = sess.run(triplet_loss,
feed_dict={embeddings: emb})
pos_dist_sqr = np.sum(np.square(emb[0::3, :] - emb[1::3, :]),
1)
neg_dist_sqr = np.sum(np.square(emb[0::3, :] - emb[2::3, :]),
1)
np_triplet_loss = np.mean(
np.maximum(0.0, pos_dist_sqr - neg_dist_sqr + alpha))
np.testing.assert_almost_equal(
tf_triplet_loss,
np_triplet_loss,
decimal=5,
err_msg='Triplet loss is incorrect')
def testDemuxEmbeddings(self):
batch_size = 3 * 12
embedding_size = 16
alpha = 0.2
with tf.Graph().as_default():
embeddings = tf.placeholder(tf.float64,
shape=(batch_size, embedding_size),
name='embeddings')
anchor, positive, negative = tf.unpack(
tf.reshape(embeddings, [-1, 3, embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
alpha)
sess = tf.Session()
with sess.as_default():
np.random.seed(seed=666)
emb = np.random.uniform(size=(batch_size, embedding_size))
#tf_triplet_loss, = sess.run(triplet_loss, feed_dict={embeddings:emb})
anchor_, positive_, negative_ = sess.run(
[anchor, positive, negative], feed_dict={embeddings: emb})
tf_triplet_loss, pos_dist_, neg_dist_, basic_loss_ = sess.run(
triplet_loss, feed_dict={embeddings: emb})
pos_dist_sqr = np.sum(np.square(emb[0::3, :] - emb[1::3, :]),
1)
neg_dist_sqr = np.sum(np.square(emb[0::3, :] - emb[2::3, :]),
1)
np_triplet_loss = np.mean(
np.maximum(0.0, pos_dist_sqr - neg_dist_sqr + alpha))
np.testing.assert_almost_equal(
tf_triplet_loss,
np_triplet_loss,
decimal=5,
err_msg='Triplet loss is incorrect')
emb_visual = np.array(emb)
x = emb_visual[:, 0]
y = emb_visual[:, 1]
z = np.random.rand(batch_size)
plt.scatter(x,
y,
c=z,
s=100,
cmap=plt.cm.cool,
edgecolors='None',
alpha=0.75)
plt.colorbar()
plt.show()
def testDemuxEmbeddings(self):
batch_size = 3*12
embedding_size = 16
alpha = 0.2
with tf.Graph().as_default():
embeddings = tf.placeholder(tf.float64, shape=(batch_size, embedding_size), name='embeddings')
anchor, positive, negative = tf.unstack(tf.reshape(embeddings, [-1,3,embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative, alpha)
sess = tf.Session()
with sess.as_default():
np.random.seed(seed=666)
emb = np.random.uniform(size=(batch_size, embedding_size))
tf_triplet_loss = sess.run(triplet_loss, feed_dict={embeddings:emb})
pos_dist_sqr = np.sum(np.square(emb[0::3,:]-emb[1::3,:]),1)
neg_dist_sqr = np.sum(np.square(emb[0::3,:]-emb[2::3,:]),1)
np_triplet_loss = np.mean(np.maximum(0.0, pos_dist_sqr - neg_dist_sqr + alpha))
np.testing.assert_almost_equal(tf_triplet_loss, np_triplet_loss, decimal=5, err_msg='Triplet loss is incorrect')
def main(args):
network = importlib.import_module(args.model_def, 'inference')
if args.model_name:
subdir = args.model_name
preload_model = True
else:
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
preload_model = False
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.mkdir(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.mkdir(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)
print('Model directory: %s' % model_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
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)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32, shape=(None, args.image_size, args.image_size, 3), name='input')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Build the inference graph
embeddings = network.inference(images_placeholder, args.pool_type, args.use_lrn,
args.keep_probability, phase_train=phase_train_placeholder, weight_decay=args.weight_decay)
# Split example embeddings into anchor, positive and negative
anchor, positive, negative = tf.split(0, 3, embeddings)
# Calculate triplet loss
loss = facenet.triplet_loss(anchor, positive, negative, args.alpha)
# Calculate the total loss
regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([loss] + 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, args.learning_rate,
args.learning_rate_decay_epochs*args.epoch_size, args.learning_rate_decay_factor, args.moving_average_decay)
# Create a saver
saver = tf.train.Saver(tf.all_variables(), max_to_keep=0)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session()
sess.run(init)
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
with sess.as_default():
if preload_model:
ckpt = tf.train.get_checkpoint_state(model_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise ValueError('Checkpoint not found')
# Training and validation loop
for epoch in range(args.max_nrof_epochs):
# Train for one epoch
step = train(args, sess, train_set, epoch, images_placeholder, phase_train_placeholder,
global_step, embeddings, loss, train_op, summary_op, summary_writer)
_, _, accuracy, val, val_std, far = lfw.validate(sess,
paths, actual_issame, args.seed, args.batch_size,
images_placeholder, phase_train_placeholder, embeddings, nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
# Add validation loss and accuracy to summary
summary = tf.Summary()
summary.value.add(tag='lfw/accuracy', simple_value=np.mean(accuracy))
summary.value.add(tag='lfw/val_rate', simple_value=val)
summary_writer.add_summary(summary, step)
if (epoch % args.checkpoint_period == 0) or (epoch==args.max_nrof_epochs-1):
# Save the model checkpoint
print('Saving checkpoint')
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
return model_dir
def main(args):
#此处导入的是：models.inception_resnet_v1模型，以后再看怎么更改模型
network = importlib.import_module(args.model_def)
#用当前日期来命名模型
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
#日志保存在c:\\users\\Administrator\logs\facenet\ 文件夹里
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)
# 把参数写在日志文件中
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# Store some git revision info in a text file in the log directory
src_path, _ = os.path.split(os.path.realpath(__file__))
#arg_string:'E:/facenet/train_tripletloss.py' output_dir:'C:\\Users\\Administrator/logs/facenet\\20180314-181556'
facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv))
np.random.seed(seed=args.seed)
#获取数据集，train_set是包含文件路径与标签的集合
#先输入一个父路径 path：'E:/facenet/data/lfw_160'，接着输入每个子路径
# 输出：一个list，每个元素是一个ImageClass，里边包含图片地址的list（image_paths）以及对应的人名(name)[以后可能会直接调用这几个属性]
train_set = facenet.get_dataset(args.data_dir)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model: #用在判断是否有预训练模型，但是如果有，怎么加载呢？
print('Pre-trained model: %s' %
os.path.expanduser(args.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语句适用于对资源进行访问的场合，确保使用过程中是否发生异常都会执行必要嘚瑟“清理”操作
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# 学习率 Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
#批大小
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
#用于判断是训练还是测试
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
#图像路径
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
# 图像标签
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
#新建一个队列，数据流操作，fifo先入先出
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
#enqueue_many返回的是一个操作
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder])
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
if args.random_crop:
image = tf.random_crop(
image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(
image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
labels_batch = tf.identity(labels_batch, 'label_batch')
# Build the inference (构造计算图)
#其中prelogits是最后一层的输出
prelogits, _ = network.inference(
image_batch,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
#L2正则化（范化）函数
# embeddings = tf.nn.l2_normalize(输入向量, L2范化的维数（取0（列L2范化）或1（行L2范化））, 泛化的最小值边界, name='embeddings')
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
#将指数衰减应用在学习率上
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# 计算损失
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
#构建L2正则化
total_loss = tf.add_n([triplet_loss] + regularization_losses,
name='total_loss')
# Build a Graph that trains the model with one batch of examples and updates the model parameters
# 确定优化方法并根据损失函数求梯度，在这里，每更行一次参数，global_step会加1
train_op = facenet.train(total_loss, global_step, args.optimizer,
learning_rate, args.moving_average_decay,
tf.global_variables())
# Create a saver创建一个saver用来保存或者从内存中回复一个模型参数
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.能够在GPU上分配的最大内存
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
#写log文件
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
#获取线程坐标
coord = tf.train.Coordinator()
#将队列中的多用sunner开始执行
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
#saver.restore(sess, os.path.expanduser(args.pretrained_model))
facenet.load_model(args.pretrained_model)
# Training and validation loop
epoch = 0
#将所有数据过一遍的次数 默认500
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
#epoch_size是一个epoch中批的个数，这个epoch是全局的批处理个数以一个epoch中。。。这个epoch将用于求学习率
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, train_set, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, input_queue, global_step, embeddings,
total_loss, train_op, summary_op, summary_writer,
args.learning_rate_schedule_file, args.embedding_size,
anchor, positive, negative, triplet_loss)
# 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, lfw_paths, embeddings, labels_batch,
image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, enqueue_op,
actual_issame, args.batch_size,
args.lfw_nrof_folds, log_dir, step,
summary_writer, args.embedding_size)
return model_dir
def main(args):
#导入模型
network = importlib.import_module(args.model_def)
#为本次运行新建日志目录与模型目录
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir)
if not os.path.isdir(
log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
if not os.path.isdir(
model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
#保存输入参数信息
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
#保存git相关信息
# 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)
#pre-trained model 路径
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' %
os.path.expanduser(args.pretrained_model))
#lfw测试集
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)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
#创建各种placeholder
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
#使用了三元组损失，输入需要3张图片
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
#数据集准备
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
#文件入队操作
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder])
#读取队列数据，经过一系列转换（读取图片、切片、水平镜像、reshape）
#结果是[images,label],image.shape(3,160,160,3),label.shape (3,)
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
if args.random_crop:
image = tf.random_crop(
image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(
image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
# 由于 enqueue_many=True
# 因此输入队列 images_and_labels 中的每个元素，即[images, label]也会根据axis=0的切分为多条数据
# image_batch 的 shape 为 (batch_size, image_size, image_size, 3)
# labels_batch 的 shape 为 (batch_size)
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
labels_batch = tf.identity(labels_batch, 'label_batch')
# 将图片转换为长度为128的向量，并进行l2 normalize操作
# Build the inference graph
#prelogits是最后一层的输出
prelogits, _ = network.inference(
image_batch,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
#对最后的输出进行标准化，得到该图像的embedding
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
#将embedding分成三个部分，anchor，positive，negative
# 获取triplet输入数据，并计算损失函数
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
#根据上面三个值计算三元组损失
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
#定义优化方法tf.train.exponential_decay 将指数衰减应用到学习率上 每decay_steps步更新学习速率
#获取学习率
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
#加入正则化损失
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
#整体损失=正则化损失+三元组损失
total_loss = tf.add_n([triplet_loss] + regularization_losses,
name='total_loss')
# Build a Graph that trains the model with one batch of examples and updates the model parameters
#用上述定义的优化方法和loss进行优化
train_op = facenet.train(total_loss, global_step, args.optimizer,
learning_rate, args.moving_average_decay,
tf.global_variables())
# Create a saver
# saver summary相关
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
# 创建Session并进行变量初始化
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
# # 运行输入数据队列，并获取FileWriter
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
# 导入 pre-trained model
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
# saver.restore(sess, os.path.expanduser(args.pretrained_model))
facenet.load_model(args.pretrained_model)
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
# 构建一个epoch的数据并训练
train(args, sess, train_set, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, input_queue, global_step, embeddings,
total_loss, train_op, summary_op, summary_writer,
args.learning_rate_schedule_file, args.embedding_size,
anchor, positive, negative, triplet_loss)
# 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
# 在 lfw 上验证模型性能
if args.lfw_dir:
evaluate(sess, lfw_paths, embeddings, labels_batch,
image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, enqueue_op,
actual_issame, args.batch_size,
args.lfw_nrof_folds, log_dir, step,
summary_writer, args.embedding_size)
return model_dir
def main(args):
network = importlib.import_module(args.model_def)
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') + args.experiment_name
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)
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir, 'arguments.txt'))
# 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)
class_name = ['smile','oval_face','5_ocloc_shadow','bald','archied_eyebrows','Big_lips', 'Big_Nose']
class_num = len(class_name)
class_index = [31,25,0,4,1,6,7]
all_image_list = []
all_label_list = []
for i in range(class_num):
image_list = []
label_list = []
train_set = facenet.get_sub_category_dataset(args.data_dir, class_index[i])
image_list_p, label_list_p = facenet.get_image_paths_and_labels_triplet(train_set[0], args)
image_list_n, label_list_n = facenet.get_image_paths_and_labels_triplet(train_set[1], args)
image_list.append(image_list_p)
image_list.append(image_list_n)
label_list.append(label_list_p)
label_list.append(label_list_n)
all_image_list.append(image_list)
all_label_list.append(label_list)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' % os.path.expanduser(args.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)
image_size = args.image_size
batch_size = args.batch_size
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# image_paths_placeholder = tf.placeholder(tf.string, shape=(None,3), name='image_paths')
image_placeholder = tf.placeholder(tf.float32, shape=(batch_size, image_size, image_size,3), name='images')
labels_placeholder = tf.placeholder(tf.int64, shape=(batch_size,3), name='labels')
code_placeholder = tf.placeholder(tf.float32, shape=(batch_size,class_num,1,1), name='code')
image_batch = normalized_image(image_placeholder)
code_batch = code_placeholder
control_code = tf.tile(code_placeholder,[1,1,args.embedding_size,1])
mask_array = np.ones((1 ,class_num,args.embedding_size,1),np.float32)
# for i in range(class_num):
# mask_array[:,i,(args.embedding_size/class_num)*i:(args.embedding_size/class_num)*(i+1)] = 1
mask_tensor = tf.get_variable('mask', dtype=tf.float32, trainable=args.learned_mask, initializer=tf.constant(mask_array))
mask_tensor = tf.tile(mask_tensor,[batch_size,1,1,1])
control_code = tf.tile(code_placeholder,[1,1,args.embedding_size,1])
mask_out = tf.multiply(mask_tensor, control_code)
mask_out = tf.reduce_sum(mask_out,axis=1)
mask_out = tf.squeeze(mask_out)
mask_out = tf.nn.relu(mask_out)
mask0_array = np.ones((1, class_num, 128, 1), np.float32)
mask0_tensor = tf.get_variable('mask0', dtype=tf.float32, trainable=args.learned_mask,
initializer=tf.constant(mask0_array))
mask0_tensor = tf.tile(mask0_tensor, [batch_size, 1, 1, 1])
control0_code = tf.tile(code_placeholder,[1,1,128,1])
mask0_out = tf.multiply(mask0_tensor, control0_code)
mask0_out = tf.reduce_sum(mask0_out, axis=1)
mask0_out = tf.squeeze(mask0_out)
mask0_out = tf.nn.relu(mask0_out)
mask0_out = tf.expand_dims(mask0_out,1)
mask0_out = tf.expand_dims(mask0_out,1)
mask1_array = np.ones((1, class_num, 128, 1), np.float32)
mask1_tensor = tf.get_variable('mask1', dtype=tf.float32, trainable=args.learned_mask,
initializer=tf.constant(mask1_array))
mask1_tensor = tf.tile(mask1_tensor, [batch_size, 1, 1, 1])
control1_code = tf.tile(code_placeholder,[1,1,128,1])
mask1_out = tf.multiply(mask1_tensor, control1_code)
mask1_out = tf.reduce_sum(mask1_out, axis=1)
mask1_out = tf.squeeze(mask1_out)
mask1_out = tf.nn.relu(mask1_out)
mask1_out = tf.expand_dims(mask1_out,1)
mask1_out = tf.expand_dims(mask1_out,1)
# Build the inference graph
prelogits, _ = network.inference(image_batch, mask0_out, mask1_out, args.keep_probability,
phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
embeddings_pre = tf.multiply(mask_out, prelogits)
embeddings = tf.nn.l2_normalize(embeddings_pre, 1, 1e-10, name='embeddings')
anchor_index = list(range(0,batch_size,3))
positive_index = list(range(1,batch_size,3))
negative_index = list(range(2,batch_size,3))
a_indice = tf.constant(np.array(anchor_index))
p_indice = tf.constant(np.array(positive_index))
n_indice = tf.constant(np.array(negative_index))
anchor = tf.gather(embeddings,a_indice)
positive = tf.gather(embeddings,p_indice)
negative = tf.gather(embeddings,n_indice)
triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha)
learning_rate = tf.train.exponential_decay(learning_rate_placeholder, global_step,
args.learning_rate_decay_epochs*args.epoch_size, args.learning_rate_decay_factor, staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + 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.global_variables())
# Create a saver
trainable_variables = tf.global_variables()
saver = tf.train.Saver(trainable_variables, max_to_keep=35)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(), feed_dict={phase_train_placeholder:True})
sess.run(tf.local_variables_initializer(), feed_dict={phase_train_placeholder:True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
Accuracy = [0]
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
# epoch = step // args.epoch_size
# Train for one epoch
code_list = []
triplets_list = []
max_num = 32768
if (epoch+1)%args.lr_epoch == 0:
args.learning_rate = 0.1*args.learning_rate
if args.random_trip:
for i in range(class_num):
code = np.zeros((batch_size, class_num, 1, 1), np.float32)
_class = i
code[:, _class, :, :] = 1
Triplets = triplet_random(args, sess, all_image_list[i], all_image_list, epoch, image_placeholder,
batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, global_step,
embeddings, total_loss, train_op, summary_op, summary_writer,
args.learning_rate_schedule_file,
args.embedding_size, anchor, positive, negative, triplet_loss, max_num)
triplets_list.append(Triplets)
code_list.append(code)
else:
for i in range(class_num):
code = np.zeros((batch_size, 1, 1, 1), np.float32)
_class = i
if _class > 3:
_class = 3
code[:, :, :, :] = _class
print(class_name[i])
Triplets = triplet(args, sess, all_image_list[i], epoch, image_placeholder, code_placeholder,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, global_step,
embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file,
args.embedding_size, anchor, positive, negative, triplet_loss,code)
triplets_num = len(Triplets)
triplets_list.append(Triplets)
code_list.append(code)
train(args, sess, image_list, epoch, image_placeholder, code_placeholder,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, global_step,
embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file,
args.embedding_size, anchor, positive, negative, triplet_loss, triplets_list, code_list, model_dir, Accuracy)
if (epoch+1)%2 == 0:
Accuracy = test(args, sess, image_list, epoch, image_placeholder,code_placeholder,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, global_step,
embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file,
args.embedding_size, anchor, positive, negative, triplet_loss, triplets_list, Accuracy)
# Save variables and the metagraph if it doesn't exist already
model_name = 'epoch' + str(epoch+1)
print(model_dir)
if (epoch+1) > 0 :
if (epoch +1)%2 == 0:
save_variables_and_metagraph(sess, saver, summary_writer, model_dir, model_name, step)
print('models are saved in ', os.path.join(model_dir, model_name))
epoch = epoch + 1
sess.close()
return model_dir
def main(args):
network = importlib.import_module(args.model_def, 'inference')
if args.model_name:
subdir = args.model_name
preload_model = True
else:
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
preload_model = False
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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_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
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)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32,
shape=(None, args.image_size,
args.image_size, 3),
name='input')
# Placeholder for the learning rate
labels_placeholder = tf.placeholder(tf.int64, name='labels')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learing_rate')
# Build the inference graph
logits1, _ = network.inference(images_placeholder,
[128, len(train_set)],
args.keep_probability,
phase_train=phase_train_placeholder,
weight_decay=args.weight_decay)
# Split example embeddings into anchor, positive and negative and calculate triplet loss
embeddings = tf.nn.l2_normalize(logits1, 1, 1e-10, name='embeddings')
anchor, positive, negative = tf.split(0, 3, embeddings)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
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 total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_triplet_loss = tf.add_n([triplet_loss] + regularization_losses,
name='total_triplet_loss')
# Build a Graph that trains the model with one batch of examples and updates the model parameters
triplet_loss_train_op = facenet.train('tripletloss_',
total_triplet_loss, global_step,
args.optimizer, learning_rate,
args.moving_average_decay)
# Create a saver
saver = tf.train.Saver(tf.all_variables(), max_to_keep=0)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# 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))
sess.run(init)
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
with sess.as_default():
if preload_model:
ckpt = tf.train.get_checkpoint_state(model_dir)
#pylint: disable=maybe-no-member
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise ValueError('Checkpoint not found')
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
epoch = sess.run(global_step,
feed_dict=None) // args.epoch_size
# Train for one epoch
step = train_triplet_loss(
args, sess, train_set, epoch, images_placeholder,
labels_placeholder, phase_train_placeholder,
learning_rate_placeholder, global_step, embeddings,
total_triplet_loss, triplet_loss_train_op, summary_op,
summary_writer)
if args.lfw_dir:
_, _, accuracy, val, val_std, far = lfw.validate(
sess,
paths,
actual_issame,
args.seed,
args.batch_size,
images_placeholder,
phase_train_placeholder,
embeddings,
nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' %
(np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' %
(val, val_std, far))
# Add validation loss and accuracy to summary
summary = tf.Summary()
#pylint: disable=maybe-no-member
summary.value.add(tag='lfw/accuracy',
simple_value=np.mean(accuracy))
summary.value.add(tag='lfw/val_rate', simple_value=val)
summary_writer.add_summary(summary, step)
if (epoch % args.checkpoint_period
== 0) or (epoch == args.max_nrof_epochs - 1):
# Save the model checkpoint
print('Saving checkpoint')
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
return model_dir
def triplet_loss(self, embeddings, embedding_size, alpha):
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative, alpha)
return triplet_loss
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)
if args.minutiae_pairs_dir is not None:
minutiae_pairs = args.minutiae_pairs_dir.split(':')
evaluate_paths = []
evaluate_paths.append(glob.glob(minutiae_pairs[0]+'*.jpeg'))
evaluate_paths[0].sort()
evaluate_paths.append(glob.glob(minutiae_pairs[1]+'*.jpeg'))
evaluate_paths[1].sort()
with open(os.path.join(model_dir, 'args.txt'), 'w') as f:
for arg in vars(args):
f.write(arg + ' ' + str(getattr(args, arg)) + '\n')
# Store some git revision info in a text file in the log directory
if not args.no_store_revision_info:
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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' % os.path.expanduser(args.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)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder = tf.placeholder(tf.string, shape=(None,3), name='image_paths')
labels_placeholder = tf.placeholder(tf.int64, shape=(None,3), name='labels')
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3,), (3,)],
shared_name=None, name=None)
enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder])
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
#image = tf.image.decode_png(file_contents)
image = tf.image.decode_jpeg(file_contents, channels=3)
#image = facenet.crop(image, None,args.image_size+30)
if args.random_rotate:
image = tf.py_func(facenet.random_rotate_image, [image], tf.uint8)
if args.random_crop:
image = tf.random_crop(image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
image = tf.cast(image,tf.float32)
#image = tf.image.per_image_standardization(image)
distorted_image = tf.image.random_brightness(image, max_delta=32)
image = tf.image.random_contrast(distorted_image, lower=0.5, upper=1.5)
#images.append(tf.image.per_image_standardization(image))
images.append(image)
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels, batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
batch_norm_params = {
# Decay for the moving averages
'decay': 0.995,
# epsilon to prevent 0s in variance
'epsilon': 0.001,
# force in-place updates of mean and variance estimates
'updates_collections': None,
# Moving averages ends up in the trainable variables collection
'variables_collections': [ tf.GraphKeys.TRAINABLE_VARIABLES ],
# Only update statistics during training mode
'is_training': phase_train_placeholder
}
# Build the inference graph
prelogits, _ = network.inference(image_batch, args.keep_probability,
phase_train=phase_train_placeholder, weight_decay=args.weight_decay)
#pre_embeddings = slim.fully_connected(prelogits, args.embedding_size, activation_fn=None,
# weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
# weights_regularizer=slim.l2_regularizer(args.weight_decay),
# normalizer_fn=slim.batch_norm,
# normalizer_params=batch_norm_params,
# scope='Bottleneck', reuse=False)
pre_embeddings = _fully_connected(prelogits, args.embedding_size, name='Bottleneck')
embeddings = tf.nn.l2_normalize(pre_embeddings, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(tf.reshape(embeddings, [-1,3,args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha)
learning_rate = tf.train.exponential_decay(learning_rate_placeholder, global_step,
args.learning_rate_decay_epochs*args.epoch_size, args.learning_rate_decay_factor, staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + 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.global_variables())
# Create a saver
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(), feed_dict={phase_train_placeholder:True})
sess.run(tf.local_variables_initializer(), feed_dict={phase_train_placeholder:True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, train_set, epoch, image_paths_placeholder, labels_placeholder, labels_batch,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step,
embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file,
args.embedding_size, anchor, positive, negative, triplet_loss)
# Save variables and the metagraph if it doesn't exist already
save_variables_and_metagraph(sess, saver, summary_writer, model_dir, subdir, step)
if evaluate_paths:
evaluate_NISTSD27(sess, evaluate_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op,
args.batch_size, log_dir, step, summary_writer, args.embedding_size)
# Evaluate on LFW
#if args.lfw_dir:
# evaluate(sess, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder,
# batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size,
# args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size)
sess.close()
return model_dir
tf.app.flags.DEFINE_boolean('log_device_placement', False,
"""Whether to log device placement.""")
tf.app.flags.DEFINE_integer('alpha', 0.2,
"""Positive to negative triplet distance margin.""")
with tf.Graph().as_default():
embeddings_placeholder = tf.placeholder(tf.float32, shape=(6, 10), name='Input')
a, p, n = tf.split(0, 3, embeddings_placeholder)
# Calculate triplet loss
loss = facenet.triplet_loss(a, p, n)
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=FLAGS.log_device_placement))
sess.run(init)
with sess.as_default():
fileName = "/home/david/tripletLossTest3.h5"
f = h5py.File(fileName, "r")
def train():
dataset = facenet.get_dataset(FLAGS.data_dir)
train_set, test_set = facenet.split_dataset(dataset, 0.9)
fileName = "/home/david/debug4.h5"
f = h5py.File(fileName, "r")
for item in f.values():
print(item)
w1 = f['1w'][:]
b1 = f['1b'][:]
f.close()
print(w1.shape)
print(b1.shape)
"""Train CIFAR-10 for a number of steps."""
with tf.Graph().as_default():
global_step = tf.Variable(0, trainable=False)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32,
shape=(FLAGS.batch_size, 96, 96,
3),
name='Input')
# Build a Graph that computes the logits predictions from the inference model
#embeddings = facenet.inference_nn4_max_pool_96(images_placeholder, phase_train=True)
conv1 = _conv(images_placeholder,
3,
64,
7,
7,
2,
2,
'SAME',
'conv1_7x7',
phase_train=False,
use_batch_norm=False,
init_weight=w1,
init_bias=b1)
resh1 = tf.reshape(conv1, [-1, 294912])
embeddings = _affine(resh1, 294912, 128)
# Split example embeddings into anchor, positive and negative
a, p, n = tf.split(0, 3, embeddings)
# Calculate triplet loss
loss = facenet.triplet_loss(a, p, n)
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op, grads = facenet.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.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(
log_device_placement=FLAGS.log_device_placement))
sess.run(init)
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir,
graph_def=sess.graph_def)
epoch = 0
with sess.as_default():
while epoch < FLAGS.max_nrof_epochs:
batch_number = 0
while batch_number < FLAGS.epoch_size:
print('Loading new data')
image_data, num_per_class, image_paths = facenet.load_data(
train_set)
print('Selecting suitable triplets for training')
start_time = time.time()
emb_list = []
# Run a forward pass for the sampled images
nrof_examples_per_epoch = FLAGS.people_per_batch * FLAGS.images_per_person
nrof_batches_per_epoch = int(
np.floor(nrof_examples_per_epoch / FLAGS.batch_size))
if True:
for i in xrange(nrof_batches_per_epoch):
feed_dict, _ = facenet.get_batch(
images_placeholder, image_data, i)
emb_list += sess.run([embeddings],
feed_dict=feed_dict)
emb_array = np.vstack(
emb_list
) # Stack the embeddings to a nrof_examples_per_epoch x 128 matrix
# Select triplets based on the embeddings
apn, nrof_random_negs, nrof_triplets = facenet.select_triplets(
emb_array, num_per_class, image_data)
duration = time.time() - start_time
print(
'(nrof_random_negs, nrof_triplets) = (%d, %d): time=%.3f seconds'
% (nrof_random_negs, nrof_triplets, duration))
count = 0
while count < nrof_triplets * 3 and batch_number < FLAGS.epoch_size:
start_time = time.time()
feed_dict, batch = facenet.get_batch(
images_placeholder, apn, batch_number)
if (batch_number % 20 == 0):
err, summary_str, _ = sess.run(
[loss, summary_op, train_op],
feed_dict=feed_dict)
summary_writer.add_summary(
summary_str,
FLAGS.epoch_size * epoch + batch_number)
else:
err, _ = sess.run([loss, train_op],
feed_dict=feed_dict)
duration = time.time() - start_time
print(
'Epoch: [%d][%d/%d]\tTime %.3f\ttripErr %2.3f'
% (epoch, batch_number, FLAGS.epoch_size,
duration, err))
batch_number += 1
count += FLAGS.batch_size
else:
while batch_number < FLAGS.epoch_size:
start_time = time.time()
feed_dict, _ = facenet.get_batch(
images_placeholder, image_data, batch_number)
grad_tensors, grad_vars = zip(*grads)
eval_list = (train_op, loss) + grad_tensors
result = sess.run(eval_list, feed_dict=feed_dict)
grads_eval = result[2:]
nrof_parameters = 0
for gt, gv in zip(grads_eval, grad_vars):
print('%40s: %6d' % (gv.op.name, np.size(gt)))
nrof_parameters += np.size(gt)
print('Total number of parameters: %d' %
nrof_parameters)
err = result[1]
batch_number += 1
epoch += 1
# Save the model checkpoint periodically.
checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
saver.save(sess,
checkpoint_path,
global_step=epoch * FLAGS.epoch_size + batch_number)
def main(args):
network = importlib.import_module(args.model_def)
subdir = time.strftime('%Y%m%d-%H%M%S', time.localtime())
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)
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
np.random.seed(seed=args.seed)
train_set = utils.___get_dataset(args.file_exp)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
# 如果选择了预训练的模型的话，这里我们会选取facenet的网络作预训练
if args.pretrained_model:
print('Pre-trained model: %s' %
os.path.expanduser(args.pretrained_model))
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
# input queue 其实就是 路径/label,三元组，也就是make好pair的
# label的必要性?
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder])
nrof_preprocess_threads = 4
images_and_labels = []
# 这里其实就是对数据进行预处理，通过从queue中获取到数据，读取路径下的图片并且预处理后做成一个list
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
if args.random_crop:
image = tf.random_crop(
image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(
image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
# pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
# print('image input successfully!')
# 其实就是对于list里面进行获取batch
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
# 返回一个节点，那么就可以做到更新节点，每次产生新的batch
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
labels_batch = tf.identity(labels_batch, 'label_batch')
# Build the inference graph
# 网络的参数设置，返回的是输出的dropout和fc（bottleneck）之后的输出，那么label到底作用在哪里
prelogits, _ = network.inference(
image_batch,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
# embedding 其实就是对于softmax进行距离的l2正则化
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# 把我们输入进去的图片集得到的结果拆分为三元组
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
# get到了，把learning rate 坐成一个placeholder就可以动态调整learning rate啦
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
# 正则化损失是什么
# 图构建过程当中的所有的回归损失？哪里加进去了呢
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + 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.global_variables())
# Create a saver
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
# print('variable inti successfully!')
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
# 线程管理器
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
# print('begin to train!')
with sess.as_default():
# 读取预训练模型
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
# print('train another epoch')
train(args, sess, train_set, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, input_queue, global_step, embeddings,
total_loss, train_op, summary_op, summary_writer,
args.learning_rate_schedule_file, args.embedding_size,
anchor, positive, negative, triplet_loss)
# Save variables and the metagraph if it doesn't exist already
save_variables_and_metagraph(sess, saver, summary_writer,
model_dir, subdir, step)
return model_dir
def main(argv=None): # pylint: disable=unused-argument
if FLAGS.model_name:
subdir = FLAGS.model_name
preload_model = True
else:
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
preload_model = False
log_dir = os.path.join(os.path.expanduser(FLAGS.logs_base_dir), subdir)
if not os.path.isdir(log_dir): # Create the log directory if it doesn't exist
os.mkdir(log_dir)
model_dir = os.path.join(os.path.expanduser(FLAGS.models_base_dir), subdir)
if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist
os.mkdir(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(argv))
np.random.seed(seed=FLAGS.seed)
dataset = facenet.get_dataset(FLAGS.data_dir)
train_set, validation_set = facenet.split_dataset(dataset, FLAGS.train_set_fraction, FLAGS.split_mode)
print('Model directory: %s' % model_dir)
with tf.Graph().as_default():
tf.set_random_seed(FLAGS.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32, shape=(None, FLAGS.image_size, FLAGS.image_size, 3), name='input')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Build the inference graph
embeddings = network.inference(images_placeholder, FLAGS.pool_type, FLAGS.use_lrn,
FLAGS.keep_probability, phase_train=phase_train_placeholder)
# Split example embeddings into anchor, positive and negative
anchor, positive, negative = tf.split(0, 3, embeddings)
# Calculate triplet loss
loss = facenet.triplet_loss(anchor, positive, negative, FLAGS.alpha)
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op, _ = facenet.train(loss, global_step, FLAGS.optimizer, FLAGS.learning_rate, FLAGS.moving_average_decay)
# Create a saver
saver = tf.train.Saver(tf.all_variables(), max_to_keep=0)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=FLAGS.log_device_placement))
sess.run(init)
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
with sess.as_default():
if preload_model:
ckpt = tf.train.get_checkpoint_state(model_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise ValueError('Checkpoint not found')
# Training and validation loop
for epoch in range(FLAGS.max_nrof_epochs):
# Train for one epoch
step = train(sess, train_set, epoch, images_placeholder, phase_train_placeholder,
global_step, embeddings, loss, train_op, summary_op, summary_writer)
# Store the state of the random number generator
rng_state = np.random.get_state()
# Test on validation set
np.random.seed(seed=FLAGS.seed)
validate(sess, validation_set, epoch, images_placeholder, phase_train_placeholder,
global_step, embeddings, loss, 'validation', summary_writer)
# Test on training set
np.random.seed(seed=FLAGS.seed)
validate(sess, train_set, epoch, images_placeholder, phase_train_placeholder,
global_step, embeddings, loss, 'training', summary_writer)
# Restore state of the random number generator
np.random.set_state(rng_state)
if (epoch % FLAGS.checkpoint_period == 0) or (epoch==FLAGS.max_nrof_epochs-1):
# Save the model checkpoint
print('Saving checkpoint')
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
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) ##mzh
# test_list= train_set[0].image_paths + train_set[1].image_paths + train_set[2].image_paths
# labels_triplet = facenet.get_label_triplet(test_list)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' %
os.path.expanduser(args.pretrained_model))
meta_file, ckpt_file = facenet.get_model_filenames(
args.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)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder])
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unpack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_png(file_contents)
if args.random_crop:
image = tf.random_crop(
image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(
image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
# Build the inference graph
prelogits, _ = network.inference(image_batch,
args.keep_probability,
phase_train=phase_train_placeholder,
weight_decay=args.weight_decay)
## Aftre the last layer of the networks, adding a full connection layer to reduce the dimension of the embdedding to the args.embedding_size (e.g 128)
#pre_embeddings = slim.fully_connected(prelogits, args.embedding_size, activation_fn=None, scope='Embeddings', reuse=False)
#embedding_size = 1792
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)
## Normalise the output of the full connection layer, then the output are embeddings
#embeddings = tf.nn.l2_normalize(pre_embeddings, 1, 1e-10, name='embeddings')
embeddings = tf.nn.l2_normalize(
prelogits, 1, 1e-10, name='embeddings') #embeddin_size = 1792
# Split embeddings into anchor, positive and negative and calculate triplet loss
#anchor, positive, negative = tf.unpack(tf.reshape(embeddings, [-1,3,args.embedding_size]), 3, 1)
anchor, positive, negative = tf.unpack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
# Add center loss
if args.center_loss_factor > 0.0:
#prelogits_center_loss, _ = facenet.center_loss(prelogits, labels_batch, args.center_loss_alfa, nrof_classes)
#### The triplet loss is calculated based on embeddings , the center_loss should also calculate based on embadding.
#### However in the facenet_train_classifier (softmax+centerloss) the loss is calculated the output of the network, i.e. prelogits.
#### However, facenet_train_classifier's evaluation is based on the normalisatioin of the traind prelogits which are the embedding.
prelogits_center_loss, center = facenet.center_loss(
embeddings, labels_batch, args.center_loss_alfa, nrof_classes)
tf.add_to_collection(
tf.GraphKeys.REGULARIZATION_LOSSES,
prelogits_center_loss * args.center_loss_factor)
# Calculate the average cross entropy loss across the batch
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits, labels_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)
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([cross_entropy_mean] +
[args.triplet_loss_factor * triplet_loss] +
regularization_losses,
name='total_loss')
# Create list with variables to restore
restore_vars = []
update_gradient_vars = []
if args.pretrained_model:
update_gradient_vars = tf.global_variables()
for var in tf.global_variables():
if not 'Embeddings/' in var.op.name:
restore_vars.append(var)
#else:
#update_gradient_vars.append(var)
else:
restore_vars = tf.global_variables()
update_gradient_vars = tf.global_variables()
# 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,
update_gradient_vars)
# Create a saver
restore_saver = tf.train.Saver(restore_vars)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
tf.train.start_queue_runners(sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
#restore_saver.restore(sess, os.path.expanduser(args.pretrained_model))
## edit by mzh
restore_saver.restore(
sess,
os.path.join(os.path.expanduser(args.pretrained_model),
ckpt_file))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, train_set, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, global_step, embeddings, total_loss,
train_op, summary_writer, regularization_losses,
args.learning_rate_schedule_file, args.embedding_size,
nrof_classes, summary_op)
# 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, lfw_paths, embeddings, labels_batch,
image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, enqueue_op,
actual_issame, args.batch_size,
args.lfw_nrof_folds, log_dir, step,
summary_writer, args.embedding_size)
return model_dir
def main(args):
network = importlib.import_module(args.model_def)
subdir = 'Finger'
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)
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# 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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_placeholder = tf.placeholder(tf.float32,
shape=(None, 150, 4),
name='image')
dynamic_alpha_placeholder = tf.placeholder(
tf.float32, shape=(), name='dynamic_alpha_placeholder')
prelogits, _ = network.inference(
image_placeholder,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
dynamic_alpha_placeholder)
# 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)
learning_rate = learning_rate_placeholder
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + regularization_losses,
name='total_loss')
# Build a Graph that trains the model with one batch of examples and updates the model parameters
extra_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(extra_ops):
if args.optimizer == 'ADAGRAD':
opt = tf.train.AdagradOptimizer(learning_rate)
elif args.optimizer == 'ADADELTA':
opt = tf.train.AdadeltaOptimizer(learning_rate,
rho=0.9,
epsilon=1e-6)
elif args.optimizer == 'ADAM':
opt = tf.train.AdamOptimizer(learning_rate,
beta1=0.9,
beta2=0.999,
epsilon=0.1)
elif args.optimizer == 'RMSPROP':
opt = tf.train.RMSPropOptimizer(learning_rate,
decay=0.9,
momentum=0.9,
epsilon=1.0)
elif args.optimizer == 'MOM':
opt = tf.train.MomentumOptimizer(learning_rate,
0.9,
use_nesterov=True)
else:
raise ValueError('Invalid optimization algorithm')
train_op = opt.minimize(total_loss)
# train_op = facenet.train(total_loss, global_step, args.optimizer,
# learning_rate, args.moving_average_decay, tf.global_variables())
# Create a saver
saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
# saver.restore(sess,'./models/siamese/Finger/model-Finger.ckpt-548')
# saver.save(sess, 'c3d_lstm/')
epoch = 1
final_loss = 0.0
count = 0.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, train_set, epoch, image_placeholder,
learning_rate_placeholder, phase_train_placeholder,
global_step, embeddings, total_loss, train_op,
summary_op, summary_writer, args.embedding_size, anchor,
positive, negative, triplet_loss,
dynamic_alpha_placeholder, final_loss, count)
epoch += 1
# Save variables and the metagraph if it doesn't exist already
save_variables_and_metagraph(sess, saver, summary_writer,
model_dir, subdir, epoch)
global epoch_list
global alpha_list
# plt.plot(epoch_list,alpha_list)
# plt.show()
# plt.savefig('alpha-vs-epoch.png')
file_for_alpha.write(epoch_list)
file_for_alpha.write(alpha_list)
return model_dir
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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' % os.path.expanduser(args.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)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32, shape=(None, args.image_size, args.image_size, 3), name='input')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate')
# Build the inference graph
prelogits, _ = network.inference(images_placeholder, args.keep_probability,
phase_train=True, weight_decay=args.weight_decay)
pre_embeddings = slim.fully_connected(prelogits, 128, activation_fn=None, scope='Embeddings', reuse=False)
# Split example embeddings into anchor, positive and negative and calculate triplet loss
embeddings = tf.nn.l2_normalize(pre_embeddings, 1, 1e-10, name='embeddings')
anchor, positive, negative = tf.split(0, 3, embeddings)
triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha)
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 total losses
regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + regularization_losses, name='total_loss')
# Create list with variables to restore
restore_vars = []
update_gradient_vars = []
if args.pretrained_model:
for var in tf.all_variables():
if not 'Embeddings/' in var.op.name:
restore_vars.append(var)
else:
update_gradient_vars.append(var)
else:
restore_vars = tf.all_variables()
update_gradient_vars = tf.all_variables()
# 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, update_gradient_vars)
# Create a saver
restore_saver = tf.train.Saver(restore_vars)
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))
# Initialize variables
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 args.pretrained_model:
restore_saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
step = train(args, sess, train_set, epoch, images_placeholder,
learning_rate_placeholder, global_step, embeddings, total_loss, train_op, summary_op, summary_writer)
if args.lfw_dir:
_, _, accuracy, val, val_std, far = lfw.validate(sess, lfw_paths,
actual_issame, args.seed, 60, images_placeholder, phase_train_placeholder, embeddings, nrof_folds=args.lfw_nrof_folds)
print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy)))
print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far))
# Add validation loss and accuracy to summary
summary = tf.Summary()
#pylint: disable=maybe-no-member
summary.value.add(tag='lfw/accuracy', simple_value=np.mean(accuracy))
summary.value.add(tag='lfw/val_rate', simple_value=val)
summary_writer.add_summary(summary, step)
# Save the model checkpoint
print('Saving checkpoint')
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
return model_dir
def main(args):
# # 导入 model_def 代表的网络结构
# network = importlib.import_module(args.model_def)
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir)
if not os.path.isdir(
log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
if not os.path.isdir(
model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
# Write arguments to a text file
# 将 参数 写入到 text 文件中
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# Store some git revision info in a text file in the log directory
# 将一些 git 修订信息存储在日志目录的文本文件中
src_path, _ = os.path.split(os.path.realpath(__file__))
facenet.store_revision_info(src_path, log_dir, ' '.join(sys.argv))
# 获取 facenet 的数据集
np.random.seed(seed=args.seed)
# train_set = facenet.get_dataset(args.data_dir)
# 训练数据集
train_set = facenet.dataset_from_list(args.data_dir, args.list_file)
nrof_classes = len(train_set)
print('nrof_classes: ', nrof_classes)
# 获取 图像 的 路径 和 labels
image_list, label_list = facenet.get_image_paths_and_labels(train_set)
print('total images: ', len(image_list))
image_list = np.array(image_list)
label_list = np.array(label_list, dtype=np.int32)
dataset_size = len(image_list)
# 单个 batch_size = 每个 batch 中的人数 * 每个人的图像数
single_batch_size = args.people_per_batch * args.images_per_person
indices = range(dataset_size)
np.random.shuffle(indices)
# 从 dataset 中抽取 样本，将 image_path 和 image_label 返回
def _sample_people_softmax(x):
global softmax_ind
if softmax_ind >= dataset_size:
np.random.shuffle(indices)
softmax_ind = 0
true_num_batch = min(single_batch_size, dataset_size - softmax_ind)
sample_paths = image_list[indices[softmax_ind:softmax_ind +
true_num_batch]]
sample_labels = label_list[indices[softmax_ind:softmax_ind +
true_num_batch]]
softmax_ind += true_num_batch
return (np.array(sample_paths), np.array(sample_labels,
dtype=np.int32))
def _sample_people(x):
'''We sample people based on tf.data, where we can use transform and prefetch.
Desc：
我们基于 tf.data 对人进行抽样，这样我们可以使用 transform 和 prefetch 。
'''
image_paths, num_per_class = sample_people(
train_set, args.people_per_batch * (args.num_gpus - 1),
args.images_per_person)
labels = []
for i in range(len(num_per_class)):
labels.extend([i] * num_per_class[i])
return (np.array(image_paths), np.array(labels, dtype=np.int32))
# 解析函数，将 image 的路径和 label 解析出来，对应着 image 和 label
def _parse_function(filename, label):
# 使用 tf.read_file() 进行读取，并使用 tf.image.decode_image() 进行转换为 tensor 的形式
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
#image = tf.image.decode_jpeg(file_contents, channels=3)
print(image.shape)
# 判断是否对图像进行随机裁剪
if args.random_crop:
print('use random crop')
image = tf.random_crop(image,
[args.image_size, args.image_size, 3])
else:
print('Not use random crop')
#image.set_shape((args.image_size, args.image_size, 3))
image.set_shape((None, None, 3))
# 将图片进行 resize ，转换为我们传入的参数的大小
image = tf.image.resize_images(image,
size=(args.image_height,
args.image_width))
#print(image.shape)
# 判断是否进行随机水平翻转
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
#image.set_shape((args.image_size, args.image_size, 3))
image.set_shape((args.image_height, args.image_width, 3))
# 强制转换数据类型
image = tf.cast(image, tf.float32)
image = tf.subtract(image, 127.5)
image = tf.div(image, 128.)
#image = tf.image.per_image_standardization(image)
return image, label
# 将 model 目录和 log 目录先打印一下
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
# # 如果已经提供了 预训练好的模型
# if args.pretrained_model:
# # os.path.expanduser() 把路径中包含 ～ 或者 ～user 的地方转换为用户目录
# print('Pre-trained model: %s' % os.path.expanduser(args.pretrained_model))
# # 如果提供了 lfw 数据，读取 lfw 目录中的 pairs 和 lfw 数据集中图像的 path
# 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)
with tf.Graph().as_default():
# 设置随机生成数的种子
tf.set_random_seed(args.seed)
# 全局的 step
global_step = tf.Variable(0, trainable=False, name='global_step')
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
# batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# image_paths_placeholder = tf.placeholder(tf.string, shape=(None,3), name='image_paths')
# labels_placeholder = tf.placeholder(tf.int64, shape=(None,3), name='labels')
# input_queue = data_flow_ops.FIFOQueue(capacity=100000,
# dtypes=[tf.string, tf.int64],
# shapes=[(3,), (3,)],
# shared_name=None, name=None)
# enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder])
# the image is generated by sequence
# 在 cpu 中将 训练数据集的 batch 进行拆分，分成 num_gpus 份数据
with tf.device("/cpu:0"):
softmax_dataset = tf_data.Dataset.range(args.epoch_size *
args.max_nrof_epochs * 100)
softmax_dataset = softmax_dataset.map(lambda x: tf.py_func(
_sample_people_softmax, [x], [tf.string, tf.int32]))
softmax_dataset = softmax_dataset.flat_map(_from_tensor_slices)
softmax_dataset = softmax_dataset.map(_parse_function,
num_parallel_calls=2000)
softmax_dataset = softmax_dataset.batch(args.num_gpus *
single_batch_size)
softmax_iterator = softmax_dataset.make_initializable_iterator()
softmax_next_element = softmax_iterator.get_next()
softmax_next_element[0].set_shape(
(args.num_gpus * single_batch_size, args.image_height,
args.image_width, 3))
softmax_next_element[1].set_shape(args.num_gpus *
single_batch_size)
batch_image_split = tf.split(softmax_next_element[0],
args.num_gpus)
batch_label_split = tf.split(softmax_next_element[1],
args.num_gpus)
# # 在整体数据集上选出 3 元组（triplets）
# select_start_time = time.time()
# # Select triplets based on the embeddings
# print('Selecting suitable triplets for training')
# # 修改版本的 triplets
# nrof_examples = args.people_per_batch * args.images_per_person
# triplets, nrof_random_negs, nrof_triplets = select_triplets(emb_array, num_per_class,
# image_paths, args.people_per_batch, args.alpha)
# selection_time = time.time() - start_time
# print('(nrof_random_negs, nrof_triplets) = (%d, %d): time=%.3f seconds' %
# (nrof_random_negs, nrof_triplets, selection_time))
# 学习率设置
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# 优化器设置
print('Using optimizer: {}'.format(args.optimizer))
if args.optimizer == 'ADAGRAD':
opt = tf.train.AdagradOptimizer(learning_rate)
elif args.optimizer == 'MOM':
opt = tf.train.MomentumOptimizer(learning_rate, 0.9)
elif args.optimizer == 'ADAM':
opt = tf.train.AdamOptimizer(learning_rate,
beta1=0.9,
beta2=0.999,
epsilon=0.1)
else:
raise Exception("Not supported optimizer: {}".format(
args.optimizer))
tower_losses = []
tower_cross = []
tower_dist = []
tower_reg = []
for i in range(args.num_gpus):
with tf.device("/gpu:" + str(i)):
with tf.name_scope("tower_" + str(i)) as scope:
with slim.arg_scope([slim.model_variable, slim.variable],
device="/cpu:0"):
with tf.variable_scope(
tf.get_variable_scope()) as var_scope:
reuse = False if i == 0 else True
if args.network == 'inception_resnet_v1':
with tf.variable_scope(name_or_scope='',
reuse=tf.AUTO_REUSE):
prelogits, _ = inception_net.inference(
batch_image_split[i],
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.
embedding_size,
weight_decay=args.weight_decay)
print(prelogits)
# elif args.network == 'inception_net_v2':
# with tf.variable_scope(name_or_scope='', reuse=tf.AUTO_REUSE):
# prelogits, _ = inception_net_v2.inference(image_batch, args.keep_probability,
# phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size,
# weight_decay=args.weight_decay)
# print(prelogits)
# elif args.network == 'squeezenet':
# with tf.variable_scope(name_or_scope='', reuse=tf.AUTO_REUSE):
# prelogits, _ = squeezenet.inference(image_batch, args.keep_probability,
# phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size,
# weight_decay=args.weight_decay)
# print(prelogits)
else:
raise Exception(
"Not supported network: {}".format(
args.network))
if args.fc_bn:
prelogits = slim.batch_norm(
prelogits,
is_training=True,
decay=0.997,
epsilon=1e-5,
scale=True,
updates_collections=tf.GraphKeys.
UPDATE_OPS,
reuse=reuse,
scope='softmax_bn')
if args.loss_type == 'triplet':
embeddings = tf.nn.l2_normalize(
prelogits, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings,
[-1, 3, args.embedding_size]),
3, 1)
triplet_loss = facenet.triplet_loss(
anchor, positive, negative, args.alpha)
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
if args.network == 'sphere_network':
print(
'reg loss using weight_decay * tf.add_n'
)
reg_loss = args.weight_decay * tf.add_n(
regularization_losses)
else:
print('reg loss using tf.add_n')
# reg_loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
reg_loss = tf.add_n(regularization_losses)
loss = triplet_loss + reg_loss
tower_losses.append(loss)
tower_reg.append(reg_loss)
# elif args.loss_type =='cosface':
#loss = tf.add_n([cross_entropy_mean] + regularization_losses, name='total_loss')
tf.get_variable_scope().reuse_variables()
# 计算 total loss
total_loss = tf.reduce_mean(tower_losses)
total_reg = tf.reduce_mean(tower_reg)
losses = {}
losses['total_loss'] = total_loss
losses['total_reg'] = total_reg
# # Build a Graph that trains the model with one batch of examples and updates the model parameters
# train_op = facenet.train(total_loss, global_step, args.optimizer,
# learning_rate, args.moving_average_decay, tf.global_variables())
grads = opt.compute_gradients(total_loss,
tf.trainable_variables(),
colocate_gradients_with_ops=True)
apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_op = tf.group(apply_gradient_op)
# Create a saver
# saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
save_vars = [
var for var in tf.global_variables()
if 'Adagrad' not in var.name and 'global_step' not in var.name
]
saver = tf.train.Saver(save_vars, max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
allow_soft_placement=True))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(softmax_iterator.initializer)
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
# 如果有预训练好的 model，那就进行 restore 操作，将模型加载进行以后的 测试阶段
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, epoch, learning_rate_placeholder,
phase_train_placeholder, global_step, losses, train_op,
summary_op, summary_writer,
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, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder,
# batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size,
# args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size)
# 将训练好的模型 返回
return model_dir
def main(argv=None): # pylint: disable=unused-argument
if FLAGS.model_name:
subdir = FLAGS.model_name
preload_model = True
else:
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
preload_model = False
log_dir = os.path.join(os.path.expanduser(FLAGS.logs_base_dir), subdir)
if not os.path.isdir(
log_dir): # Create the log directory if it doesn't exist
os.mkdir(log_dir)
model_dir = os.path.join(os.path.expanduser(FLAGS.models_base_dir), subdir)
if not os.path.isdir(
model_dir): # Create the model directory if it doesn't exist
os.mkdir(model_dir)
# Store some git revision info in a text file in the log directory
src_path, _ = os.path.split(os.path.realpath(__file__))
store_training_info(src_path, log_dir, ' '.join(argv))
np.random.seed(seed=FLAGS.seed)
dataset = facenet.get_dataset(FLAGS.data_dir)
train_set, validation_set = facenet.split_dataset(dataset,
FLAGS.train_set_fraction,
FLAGS.split_mode)
print('Model directory: %s' % model_dir)
with tf.Graph().as_default():
tf.set_random_seed(FLAGS.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32,
shape=(FLAGS.batch_size,
FLAGS.image_size,
FLAGS.image_size, 3),
name='input')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Build the inference graph
embeddings = facenet.inference_nn4_max_pool_96(
images_placeholder,
FLAGS.pool_type,
FLAGS.use_lrn,
FLAGS.keep_probability,
phase_train=phase_train_placeholder)
# Split example embeddings into anchor, positive and negative
anchor, positive, negative = tf.split(0, 3, embeddings)
# Calculate triplet loss
loss = facenet.triplet_loss(anchor, positive, negative, FLAGS.alpha)
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op, _ = facenet.train(loss, global_step, FLAGS.optimizer,
FLAGS.learning_rate,
FLAGS.moving_average_decay)
# Create a saver
saver = tf.train.Saver(tf.all_variables(), max_to_keep=0)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(
log_device_placement=FLAGS.log_device_placement))
sess.run(init)
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
with sess.as_default():
if preload_model:
ckpt = tf.train.get_checkpoint_state(model_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise ValueError('Checkpoint not found')
# Training and validation loop
for epoch in range(FLAGS.max_nrof_epochs):
# Train for one epoch
step = train(sess, train_set, epoch, images_placeholder,
phase_train_placeholder, global_step, embeddings,
loss, train_op, summary_op, summary_writer)
# Test on validation set
validate(sess, validation_set, epoch, images_placeholder,
phase_train_placeholder, global_step, embeddings,
loss, 'validation', summary_writer)
# Test on training set
validate(sess, train_set, epoch, images_placeholder,
phase_train_placeholder, global_step, embeddings,
loss, 'training', summary_writer)
if (epoch % FLAGS.checkpoint_period
== 0) or (epoch == FLAGS.max_nrof_epochs - 1):
# Save the model checkpoint
print('Saving checkpoint')
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
# Save the model if it hasn't been saved before
graphdef_dir = os.path.join(model_dir, 'graphdef')
graphdef_filename = 'graph_def.pb'
if (not os.path.exists(
os.path.join(graphdef_dir, graphdef_filename))):
print('Saving graph definition')
tf.train.write_graph(sess.graph_def, graphdef_dir,
graphdef_filename, False)
def main(args):
network = importlib.import_module(args.model_def)
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir)
if not os.path.isdir(log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir, 'arguments.txt'))
# 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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
# 预训练模型
if args.pretrained_model:
print('Pre-trained model: %s' % os.path.expanduser(args.pretrained_model))
# # lfw 数据集的位置
# 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)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False, name='global_step')
# Placeholders for the learning rate, batch_size, phase_train, image_path, labels
learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder = tf.placeholder(tf.string, shape=(None, 3), name='image_paths')
labels_placeholder = tf.placeholder(tf.int64, shape=(None, 3), name='labels')
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3,), (3,)],
shared_name=None, name=None)
enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder])
# 读取数据的线程数，将下面改为 multi_gpu 运行的版本
nrof_preprocess_threads = 4
images_and_labels_all = []
for _ in range(nrof_preprocess_threads):
for gpu in range(args.num_gpus):
images_and_labels = []
# 每次都从 queue 中将数据 dequeue 出来
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
if args.random_crop:
image = tf.random_crop(image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
# pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
images_and_labels_all.append(images_and_labels)
# 将数据整理，并适用于下面的多 gpu 运行
image_batch_split = []
label_batch_split = []
# label_extend = []
for i in range(args.num_gpus):
image_batch, labels_batch = tf.train.batch_join(
images_and_labels_all[i], batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
labels_batch = tf.identity(labels_batch, 'label_batch')
image_batch_split.append(image_batch)
label_batch_split.append(labels_batch)
# label_extend.extend(labels_batch)
learning_rate = tf.train.exponential_decay(learning_rate_placeholder, global_step,
args.learning_rate_decay_epochs*args.epoch_size, args.learning_rate_decay_factor, staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# print('Using optimizer: {}'.format(args.optimizer))
# if args.optimizer == 'ADAGRAD':
# opt = tf.train.AdagradOptimizer(learning_rate)
# elif args.optimizer == 'MOM':
# opt = tf.train.MomentumOptimizer(learning_rate, rho=0.9, epsilon=1e-6)
# elif args.optimizer=='ADAM':
# opt = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999, epsilon=0.1)
# elif args.optimizer=='RMSPROP':
# opt = tf.train.RMSPropOptimizer(learning_rate, decay=0.9, momentum=0.9, epsilon=1.0)
# elif args.optimizer=='MOM':
# opt = tf.train.MomentumOptimizer(learning_rate, 0.9, use_nesterov=True)
# else:
# raise Exception('Not supported optimizer: {}'.format(args.optimizer))
# 在这部分进行 multi_gpu
print('Building training graph....')
tower_losses = []
tower_triplet = []
tower_reg= []
# embeddings_extend = []
embeddings_split = []
for i in range(args.num_gpus):
with tf.device("/gpu:" + str(i)):
with tf.name_scope("tower_" + str(i)) as scope:
with tf.variable_scope(tf.get_variable_scope()) as var_scope:
# Build the inference graph
with tf.variable_scope(name_or_scope='', reuse=tf.AUTO_REUSE):
# # Dequeues one batch for one tower
# image_batch_de, label_batch_de = batch_queue.dequeue()
prelogits, _ = network.inference(image_batch_split[i], args.keep_probability,
phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# embeddings_extend.extend(embeddings)
embeddings_split.append(embeddings)
# Split embeddings into anchor, postive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(tf.reshape(embeddings, [-1,3,args.embedding_size]), 3, 1)
triplet_loss_split = facenet.triplet_loss(anchor, positive, negative, args.alpha)
regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
tower_triplet.append(triplet_loss_split)
loss = triplet_loss_split + tf.add_n(regularization_losses)
tower_losses.append(loss)
tower_reg.append(regularization_losses)
# 同名变量可以重用
tf.get_variable_scope().reuse_variables()
total_loss = tf.reduce_mean(tower_losses)
total_reg = tf.reduce_mean(tower_reg)
losses = {}
losses['total_loss'] = total_loss
losses['total_reg'] = total_reg
# # 计算 embeddings 的均值
# tmp_embeddings = None
# for j in range(arg.num_gpus):
# if j > 0:
# tmp_embeddings += embeddings_split[j]
# else:
# tmp_embeddings = embeddings_split[j]
# embeddings = tmp_embeddings / args.num_gpus
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op = facenet.train(total_loss, global_step, args.optimizer,
learning_rate, args.moving_average_decay, tf.global_variables())
# grads = opt.compute_gradients(total_loss,tf.trainable_variables(),colocate_gradients_with_ops=True)
# apply_gradient_op = opt.apply_gradients(grads,global_step=global_step)
# update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
# with tf.control_dependencies(update_ops):
# train_op = tf.group(apply_gradient_op)
# Create a saver
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(), feed_dict={phase_train_placeholder:True})
sess.run(tf.local_variables_initializer(), feed_dict={phase_train_placeholder:True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train multi gpus for one epoch
epoch_start_time = time.time()
# for i in range(args.num_gpus):
train_multi_gpu(args, sess, train_set, epoch, image_paths_placeholder, labels_placeholder,
label_batch_split[0], label_batch_split[1], batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, enqueue_op, input_queue, global_step, embeddings_split[0], embeddings_split[1], losses['total_loss'], losses['total_reg'], train_op,
summary_op, summary_writer, args.learning_rate_schedule_file, args.embedding_size)
print('The %dth epoch running time is %.3f seconds!!!' %(epoch, time.time()-epoch_start_time))
# # Train for one epoch
# train(args, sess, epoch,
# learning_rate_placeholder, phase_train_placeholder, global_step,
# losses, train_op, summary_op, summary_writer, 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)
return model_dir
def train_multi_gpus(args, sess, dataset, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, input_queue, global_step, embeddings, anchors,
positives, negatives, train_op, summary_op,
summary_writer, learning_rate_schedule_file,
embedding_size):
batch_number = 0
if args.learning_rate > 0.0:
lr = args.learning_rate
else:
lr = facenet.get_learning_rate_from_file(learning_rate_schedule_file,
epoch)
while batch_number < args.epoch_size:
# Sample people randomly from the dataset
image_paths, num_per_class = sample_people(dataset,
args.people_per_batch,
args.images_per_person)
print('Running forward pass on sampled images: ', end='')
start_time = time.time()
nrof_examples = args.people_per_batch * args.images_per_person
labels_array = np.reshape(np.arange(nrof_examples), (-1, 3))
image_paths_array = np.reshape(
np.expand_dims(np.array(image_paths), 1), (-1, 3))
sess.run(
enqueue_op, {
image_paths_placeholder: image_paths_array,
labels_placeholder: labels_array
})
emb_array = np.zeros((nrof_examples, embedding_size))
nrof_batches = int(np.ceil(nrof_examples / args.batch_size))
for i in range(nrof_batches):
batch_size = min(nrof_examples - i * args.batch_size,
args.batch_size)
emb, lab = sess.run(
[embeddings, labels_batch],
feed_dict={
batch_size_placeholder: batch_size,
learning_rate_placeholder: lr,
phase_train_placeholder: True
})
emb_array[lab, :] = emb
print('加载数据完毕，用时 %.3f' % (time.time() - start_time))
# Select triplets based on the embeddings
print('Selecting suitable triplets for training...')
triplets, nrof_random_negs, nrof_triplets = select_triplets(
emb_array, num_per_class, image_paths, args.people_per_batch,
args.alpha)
selection_time = time.time() - start_time
print(
'选择 三元组 完毕 --- (nrof_random_negs, nrif_triplets) = (%d, %d): time=%.3f seconds'
% (nrof_random_negs, nrof_triplets, selection_time))
# 在选定的 triplets 上执行 训练
nrof_batches = int(np.ceil(nrof_triplets * 3 / args.batch_size))
print('选择出来的 triplets 形成的 batch 有多少个：', nrof_batches)
triplet_paths = list(itertools.chain(*triplets))
# print('triplet_paths:', triplet_paths)
labels_array = np.reshape(np.arange(len(triplet_paths)), (-1, 3))
triplet_paths_array = np.reshape(
np.expand_dims(np.array(triplet_paths), 1), (-1, 3))
# 把 选择出来的 triplets 添加到 enqueue 中去
sess.run(
enqueue_op, {
image_paths_placeholder: triplet_paths_array,
labels_placeholder: labels_array
})
nrof_examples = len(triplet_paths)
print('选择出的 triplets 的个数为：', nrof_examples)
train_time = 0
i = 0
emb_array = np.zeros((nrof_examples, embedding_size))
loss_array = np.zeros((nrof_triplets, ))
summary = tf.Summary()
step = 0
while i < nrof_batches:
start_time = time.time()
# 添加 计算 loss 的代码，加在此处，是因为每个 epoch 中的每个 batch 都要计算一下 loss
# First, calculate the total_loss to run the following code
# 在这部分修改为 multi-gpu 训练
# 即 将每一个 batch 均分，然后在多个 gpu 上来计算对应的 triplet_loss ，之后汇总得到和，求取平均，得到一个 batch_size 的 loss
tower_losses = []
tower_triplets = []
tower_reg = []
with tf.variable_scope(tf.get_variable_scope()):
for i in range(args.num_gpus):
with tf.device('/gpu:' + str(i + 2)):
with tf.name_scope('tower_' + str(i)) as scope:
print('###' * 10, i)
print('---' * 10, anchors[i])
print('---' * 10, positives[i])
print('---' * 10, negatives[i])
print('###' * 10, i)
triplet_loss_split = facenet.triplet_loss(
anchors[i], positives[i], negatives[i],
args.alpha)
regularization_loss = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
# 添加本行代码，进行同名变量的重用
tf.get_variable_scope().reuse_variables()
tower_triplets.append(triplet_loss_split)
loss = triplet_loss_split + tf.add_n(
regularization_loss)
tower_losses.append(loss)
tower_reg.append(regularization_loss)
# 计算 multi gpu 运行完成得到的 loss
total_loss = tf.reduce_mean(tower_losses)
total_reg = tf.reduce_mean(tower_reg)
losses = {}
losses['total_loss'] = total_loss
losses['total_reg'] = total_reg
loss = total_loss
batch_size = min(nrof_examples - i * args.batch_size,
args.batch_size)
feed_dict = {
batch_size_placeholder: batch_size,
learning_rate_placeholder: lr,
phase_train_placeholder: True
}
# --- print start ---
print('**************batch_size', batch_size)
print('**************lr', lr)
print('**************loss', loss, loss.get_shape())
print('**************train_op', train_op)
print('**************global_step', global_step)
print('**************embeddings', embeddings,
embeddings.get_shape())
print('**************labels_batch', labels_batch,
labels_batch.get_shape())
# --- print end -----
err, _, step, emb, lab = sess.run(
[loss, train_op, global_step, embeddings, labels_batch],
feed_dict=feed_dict)
emb_array[lab, :] = emb
loss_array[i] = err
duration = time.time() - start_time
print('Epoch: [%d][%d/%d]\tTime %.3f\tLoss %2.3f' %
(epoch, batch_number + 1, args.epoch_size, duration, err))
batch_number += 1
i += 1
train_time += duration
summary.value.add(tag='loss', simple_value=err)
# Add validation loss and accuracy to summary
#pylint: disable=maybe-no-member
summary.value.add(tag='time/selection', simple_value=selection_time)
summary_writer.add_summary(summary, step)
return step
def main(argv=None): # pylint: disable=unused-argument
if FLAGS.model_name:
subdir = FLAGS.model_name
preload_model = True
else:
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
preload_model = False
log_dir = os.path.join(os.path.expanduser(FLAGS.logs_base_dir), subdir)
model_dir = os.path.join(os.path.expanduser(FLAGS.models_base_dir), subdir)
if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist
os.mkdir(model_dir)
np.random.seed(seed=FLAGS.seed)
dataset = facenet.get_dataset(FLAGS.data_dir)
train_set, validation_set = facenet.split_dataset(dataset, FLAGS.train_set_fraction, FLAGS.split_mode)
print('Model directory: %s' % model_dir)
with tf.Graph().as_default():
tf.set_random_seed(FLAGS.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32, shape=(FLAGS.batch_size, FLAGS.image_size, FLAGS.image_size, 3),
name='input')
# Placeholder for phase_train
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# Build the inference graph
embeddings = facenet.inference_nn4_max_pool_96(images_placeholder, phase_train=phase_train_placeholder)
# Split example embeddings into anchor, positive and negative
anchor, positive, negative = tf.split(0, 3, embeddings)
# Calculate triplet loss
loss = facenet.triplet_loss(anchor, positive, negative)
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op, _ = facenet.train(loss, global_step)
# Create a saver
saver = tf.train.Saver(tf.all_variables(), max_to_keep=0)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=FLAGS.log_device_placement))
sess.run(init)
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
with sess.as_default():
if preload_model:
ckpt = tf.train.get_checkpoint_state(model_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise ValueError('Checkpoint not found')
# Training and validation loop
for epoch in range(FLAGS.max_nrof_epochs):
# Train for one epoch
step = train(sess, train_set, epoch, images_placeholder, phase_train_placeholder,
global_step, embeddings, loss, train_op, summary_op, summary_writer)
# Validate epoch
validate(sess, validation_set, epoch, images_placeholder, phase_train_placeholder,
global_step, embeddings, loss, train_op, summary_op, summary_writer)
# Save the model checkpoint after each epoch
print('Saving checkpoint')
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
graphdef_dir = os.path.join(model_dir, 'graphdef')
graphdef_filename = 'graph_def.pb'
if (not os.path.exists(os.path.join(graphdef_dir, graphdef_filename))):
print('Saving graph definition')
tf.train.write_graph(sess.graph_def, graphdef_dir, graphdef_filename, False)
def main(args):
image_size = (args.image_size, args.image_size)
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)
stat_file_name = os.path.join(log_dir, 'stat.h5')
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# 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)
random.seed(args.seed)
dataset = facenet.get_dataset(args.data_dir)
nrof_classes = len(dataset)
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)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
input_queue = data_flow_ops.FIFOQueue(capacity=200000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder], name='enqueue_op')
# image_batch, label_batch = facenet.create_input_pipeline(input_queue, image_size, nrof_preprocess_threads, batch_size_placeholder)
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
if args.random_crop:
image = tf.random_crop(
image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(
image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
# pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
label_batch = tf.identity(labels_batch, 'label_batch')
print('Number of classes in training set: %d' % nrof_classes)
print('Building training graph')
with tf.contrib.slim.arg_scope(
mobilenet_v2.training_scope(
is_training=True,
dropout_keep_prob=args.keep_probability,
weight_decay=args.weight_decay)):
logits, end_points = mobilenet_v2.mobilenet(
image_batch, num_classes=nrof_classes)
prelogits = tf.squeeze(end_points['global_pool'], [1, 2])
print('After mobilenet ')
logits = slim.fully_connected(
prelogits,
args.embedding_size,
activation_fn=None,
weights_initializer=slim.initializers.xavier_initializer(),
reuse=False)
embeddings = tf.identity(logits, 'embeddings')
"""
Tensor("Squeeze:0", shape=(?, 1280), dtype=float32)
Tensor("fully_connected/BiasAdd:0", shape=(?, 512), dtype=float32)
Tensor("label_batch:0", shape=(?,), dtype=int64)
"""
print('logits node')
print(prelogits)
print(logits)
print(label_batch)
# g = tf.get_default_graph()
# tf.contrib.quantize.create_training_graph(input_graph=g)
# Norm for the prelogits
eps = 1e-4
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + 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.global_variables())
# Create a saver
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# saver_new = tf.train.Saver(max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
# gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, 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
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, dataset, epoch, image_paths_placeholder,
labels_placeholder, label_batch, batch_size_placeholder,
learning_rate_placeholder, enqueue_op, input_queue,
global_step, embeddings, total_loss, train_op,
summary_op, summary_writer,
args.learning_rate_schedule_file, args.embedding_size,
anchor, positive, negative, triplet_loss)
# 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, lfw_paths, embeddings, label_batch,
image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder,
enqueue_op, actual_issame, args.batch_size,
args.lfw_nrof_folds, log_dir, step,
summary_writer, args.embedding_size)
return model_dir
def main(args):
network = importlib.import_module(args.model_def)
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir)
if not os.path.isdir(
log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
if not os.path.isdir(
model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# 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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' %
os.path.expanduser(args.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)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder])
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
if args.random_crop:
image = tf.random_crop(
image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(
image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
labels_batch = tf.identity(labels_batch, 'label_batch')
# Build the inference graph
prelogits, _ = network.inference(
image_batch,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args.alpha)
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + 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.global_variables())
# Create a saver
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
# facenet.load_model(args.pretrained_model)
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, train_set, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, input_queue, global_step, embeddings,
total_loss, train_op, summary_op, summary_writer,
args.learning_rate_schedule_file, args.embedding_size,
anchor, positive, negative, triplet_loss)
# 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, lfw_paths, embeddings, labels_batch,
image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, enqueue_op,
actual_issame, args.batch_size,
args.lfw_nrof_folds, log_dir, step,
summary_writer, args.embedding_size)
return model_dir
def main(args):
# 导入网络架构模型
network = importlib.import_module(args['model_def'])
# 用当前日期来命名模型
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
# 日志保存目录
log_dir = os.path.join(os.path.expanduser(args['logs_base_dir']), subdir)
# 没有日志文件就创建一个
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args['models_base_dir']),
subdir)
# 没有模型保存目录就创建一个
if not os.path.isdir(model_dir):
os.makedirs(model_dir)
# 保存参数日志
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# 设置随机数种子
np.random.seed(seed=args['seed'])
# 获取数据集，train_set是包含文件路径与标签的集合
# 包含图片地址的（image_paths）以及对应的人名(name)
train_set = facenet.get_dataset(args['data_dir'])
print('模型目录: %s' % model_dir)
print('log目录: %s' % log_dir)
# 判断是否有预训练模型
if args['pretrained_model']:
print('Pre-trained model: %s' %
os.path.expanduser(args['pretrained_model']))
if args['lfw_dir']:
print('LFW目录: %s' % args['lfw_dir'])
# 读取用于测试的pairs文件
pairs = lfw.read_pairs(os.path.expanduser(args['lfw_pairs']))
shuffle(pairs)
# 获取对应的路径
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)
# 学习率
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
# 批大小
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
# 用于判断是训练还是测试
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# 图像路径
image_paths_placeholder = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths')
# 图像标签
labels_placeholder = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels')
# 新建一个队列，数据流操作，先入先出
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder])
preprocess_threads = 4
images_and_labels = []
for _ in range(preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unstack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_image(file_contents, channels=3)
# 随机水平反转
if args['random_flip']:
image = tf.image.random_flip_left_right(image)
image.set_shape((args['image_size'], args['image_size'], 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels,
batch_size=batch_size_placeholder,
shapes=[(args['image_size'], args['image_size'], 3), ()],
enqueue_many=True,
capacity=4 * preprocess_threads * args['batch_size'],
allow_smaller_final_batch=True)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
labels_batch = tf.identity(labels_batch, 'label_batch')
# 构造计算图
# 其中prelogits是最后一层的输出
prelogits, _ = network.inference(
image_batch,
args['keep_probability'],
phase_train=phase_train_placeholder,
bottleneck_layer_size=args['embedding_size'],
weight_decay=args['weight_decay'])
# L2正则化
# embeddings = tf.nn.l2_normalize
# 输入向量, L2范化的维数（取0（列L2范化）或1（行L2范化））
# 泛化的最小值边界, name='embeddings')
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
# 计算 triplet_loss
anchor, positive, negative = tf.unstack(
tf.reshape(embeddings, [-1, 3, args['embedding_size']]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
args['alpha'])
# 将指数衰减应用在学习率上
learning_rate = tf.train.exponential_decay(learning_rate_placeholder, global_step,
args['learning_rate_decay_epochs']\
* args['epoch_size'],
args['learning_rate_decay_factor'],
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# 计算损失
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
# 构建L2正则化
total_loss = tf.add_n([triplet_loss] + regularization_losses,
name='total_loss')
# 确定优化方法并根据损失函求梯度，每更新一次参数，global_step 会加 1
train_op = facenet.train(total_loss, global_step, args['optimizer'],
learning_rate, args['moving_average_decay'],
tf.global_variables())
# 创建一个saver用来保存或者从内存中读取一个模型参数
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
summary_op = tf.summary.merge_all()
# 设置显存比例
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args['gpu_memory_fraction'])
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# 初始化变量
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
# 写log文件
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
# 获取线程
coord = tf.train.Coordinator()
# 将队列中的多用sunner开始执行
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
# 读入预训练模型（如果有）
if args['pretrained_model']:
print('载入预训练模型: %s' % args['pretrained_model'])
# saver.restore(sess, os.path.expanduser(args['pretrained_model']))
facenet.load_model(args['pretrained_model'])
epoch = 0
# 将所有数据过一遍的次数
while epoch < args['max_nrof_epochs']:
step = sess.run(global_step, feed_dict=None)
# epoch_size是一个epoch中批的个数
# epoch是全局的批处理个数以一个epoch中。。。这个epoch将用于求学习率
epoch = step // args['epoch_size']
# 训练一个epoch
train(args, sess, train_set, epoch, image_paths_placeholder,
labels_placeholder, labels_batch, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op, input_queue, global_step, embeddings,
total_loss, train_op, summary_op, summary_writer,
args['learning_rate_schedule_file'],
args['embedding_size'], anchor, positive, negative,
triplet_loss)
# 保存变量和metagraph（如果不存在）
save_variables_and_metagraph(sess, saver, summary_writer,
model_dir, subdir, step)
# 使用lfw评价当前模型
if args['lfw_dir']:
evaluate(sess, lfw_paths, embeddings, labels_batch,
image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder,
phase_train_placeholder, enqueue_op,
actual_issame, args['batch_size'],
args['lfw_nrof_folds'], log_dir, step,
summary_writer, args['embedding_size'])
return model_dir
def train():
dataset = facenet.get_dataset(FLAGS.data_dir)
train_set, test_set = facenet.split_dataset(dataset, 0.9)
fileName = "/home/david/debug4.h5"
f = h5py.File(fileName, "r")
for item in f.values():
print(item)
w1 = f['1w'][:]
b1 = f['1b'][:]
f.close()
print(w1.shape)
print(b1.shape)
"""Train CIFAR-10 for a number of steps."""
with tf.Graph().as_default():
global_step = tf.Variable(0, trainable=False)
# Placeholder for input images
images_placeholder = tf.placeholder(tf.float32, shape=(FLAGS.batch_size, 96, 96, 3), name='Input')
# Build a Graph that computes the logits predictions from the inference model
#embeddings = facenet.inference_nn4_max_pool_96(images_placeholder, phase_train=True)
conv1 = _conv(images_placeholder, 3, 64, 7, 7, 2, 2, 'SAME', 'conv1_7x7', phase_train=False, use_batch_norm=False, init_weight=w1, init_bias=b1)
resh1 = tf.reshape(conv1, [-1, 294912])
embeddings = _affine(resh1, 294912, 128)
# Split example embeddings into anchor, positive and negative
a, p, n = tf.split(0, 3, embeddings)
# Calculate triplet loss
loss = facenet.triplet_loss(a, p, n)
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op, grads = facenet.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.merge_all_summaries()
# Build an initialization operation to run below.
init = tf.initialize_all_variables()
# Start running operations on the Graph.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=FLAGS.log_device_placement))
sess.run(init)
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, graph_def=sess.graph_def)
epoch = 0
with sess.as_default():
while epoch<FLAGS.max_nrof_epochs:
batch_number = 0
while batch_number<FLAGS.epoch_size:
print('Loading new data')
image_data, num_per_class, image_paths = facenet.load_data(train_set)
print('Selecting suitable triplets for training')
start_time = time.time()
emb_list = []
# Run a forward pass for the sampled images
nrof_examples_per_epoch = FLAGS.people_per_batch*FLAGS.images_per_person
nrof_batches_per_epoch = int(np.floor(nrof_examples_per_epoch/FLAGS.batch_size))
if True:
for i in xrange(nrof_batches_per_epoch):
feed_dict, _ = facenet.get_batch(images_placeholder, image_data, i)
emb_list += sess.run([embeddings], feed_dict=feed_dict)
emb_array = np.vstack(emb_list) # Stack the embeddings to a nrof_examples_per_epoch x 128 matrix
# Select triplets based on the embeddings
apn, nrof_random_negs, nrof_triplets = facenet.select_triplets(emb_array, num_per_class, image_data)
duration = time.time() - start_time
print('(nrof_random_negs, nrof_triplets) = (%d, %d): time=%.3f seconds' % (nrof_random_negs, nrof_triplets, duration))
count = 0
while count<nrof_triplets*3 and batch_number<FLAGS.epoch_size:
start_time = time.time()
feed_dict, batch = facenet.get_batch(images_placeholder, apn, batch_number)
if (batch_number%20==0):
err, summary_str, _ = sess.run([loss, summary_op, train_op], feed_dict=feed_dict)
summary_writer.add_summary(summary_str, FLAGS.epoch_size*epoch+batch_number)
else:
err, _ = sess.run([loss, train_op], feed_dict=feed_dict)
duration = time.time() - start_time
print('Epoch: [%d][%d/%d]\tTime %.3f\ttripErr %2.3f' % (epoch, batch_number, FLAGS.epoch_size, duration, err))
batch_number+=1
count+=FLAGS.batch_size
else:
while batch_number<FLAGS.epoch_size:
start_time = time.time()
feed_dict, _ = facenet.get_batch(images_placeholder, image_data, batch_number)
grad_tensors, grad_vars = zip(*grads)
eval_list = (train_op, loss) + grad_tensors
result = sess.run(eval_list, feed_dict=feed_dict)
grads_eval = result[2:]
nrof_parameters = 0
for gt, gv in zip(grads_eval, grad_vars):
print('%40s: %6d' % (gv.op.name, np.size(gt)))
nrof_parameters += np.size(gt)
print('Total number of parameters: %d' % nrof_parameters)
err = result[1]
batch_number+=1
epoch+=1
# Save the model checkpoint periodically.
checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=epoch*FLAGS.epoch_size+batch_number)
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)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' % os.path.expanduser(args.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)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32, name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder = tf.placeholder(tf.string, shape=(None,3), name='image_paths')
labels_placeholder = tf.placeholder(tf.int64, shape=(None,3), name='labels')
input_queue = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3,), (3,)],
shared_name=None, name=None)
enqueue_op = input_queue.enqueue_many([image_paths_placeholder, labels_placeholder])
nrof_preprocess_threads = 4
images_and_labels = []
for _ in range(nrof_preprocess_threads):
filenames, label = input_queue.dequeue()
images = []
for filename in tf.unpack(filenames):
file_contents = tf.read_file(filename)
image = tf.image.decode_png(file_contents)
if args.random_crop:
image = tf.random_crop(image, [args.image_size, args.image_size, 3])
else:
image = tf.image.resize_image_with_crop_or_pad(image, args.image_size, args.image_size)
if args.random_flip:
image = tf.image.random_flip_left_right(image)
#pylint: disable=no-member
image.set_shape((args.image_size, args.image_size, 3))
images.append(tf.image.per_image_standardization(image))
images_and_labels.append([images, label])
image_batch, labels_batch = tf.train.batch_join(
images_and_labels, batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()], enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
# Build the inference graph
prelogits, _ = network.inference(image_batch, args.keep_probability,
phase_train=phase_train_placeholder, weight_decay=args.weight_decay)
pre_embeddings = slim.fully_connected(prelogits, args.embedding_size, activation_fn=None, scope='Embeddings', reuse=False)
#embedding_size = 1792
embeddings = tf.nn.l2_normalize(pre_embeddings, 1, 1e-10, name='embeddings')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor, positive, negative = tf.unpack(tf.reshape(embeddings, [-1,3,args.embedding_size]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative, args.alpha)
learning_rate = tf.train.exponential_decay(learning_rate_placeholder, global_step,
args.learning_rate_decay_epochs*args.epoch_size, args.learning_rate_decay_factor, staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# Calculate the total losses
regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add_n([triplet_loss] + regularization_losses, name='total_loss')
# Create list with variables to restore
restore_vars = []
update_gradient_vars = []
if args.pretrained_model:
update_gradient_vars = tf.global_variables()
for var in tf.global_variables():
if not 'Embeddings/' in var.op.name:
restore_vars.append(var)
#else:
#update_gradient_vars.append(var)
else:
restore_vars = tf.global_variables()
update_gradient_vars = tf.global_variables()
# 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, update_gradient_vars)
# Create a saver
restore_saver = tf.train.Saver(restore_vars)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=3)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.summary.merge_all()
# Start running operations on the Graph.
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# Initialize variables
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
tf.train.start_queue_runners(sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
restore_saver.restore(sess, os.path.expanduser(args.pretrained_model))
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, train_set, epoch, image_paths_placeholder, labels_placeholder, labels_batch,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, input_queue, global_step,
embeddings, total_loss, train_op, summary_op, summary_writer, args.learning_rate_schedule_file,
args.embedding_size, anchor, positive, negative, triplet_loss)
# 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, lfw_paths, embeddings, labels_batch, image_paths_placeholder, labels_placeholder,
batch_size_placeholder, learning_rate_placeholder, phase_train_placeholder, enqueue_op, actual_issame, args.batch_size,
args.seed, args.lfw_nrof_folds, log_dir, step, summary_writer, args.embedding_size)
return model_dir
def run_queue_for_lfw(self, input_dict, num_classes, lfw_list,
output_image_dir):
graph = input_dict["graph"]
images = input_dict["x"]
raw_images = input_dict["x_raw"]
labels = input_dict["y_"]
logits = input_dict["y_conv"]
adversarial_perturbation_min = self.config.getfloat(
'main', 'adversarial_perturbation_min')
adversarial_perturbation_max = self.config.getfloat(
'main', 'adversarial_perturbation_max')
adversarial_perturbation_steps = self.config.getfloat(
'main', 'adversarial_perturbation_steps')
perturbation_const = self.config.getfloat('main', 'perturbation_const')
with graph.as_default():
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
y_ = tf.one_hot(indices=tf.cast(labels, "int64"),
depth=num_classes,
on_value=1.0,
off_value=0.0)
anchor, positive, negative = tf.unstack(
tf.reshape(logits, [-1, 3, 128]), 3, 1)
triplet_loss = facenet.triplet_loss(anchor, positive, negative,
0.2)
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = tf.add(triplet_loss, regularization_losses)
#cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits, y_)
grad = tf.gradients(total_loss, images)
print("succeed in calculating loss")
with tf.Session() as sess:
# Start the queue runners.
sess.run(init_op)
coord = tf.train.Coordinator()
try:
threads = []
for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
threads.extend(
qr.create_threads(sess,
coord=coord,
daemon=True,
start=True))
print("succeed in producing threads")
sample_count = int(
self.config.get('main', 'num_examples_per_epoch_eval'))
print(
"succeed in initializing adv_diff or all kinds of stuffs"
)
step = 0
while step < sample_count and not coord.should_stop():
print("Initialising")
sess.run([raw_images])
print("1")
raw_images_val, images_val, labels_val, triplet_loss_val, grad_val = sess.run(
[
raw_images, images, labels, triplet_loss,
grad[0]
])
print("succeeded in sess.run()")
filename_1 = os.path.join(output_image_dir,
str(perturbation_const))
if os.path.exists(filename_1):
filename_2 = filename_1
else:
os.makedirs(filename_1)
filename_2 = filename_1
for i in range(len(images_val)):
image = raw_images_val[i]
true_label = labels_val[i]
filename_3 = os.path.join(filename_2,
lfw_list[true_label])
if os.path.exists(filename_3):
filename_4 = filename_3
else:
os.makedirs(filename_3)
filename_4 = filename_3
grad_sign = grad_val[i]
adv_image = perturbation_const * grad_sign + image
step += 1
print("adversarial example is generated")
adv_image_reshaped = np.reshape(
adv_image, np.insert(adv_image.shape, 0, 1))
output_image = tf.cast(adv_image, tf.uint8)
print("output:%s" % output_image)
filename_jpeg = '%s-%03d.jpeg' % (
lfw_list[true_label], i)
filename_jpeg_2 = os.path.join(
filename_4, filename_jpeg)
with open(filename_jpeg_2, 'wb') as f:
f.write(
sess.run(
tf.image.encode_png(output_image)))
print(
"succeeded in generating adversarial examples")
except Exception as e:
coord.request_stop(e)
print("failed to load")
coord.request_stop()
coord.join(threads, stop_grace_period_secs=10)
def main(args):
network = importlib.import_module(args.model_def)
subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S')
log_dir = os.path.join(os.path.expanduser(args.logs_base_dir), subdir)
if not os.path.isdir(
log_dir): # Create the log directory if it doesn't exist
os.makedirs(log_dir)
model_dir = os.path.join(os.path.expanduser(args.models_base_dir), subdir)
if not os.path.isdir(
model_dir): # Create the model directory if it doesn't exist
os.makedirs(model_dir)
# Write arguments to a text file
facenet.write_arguments_to_file(args, os.path.join(log_dir,
'arguments.txt'))
# 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_ID = facenet.get_dataset(args.data_dir_ID)
train_set_camera = facenet.get_dataset(args.data_dir_camera)
print('Model directory: %s' % model_dir)
print('Log directory: %s' % log_dir)
if args.pretrained_model:
print('Pre-trained model: %s' %
os.path.expanduser(args.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)
# associative, fengchen
assoc = Associative(network, args)
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
global_step = tf.Variable(0, trainable=False)
# Placeholder for the learning rate
learning_rate_placeholder = tf.placeholder(tf.float32,
name='learning_rate')
batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
image_paths_placeholder_ID = tf.placeholder(tf.string,
shape=(None, 3),
name='image_paths_ID')
image_paths_placeholder_camera = tf.placeholder(
tf.string, shape=(None, 3), name='image_paths_camera')
image_paths_placeholder_valid = tf.placeholder(
tf.string, shape=(None, 3), name='image_paths_valid')
labels_placeholder_ID = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels_ID')
labels_placeholder_camera = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels_camera')
labels_placeholder_valid = tf.placeholder(tf.int64,
shape=(None, 3),
name='labels_valid')
input_queue_ID = data_flow_ops.FIFOQueue(capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
input_queue_camera = data_flow_ops.FIFOQueue(
capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
input_queue_valid = data_flow_ops.FIFOQueue(
capacity=100000,
dtypes=[tf.string, tf.int64],
shapes=[(3, ), (3, )],
shared_name=None,
name=None)
enqueue_op_ID = input_queue_ID.enqueue_many(
[image_paths_placeholder_ID, labels_placeholder_ID])
enqueue_op_camera = input_queue_camera.enqueue_many(
[image_paths_placeholder_camera, labels_placeholder_camera])
enqueue_op_valid = input_queue_valid.enqueue_many(
[image_paths_placeholder_valid, labels_placeholder_valid])
nrof_preprocess_threads = 4
images_and_labels_ID = get_images_and_labels(nrof_preprocess_threads,
input_queue_ID)
images_and_labels_camera = get_images_and_labels(
nrof_preprocess_threads, input_queue_camera)
images_and_labels_valid = get_images_and_labels(
nrof_preprocess_threads, input_queue_valid)
image_batch_ID, labels_batch_ID = tf.train.batch_join(
images_and_labels_ID,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch_ID = tf.identity(image_batch_ID, 'image_batch_ID')
image_batch_ID = tf.identity(image_batch_ID, 'input_ID')
labels_batch_ID = tf.identity(labels_batch_ID, 'label_batch_ID')
image_batch_camera, labels_batch_camera = tf.train.batch_join(
images_and_labels_camera,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch_camera = tf.identity(image_batch_camera,
'image_batch_camera')
image_batch_camera = tf.identity(image_batch_camera, 'input_camera')
labels_batch_camera = tf.identity(labels_batch_camera,
'label_batch_camera')
image_batch_valid, labels_batch_valid = tf.train.batch_join(
images_and_labels_valid,
batch_size=batch_size_placeholder,
shapes=[(args.image_size, args.image_size, 3), ()],
enqueue_many=True,
capacity=4 * nrof_preprocess_threads * args.batch_size,
allow_smaller_final_batch=True)
image_batch_valid = tf.identity(image_batch_valid, 'image_batch_valid')
labels_batch_valid = tf.identity(labels_batch_valid,
'label_batch_valid')
image_paths_ID, _ = sample_people(train_set_ID,
args.people_per_batch_mmd,
args.images_per_person_mmd)
image_paths_camera, _ = sample_people(train_set_camera,
args.people_per_batch_mmd,
args.images_per_person_mmd)
images_mmd_ID = get_image_mmd(image_paths_ID)
images_mmd_camera = get_image_mmd(image_paths_camera)
# Build the inference graph
prelogits_ID, _, _, _, _ = network.inference(
image_batch_ID,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
prelogits_camera, _, _, _, _ = network.inference(
image_batch_camera,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
_, _, _, feature_map3_ID, _ = network.inference(
images_mmd_ID,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
_, _, _, feature_map3_camera, _ = network.inference(
images_mmd_camera,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
prelogits_valid, _, _, _, _ = network.inference(
image_batch_valid,
args.keep_probability,
phase_train=phase_train_placeholder,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay)
embeddings_ID = tf.nn.l2_normalize(prelogits_ID,
1,
1e-10,
name='embeddings_ID')
embeddings_camera = tf.nn.l2_normalize(prelogits_camera,
1,
1e-10,
name='embeddings_camera')
embeddings_valid = tf.nn.l2_normalize(prelogits_valid,
1,
1e-10,
name='embeddings_valid')
# Split embeddings into anchor, positive and negative and calculate triplet loss
anchor_ID, positive_ID, negative_ID = tf.unstack(
tf.reshape(embeddings_ID, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss_ID = facenet.triplet_loss(anchor_ID, positive_ID,
negative_ID, args.alpha)
anchor_camera, positive_camera, negative_camera = tf.unstack(
tf.reshape(embeddings_camera, [-1, 3, args.embedding_size]), 3, 1)
triplet_loss_camera = facenet.triplet_loss(anchor_camera,
positive_camera,
negative_camera, args.alpha)
learning_rate = tf.train.exponential_decay(
learning_rate_placeholder,
global_step,
args.learning_rate_decay_epochs * args.epoch_size,
args.learning_rate_decay_factor,
staircase=True)
tf.summary.scalar('learning_rate', learning_rate)
# associative, fengchen
associative_loss = assoc.loss() * 10
# Calculate the total losses
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
loss_feature_map3 = mmd_loss(feature_map3_ID, feature_map3_camera)
# loss_feature_map3 = 3*loss_feature_map3
triplet_loss = tf.add_n([triplet_loss_ID] + [triplet_loss_camera] +
regularization_losses,
name='triplet_loss')
loss_total = tf.add_n([triplet_loss_ID] + [triplet_loss_camera] +
[loss_feature_map3] + [associative_loss] +
regularization_losses,
name='loss_total')
# Build a Graph that trains the model with one batch of examples and updates the model parameters
train_op = facenet.train(loss_total, global_step, args.optimizer,
learning_rate, args.moving_average_decay,
tf.global_variables())
train_op_triplet = facenet.train(triplet_loss, global_step,
args.optimizer, learning_rate,
args.moving_average_decay,
tf.global_variables())
# 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))
# Initialize variables
sess.run(tf.global_variables_initializer(),
feed_dict={phase_train_placeholder: True})
sess.run(tf.local_variables_initializer(),
feed_dict={phase_train_placeholder: True})
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if args.pretrained_model:
print('Restoring pretrained model: %s' % args.pretrained_model)
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
saver.restore(sess, os.path.expanduser(args.pretrained_model))
saver = tf.train.Saver(tf.global_variables(), max_to_keep=3)
# Training and validation loop
epoch = 0
while epoch < args.max_nrof_epochs:
step = sess.run(global_step, feed_dict=None)
epoch = step // args.epoch_size
# Train for one epoch
train(args, sess, train_set_ID, train_set_camera, epoch,
image_paths_placeholder_ID,
image_paths_placeholder_camera, labels_placeholder_ID,
labels_placeholder_camera, labels_batch_ID,
labels_batch_camera, batch_size_placeholder,
learning_rate_placeholder, phase_train_placeholder,
enqueue_op_ID, enqueue_op_camera, global_step,
embeddings_ID, embeddings_camera, triplet_loss,
loss_total, triplet_loss_ID, triplet_loss_camera,
loss_feature_map3, associative_loss,
regularization_losses, train_op, train_op_triplet,
summary_writer, args.learning_rate_schedule_file,
args.embedding_size)
# 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, lfw_paths, embeddings_valid,
labels_batch_valid, image_paths_placeholder_valid,
labels_placeholder_valid, batch_size_placeholder,
learning_rate_placeholder,
phase_train_placeholder, enqueue_op_valid,
actual_issame, args.batch_size,
args.lfw_nrof_folds, log_dir, step,
summary_writer, args.embedding_size)
return model_dir
