def load_network(model_path):
sess = tf.Session()
images_pl = tf.placeholder(tf.float32,
shape=[None, 200, 200, 3],
name='input_image')
images_norm = tf.map_fn(
lambda frame: tf.image.per_image_standardization(frame), images_pl)
train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images_norm,
keep_probability=0.8,
phase_train=train_mode,
weight_decay=1e-5)
gender = tf.argmax(tf.nn.softmax(gender_logits), 1)
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits), age_), axis=1)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(model_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("restore model!")
else:
pass
return sess, age, gender, train_mode, images_pl
def __init__(self, face_rec_graph, model_dir):
"""
:param face_rec_graph: 输入人脸的graph
:param model_dir: 用于识别人脸的model的路径
"""
model_path = model_dir + get_model_name(model_dir)
# print(model_path)
print('正在加载model...')
config = tf.ConfigProto()
# config.allow_soft_placement = True # 刚一开始分配少量的GPU容量，然后按需慢慢的增加，由于不会释放内存，所以会导致碎片
config.gpu_options.allow_growth = True
with face_rec_graph.graph.as_default():
self.sess = tf.Session(config=config)
# 默认输入的NN尺寸为128 x 128 x 3
self.x = tf.placeholder(dtype=tf.float32,
shape=[None, 128, 128, 3])
self.embeddings = tf.nn.l2_normalize(
resnet.inference(self.x, 0.6, phase_train=False)[0], 1, 1e-10)
saver = tf.train.Saver() # 创建一个Saver来管理模型中的所有变量
saver.restore(self.sess, model_path)
print('model加载完毕！')
def estimate_age_and_gender(aligned_images, model_path):
with tf.Graph().as_default():
session = tf.Session()
images_pl = tf.placeholder(tf.float32,
shape=[None, 160, 160, 3],
name='input_image')
images = tf.map_fn(lambda frame: tf.reverse_v2(frame, [-1]),
images_pl) #BGR TO RGB
images_norm = tf.map_fn(
lambda frame: tf.image.per_image_standardization(frame), images)
train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images_norm,
keep_probability=0.8,
phase_train=train_mode,
weight_decay=1e-5)
gender = tf.argmax(tf.nn.softmax(gender_logits), 1)
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits), age_),
axis=1)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
session.run(init_op)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(model_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(session, ckpt.model_checkpoint_path)
else:
pass
return session.run([age, gender],
feed_dict={
images_pl: aligned_images,
train_mode: False
})
def tower_loss(scope, images, labels):
prelogits, _ = inception_resnet_v1.inference(images, keep_probability,
phase_train=True, bottleneck_layer_size=128,
weight_decay=5e-5)
logits = slim.fully_connected(prelogits, 54, activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
weights_regularizer=slim.l2_regularizer(5e-5),
scope='Logits', reuse=False)
labels = tf.cast(labels, tf.int64)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels, logits=logits, name='cross_entropy_per_example')
cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
tf.add_to_collection('losses', cross_entropy_mean)
#tf.add_n(tf.get_collection('losses'), name='total_loss')
losses = tf.get_collection('losses', scope)
total_loss = tf.add_n(losses, name='total_loss')
return total_loss
def content_extractor(self, images, reuse=False):
# images: (batch, 32, 32, 3) or (batch, 32, 32, 1)
if images.get_shape()[3] == 1:
# For mnist dataset, replicate the gray scale image 3 times.
images = tf.image.grayscale_to_rgb(images)
if images.get_shape()[2] < 64 or images.get_shape()[1] < 64:
print("WARNING:resnet may not support images with small size.")
prelogits, _ = inference(images, keep_probability=1.0, reuse=reuse)
ret = tf.expand_dims(tf.expand_dims(prelogits, axis=1), axis=2)
return ret
def _build_graph(self, inputs):
# with tf.device('/gpu:0'):
image, label = inputs
image = tf.identity(image, name="NETWORK_INPUT")
tf.summary.image('input-image', image, max_outputs=10)
# image = (image - 127.5) / 128
image = tf.map_fn(lambda img: tf.image.per_image_standardization(img), image)
prelogits, _ = inception_resnet_v1.inference(image, cfg.keep_probability,
phase_train=self.train_model, bottleneck_layer_size=cfg.feature_length,
weight_decay=cfg.weight_decay)
logits = slim.fully_connected(prelogits, cfg.nrof_classes, activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
weights_regularizer=slim.l2_regularizer(cfg.weight_decay),
scope='Logits', reuse=False)
#feature for face recognition
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
feature = tf.identity(embeddings, name="FEATURE")
# Add center loss
if cfg.center_loss_factor>0.0:
prelogits_center_loss, _ = facenet.center_loss(prelogits, label, cfg.center_loss_alfa, cfg.nrof_classes)
tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, prelogits_center_loss * cfg.center_loss_factor)
# Add cross entropy loss
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=label, logits=logits, name='cross_entropy_per_example')
softmax_loss = tf.reduce_mean(cross_entropy, name='softmax_loss')
# tf.add_to_collection('softmax_loss', softmax_loss)
# Calculate the total losses
center_loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
# tf.summary.scalar('regularization_losses', regularization_losses)
loss = tf.add_n([softmax_loss] + center_loss, name='loss')
center_loss = tf.identity(center_loss, name='center_loss')
if cfg.weight_decay > 0:
wd_cost = regularize_cost('.*/W', l2_regularizer(cfg.weight_decay), name='l2_regularize_loss')
add_moving_summary(loss, wd_cost)
add_moving_summary(softmax_loss)
# add_moving_summary(center_loss)
self.cost = tf.add_n([loss, wd_cost], name='cost')
else:
add_moving_summary(softmax_loss)
# add_moving_summary(center_loss)
self.cost = tf.identity(loss, name='cost')
def content_extractor(self, images, reuse=False):
# Assuming standard input -1~1, scale them to 0`255, which I think is the correct scale...
# images: (batch, 32, 32, 3) or (batch, 32, 32, 1)
if images.get_shape()[3] == 1:
# For mnist dataset, replicate the gray scale image 3 times.
images = tf.image.grayscale_to_rgb(images)
if images.get_shape()[2] < 64 or images.get_shape()[1] < 64:
print("WARNING:resnet may not support images with small size.")
prelogits, _ = inference((images + 1) * 127.5,
keep_probability=1.0,
reuse=reuse)
if self.mode == 'pretrain':
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],
}
bottleneck = slim.fully_connected(
prelogits,
self.embedding_size,
activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(
stddev=0.1),
weights_regularizer=slim.l2_regularizer(self.weight_decay),
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
scope='Bottleneck',
reuse=False)
logits = slim.fully_connected(
bottleneck,
self.num_classes,
activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(
stddev=0.1),
weights_regularizer=slim.l2_regularizer(self.weight_decay),
scope='Logits',
reuse=False)
embeddings = tf.nn.l2_normalize(bottleneck,
1,
1e-10,
name='embeddings')
return logits
else:
ret = tf.expand_dims(tf.expand_dims(prelogits, axis=1), axis=2)
return ret
def __init__(self,
face_img_size,
model_path='models/model-20170512-110547.ckpt-250000'):
self.face_imgs = tf.placeholder(
'float', [None, face_img_size, face_img_size, 3])
self.face_img_size = face_img_size
self.attr = tf.nn.l2_normalize(
resnet.inference(self.face_imgs, 0.6, phase_train=False)[0], 1,
1e-10)
#some magic numbers that u dont have to care about
self.sess = tf.Session()
saver = tf.train.Saver() #saver load pretrain model
saver.restore(self.sess, model_path)
print('Moldes loaded')
def main():
if (not handle_args()):
# invalid arguments exit program
print_usage()
return 1
with tf.Graph().as_default():
image = tf.placeholder("float",
shape=[1, image_size, image_size, 3],
name='input')
prelogits, _ = network.inference(image, 1.0, phase_train=False)
normalized = tf.nn.l2_normalize(prelogits, 1, name='l2_normalize')
output = tf.identity(normalized, name='output')
saver = tf.train.Saver(tf.global_variables())
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
index_file_name = model_base_file_name + ".index"
data_file_name = model_base_file_name + ".data-00000-of-00001"
meta_file_name = model_base_file_name + ".meta"
if (os.path.isfile(index_file_name)
and os.path.isfile(data_file_name)
and os.path.isfile(meta_file_name)):
print('Restoring ' + model_base_file_name)
saver.restore(sess, model_base_file_name)
else:
print('\n')
print('Error, did not find index, data, and meta files: ')
print(' ' + index_file_name)
print(' ' + data_file_name)
print(' ' + meta_file_name)
print('These files can be downloaded manually from:')
print(' https://github.com/davidsandberg/facenet')
print(' Download: 20170511-185253.zip (web faces), or ')
print(' 20170512-110547.zip (celeb faces)')
print(
'after unzipping be sure to rename them to the file names')
print('above to match the TensorFlow 1.3 file naming.')
print('Either the celeb faces or web faces will work')
print(
'***********************************************************'
)
# Save the network for fathom
saver.save(
sess,
model_base_file_name + '_ncs/' + model_base_file_name + '_ncs')
def __init__(self, face_rec_graph, model_path = 'models/model-20170512-110547.ckpt-250000'):
#def __init__(self, face_rec_graph, model_path='models/me.face.model.h5'):
'''
:param face_rec_sess: FaceRecSession object
:param model_path:
'''
print("Loading model...")
with face_rec_graph.graph.as_default():
self.sess = tf.Session()
self.x = tf.placeholder('float', [None,160,160,3]); #default input for the NN is 160x160x3
self.embeddings = tf.nn.l2_normalize(
resnet.inference(self.x, 0.6, phase_train=False)[0], 1, 1e-10); #some magic numbers that u dont have to care about
saver = tf.train.Saver() #saver load pretrain model
saver.restore(self.sess, model_path)
print("Model loaded")
def build_model(is_training, images, params):
'''
建立模型
----------------------------
Args：
is_training: bool, 是否是训练阶段，可以从mode中判断
images： (batch_size, 120*250*1), 输入数据
params: dict, 一些超参数
Returns:
out: 输出的embeddings, shape = (batch_size, 128)
'''
out = net.inference(images, 0.8, phase_train=is_training)
out = tf.nn.l2_normalize(out, dim=1)
return out
def inference_recognition_inceptionv1(inputs,
classnums,
reuse=False,
train=True):
logits, _ = inference(inputs,
keep_prob=0.8,
phase_train=train,
reuse=reuse)
with tf.variable_scope('recognition_fc', reuse=reuse):
net = slim.fully_connected(
logits,
classnums,
activation_fn=None,
normalizer_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.02),
scope='recognition_soft')
return tf.nn.softmax(net), net, logits
def get_loss(x, labels, scope):
y = inception_resnet_v1.inference(x,
keep_probability=keep_probability,
phase_train=phase_train,
bottleneck_layer_size=embedding_size,
weight_decay=weight_decay)
cross_entropy = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels,
logits=y))
regularization_loss = tf.add_n(tf.get_collection('losses', scope))
loss = cross_entropy + regularization_loss
return loss
def main(data, iter_num, labels):
with tf.Graph().as_default():
BATCH_SIZE = 866
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 128, 128, 3],
name='anchor')
labels_anchor = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
features, prelogits, logits = inception_resnet_v1.inference(
train_anchor_data,
keep_probability=1.0,
phase_train=False,
bottleneck_layer_size=30,
weight_decay=0.0005)
features = tf.nn.l2_normalize(features, 1, 1e-10, name='embeddings')
data_train, train_labels = data, labels
print(data.shape)
print(labels.shape)
Saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
emb_array = np.zeros((iter_num // BATCH_SIZE * BATCH_SIZE, 1792))
for step in range(iter_num // BATCH_SIZE):
batch_anchor, batch_labels = data_train[step * BATCH_SIZE:(step + 1) * BATCH_SIZE], \
train_labels[step * BATCH_SIZE:(step + 1) * BATCH_SIZE]
# batch_anchor = data_train[step * BATCH_SIZE:(step + 1) * BATCH_SIZE]
Saver.restore(
sess,
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard5/'
)
feed_dict = {
train_anchor_data: batch_anchor,
labels_anchor: batch_labels,
}
Logits = sess.run(features, feed_dict=feed_dict)
emb_array[step * BATCH_SIZE:(step + 1) *
BATCH_SIZE, :] = Logits
print('the triplet loss %g' % step)
np.savetxt('valid_feature_12_11.txt', emb_array)
print(np.shape(emb_array))
def load_session(model_path=MODEL_PATH):
global SESSION
global AGE
global GENDER
global IMAGES_PL
global TRAIN_MODE
global tf_config
graph = tf.Graph().as_default()
sess = tf.Session(config=tf_config)
images_pl = tf.placeholder(tf.float32,
shape=[None, 160, 160, 3],
name='input_image')
images = tf.map_fn(lambda frame: tf.reverse_v2(frame, [-1]),
images_pl) #BGR TO RGB
images_norm = tf.map_fn(
lambda frame: tf.image.per_image_standardization(frame), images)
train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images_norm,
keep_probability=1.0, #0.8
phase_train=train_mode,
weight_decay=1e-5)
gender = tf.argmax(tf.nn.softmax(gender_logits), 1)
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits), age_), axis=1)
GENDER = gender
AGE = age
IMAGES_PL = images_pl
TRAIN_MODE = train_mode
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(model_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("restore and continue training! : {}".format(
ckpt.model_checkpoint_path))
else:
sys.exit("Age-Gender Model not found")
SESSION = sess
def __init__(self):
self.model_path = "./models"
self.shape_detector = "shape_predictor_68_face_landmarks.dat"
cuda = True
font_scale = 1
thickness = 1
#log('1')
print('1')
with tf.Graph().as_default():
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.4
# session = tf.Session(config=config, ...)
self.sess = tf.Session(config=config)
self.images_pl = tf.placeholder(tf.float32,
shape=[None, 160, 160, 3],
name='input_image')
images = tf.map_fn(lambda frame: tf.reverse_v2(frame, [-1]),
self.images_pl) #BGR TO RGB
images_norm = tf.map_fn(
lambda frame: tf.image.per_image_standardization(frame),
images)
self.train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images_norm,
keep_probability=0.8,
phase_train=self.train_mode,
weight_decay=1e-5)
self.gender = tf.argmax(tf.nn.softmax(gender_logits), 1)
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
self.age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits),
age_),
axis=1)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
self.sess.run(init_op)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(self.model_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(self.sess, ckpt.model_checkpoint_path)
print("restore and continue training!")
else:
pass
def main():
eval_graph = tf.Graph()
with eval_graph.as_default():
inp = tf.placeholder(dtype=tf.float32, shape=[None, config.image_size, config.image_size, 3], name='input')
# phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
phase_train_placeholder = tf.placeholder_with_default(input=False, shape=[], name='phase_train')
# batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
keep_probability_placeholder = tf.placeholder_with_default(input=1., shape=[], name='keep_probability')
# keep_probability_placeholder = tf.placeholder(tf.float32, name='keep_probability')
with tf.variable_scope('quantize'):
prelogits, _ = network.inference(inp,
keep_probability=keep_probability_placeholder,
phase_train=phase_train_placeholder,
bottleneck_layer_size=config.embedding_size,
weight_decay=config.weight_decay)
prelogits = tf.maximum(prelogits, -1e27)
g = tf.get_default_graph()
tf.contrib.quantize.create_eval_graph(input_graph=g)
saver = tf.train.Saver()
eval_graph.finalize()
with open('eval.pb', 'w') as f:
f.write(str(g.as_graph_def()))
with tf.Session(graph=eval_graph) as session:
checkpoint = tf.train.latest_checkpoint('/homes/smeshkinfamfard/PycharmProjects/tensorflow-facenet/model/')
# import pdb;pdb.set_trace()
saver.restore(session, checkpoint)
fix_error()
# fix the input, output, choose types of the weights and activations for the tflite model
converter = lite.TFLiteConverter.from_session(session, [inp], [prelogits])
converter.inference_type = tf.uint8
converter.inference_input_type = tf.uint8
input_arrays = converter.get_input_arrays()
converter.quantized_input_stats = {input_arrays[0]: (0., 1.)}
flatbuffer = converter.convert()
with open('test.tflite', 'wb') as outfile:
outfile.write(flatbuffer)
print('Model successfully converted and saved in the project directory')
def main():
if (not handle_args()):
# invalid arguments exit program
print_usage()
return 1
with tf.Graph().as_default():
image = tf.placeholder("float", shape=[1, image_size, image_size, 3], name='input')
prelogits, _ = network.inference(image, 1.0, phase_train=False)
normalized = tf.nn.l2_normalize(prelogits, 1, name='l2_normalize')
output = tf.identity(normalized, name='output')
saver = tf.train.Saver(tf.global_variables())
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
index_file_name = model_base_file_name + ".index"
data_file_name = model_base_file_name + ".data-00000-of-00001"
meta_file_name = model_base_file_name + ".meta"
if (os.path.isfile(index_file_name) and
os.path.isfile(data_file_name) and
os.path.isfile(meta_file_name)):
print('Restoring ' + model_base_file_name)
saver.restore(sess, model_base_file_name)
else:
print('\n')
print('Error, did not find index, data, and meta files: ')
print(' ' + index_file_name)
print(' ' + data_file_name)
print(' ' + meta_file_name)
print('These files can be downloaded manually from:')
print(' https://github.com/davidsandberg/facenet')
print(' Download: 20170511-185253.zip (web faces), or ')
print(' 20170512-110547.zip (celeb faces)')
print('after unzipping be sure to rename them to the file names')
print('above to match the TensorFlow 1.3 file naming.')
print('Either the celeb faces or web faces will work')
print('***********************************************************')
# Save the network for fathom
saver.save(sess, model_base_file_name + '_ncs/' + model_base_file_name + '_ncs')
def build_model(self,
dropout_keep_prob=0.8,
is_training=True,
bottleneck_layer_size=128,
weight_decay=0.0):
"""
Builds the inception model.
:param dropout_keep_prob: float, the fraction to keep before final layer
:param is_training: Whether is training or not
:param bottleneck_layer_size: The size of the logits outputs of the model
:param weight_decay: This penalizes large weights
:return: The normalized logits outputs of the model
"""
# A 4-D tensor of size [batch_size, height, width, 3].
inputs_ph = tf.placeholder(tf.float32,
shape=self.inputs_shape,
name='anchor')
net, end_points = inference(inputs_ph, dropout_keep_prob, is_training,
bottleneck_layer_size, weight_decay)
embeddings = tf.nn.l2_normalize(net, 1, 1e-10, name='embeddings')
return inputs_ph, embeddings
def main(argv=None):
with tf.Graph(). as_default():
BATCH_SIZE = 3000
NUM = 3000
train_anchor_data = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 128, 128, 3], name='anchor')
_, prelogits, _ = inception_resnet_v1.inference(train_anchor_data, keep_probability=1.0,
phase_train=False, bottleneck_layer_size=30,
weight_decay=0.0005)
logits = tf.nn.softmax(prelogits)
Saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
data = data_process.input_test_data()
print(data.shape)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
Saver.restore(sess, '/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard5/')
print('Initialized!')
prob = []
for step in range(NUM // BATCH_SIZE):
batch_anchor = data[step * BATCH_SIZE:(step + 1) * BATCH_SIZE]
feed_dict = {train_anchor_data: batch_anchor}
Logits = sess.run(logits, feed_dict=feed_dict)
print("%d the %s train reslut" % (step, datetime.datetime.now()))
print('the i %g' % step)
prob.extend(Logits)
print(np.shape(prob))
np.savetxt('test_image_result.csv', prob, fmt='%g')
for i in np.max(prob, 1):
print(i)
print(np.mean(np.max(prob, 1)))
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
utils.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__))
utils.store_revision_info(src_path, log_dir, ' '.join(sys.argv))
np.random.seed(seed=args.seed)
train_set = utils.get_dataset(args.data_dir)
nrof_classes = len(train_set)
print('nrof_classes: ', nrof_classes)
image_list, label_list = utils.get_image_paths_and_labels(train_set)
image_list = np.array(image_list)
label_list = np.array(label_list, dtype=np.int32)
dataset_size = len(image_list)
single_batch_size = args.people_per_batch * args.images_per_person
indices = range(dataset_size)
np.random.shuffle(indices)
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.
'''
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))
def _parse_function(filename, label):
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))
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))
if debug:
image = tf.cast(image, tf.float32)
else:
image = tf.image.per_image_standardization(image)
return image, label
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))
with tf.Graph().as_default():
tf.set_random_seed(args.seed)
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')
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
#the image is generated by sequence
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_threads=8,
output_buffer_size=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)
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
#with slim.arg_scope(resnet_v2.resnet_arg_scope(args.weight_decay)):
#prelogits, end_points = resnet_v2.resnet_v2_50(batch_image_split[i],is_training=True,
# output_stride=16,num_classes=args.embedding_size,reuse=reuse)
#prelogits, end_points = network.inference(batch_image_split[i], args.keep_probability,
# phase_train=phase_train_placeholder, bottleneck_layer_size=args.embedding_size,
# weight_decay=args.weight_decay, reuse=reuse)
if args.network == 'sphere_network':
prelogits = network.infer(batch_image_split[i])
elif args.network == 'resface':
prelogits, _ = resface.inference(
batch_image_split[i],
1.0,
weight_decay=args.weight_decay,
reuse=reuse)
elif args.network == 'inception_net':
prelogits, endpoints = inception_net.inference(
batch_image_split[i],
1,
phase_train=True,
bottleneck_layer_size=args.embedding_size,
weight_decay=args.weight_decay,
reuse=reuse)
elif args.network == 'resnet_v2':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(
args.weight_decay)):
prelogits, end_points = resnet_v2.resnet_v2_50(
batch_image_split[i],
is_training=True,
output_stride=16,
num_classes=args.embedding_size,
reuse=reuse)
prelogits = tf.squeeze(prelogits,
axis=[1, 2])
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 == 'softmax':
cross_entropy_mean = utils.softmax_loss(
prelogits, batch_label_split[i],
len(train_set), args.weight_decay, reuse)
regularization_losses = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
tower_cross.append(cross_entropy_mean)
#loss = cross_entropy_mean + args.weight_decay*tf.add_n(regularization_losses)
loss = cross_entropy_mean + tf.add_n(
regularization_losses)
#tower_dist.append(0)
#tower_cross.append(cross_entropy_mean)
#tower_th.append(0)
tower_losses.append(loss)
tower_reg.append(regularization_losses)
elif args.loss_type == 'cosface':
label_reshape = tf.reshape(
batch_label_split[i], [single_batch_size])
label_reshape = tf.cast(
label_reshape, tf.int64)
coco_loss = utils.cos_loss(prelogits,
label_reshape,
len(train_set),
reuse,
alpha=args.alpha,
scale=args.scale)
#regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
#reg_loss = args.weight_decay*tf.add_n(regularization_losses)
reg_loss = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
loss = coco_loss + reg_loss
tower_losses.append(loss)
tower_reg.append(reg_loss)
#loss = tf.add_n([cross_entropy_mean] + regularization_losses, name='total_loss')
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
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)
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(tf.trainable_variables(), max_to_keep=3)
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(iterator.initializer)
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():
#pdb.set_trace()
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
if debug:
debug_train(args, sess, train_set, epoch,
image_batch_gather, enqueue_op,
batch_size_placeholder, image_batch_split,
image_paths_split, num_per_class_split,
image_paths_placeholder,
image_paths_split_placeholder,
labels_placeholder, labels_batch,
num_per_class_placeholder,
num_per_class_split_placeholder, len(gpus))
# 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 main(argv=None):
with tf.Graph().as_default():
global_step = tf.Variable(0, trainable=False)
CENTER_LOSS_ALPHA = 1.25
BATCH_SIZE = 256
ITERATION = 2000000
data_num = 16640
NUM_CLASSES = 30
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 128, 128, 3],
name='anchor')
labels_anchor = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
tf.summary.image('input_image', train_anchor_data, 10)
features, prelogits, logits = inception_resnet_v1.inference(
train_anchor_data,
keep_probability=0.8,
phase_train=True,
bottleneck_layer_size=30,
weight_decay=0.0005)
print(features, prelogits, logits)
with tf.name_scope('loss'):
with tf.name_scope('center_loss'):
center_loss, centers, centers_update_op = utils.get_center_loss(
features, labels_anchor, CENTER_LOSS_ALPHA, NUM_CLASSES)
with tf.name_scope('softmax_loss'):
softmax_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels_anchor, logits=prelogits))
with tf.name_scope('total_loss'):
total_loss = softmax_loss + center_loss
# global_step = tf.Variable(tf.constant(431, dtype=tf.int64))
lr = tf.train.exponential_decay(learning_rate=0.001,
global_step=global_step,
decay_steps=data_num // BATCH_SIZE,
decay_rate=0.99,
staircase=True)
with tf.control_dependencies([centers_update_op]):
train_op = tf.train.AdamOptimizer(learning_rate=lr).minimize(
total_loss, global_step=global_step)
Saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
tf.summary.scalar('total_loss', total_loss)
tf.summary.scalar('learning_rate', lr)
tf.summary.scalar('softmax_loss', softmax_loss)
tf.summary.scalar('center_loss', center_loss)
merged = tf.summary.merge_all()
data, labels = data_process.input_data()
print(data.shape)
print(labels.shape)
dataShufflu = DataShuffle(data, labels)
with tf.Session() as sess:
train_write = tf.summary.FileWriter(
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard4/',
sess.graph)
sess.run(tf.global_variables_initializer())
# sess.run(tf.local_variables_initializer())
# Saver.restore(sess, '/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard2/')
for step in range(ITERATION):
batch_anchor, batch_labels_anchor = dataShufflu.get_triplet(
n_labels=30, n_triplet=BATCH_SIZE)
feed_dict = {
train_anchor_data: batch_anchor,
labels_anchor: batch_labels_anchor
}
_, l, summary, Loss = sess.run(
[train_op, total_loss, merged, softmax_loss],
feed_dict=feed_dict)
print("%d the %s train reslut" %
(step, datetime.datetime.now()))
print('the softmax loss %g' % Loss)
print('the total loss %g' % l)
train_write.add_summary(summary, step)
if step % 500 == 0:
Saver.save(
sess,
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard4/'
)
train_write.close()
def main():
image_size = (config.image_size, config.image_size)
#创建graph和model存放目录
if not os.path.exists(config.graph_dir):
os.mkdir(config.graph_dir)
if not os.path.exists(config.model_dir):
os.mkdir(config.model_dir)
#获取图片地址和类别
dataset = get_dataset(config.data_dir)
#划分训练验证集
if config.validation_set_split_ratio > 0.0:
train_set, val_set = split_dataset(
dataset, config.validation_set_split_ratio,
config.min_nrof_val_images_per_class)
else:
train_set, val_set = dataset, []
#训练集的种类数量
nrof_classes = len(train_set)
with tf.Graph().as_default():
global_step = tf.Variable(0, trainable=False)
#获取所有图像位置和相应类别
image_list, label_list = get_image_paths_and_labels(train_set)
assert len(image_list) > 0, '训练集不能为空'
val_image_list, val_label_list = get_image_paths_and_labels(val_set)
labels = tf.convert_to_tensor(label_list, dtype=tf.int32)
#样本数量
range_size = labels.get_shape().as_list()[0]
#每一各epoch的batch数量
epoch_size = range_size // config.batch_size
#创建一个队列
index_queue = tf.train.range_input_producer(range_size,
num_epochs=None,
shuffle=True,
seed=None,
capacity=32)
index_dequeue_op = index_queue.dequeue_many(
config.batch_size * epoch_size, 'index_dequeue')
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, 1),
name='image_paths')
labels_placeholder = tf.placeholder(tf.int32,
shape=(None, 1),
name='label')
keep_probability_placeholder = tf.placeholder(tf.float32,
name='keep_probability')
nrof_preprocess_threads = 4
#输入队列
input_queue = tf.FIFOQueue(capacity=2000000,
dtypes=[tf.string, tf.int32],
shapes=[(1, ), (1, )],
shared_name=None,
name=None)
enqueue_op = input_queue.enqueue_many(
[image_paths_placeholder, labels_placeholder], name='enqueue_op')
#获取图像，label的batch形式
image_batch, label_batch = create_input_pipeline(
input_queue, image_size, nrof_preprocess_threads,
batch_size_placeholder)
image_batch = tf.identity(image_batch, 'image_batch')
image_batch = tf.identity(image_batch, 'input')
label_batch = tf.identity(label_batch, 'label_batch')
#网络输出
prelogits, _ = network.inference(
image_batch,
keep_probability_placeholder,
phase_train=phase_train_placeholder,
bottleneck_layer_size=config.embedding_size,
weight_decay=config.weight_decay)
#用于计算loss
logits = slim.fully_connected(
prelogits,
len(train_set),
activation_fn=None,
weights_initializer=slim.initializers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(config.weight_decay),
scope='Logits',
reuse=False)
#正则化的embeddings主要用于测试，对比两张图片差异
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
#计算centerloss
prelogits_center_loss, _ = center_loss(prelogits, label_batch,
config.center_loss_alfa,
nrof_classes)
tf.identity(prelogits_center_loss, name='center_loss')
tf.summary.scalar('center_loss', prelogits_center_loss)
#学习率
boundaries = [
int(epoch * range_size / config.batch_size)
for epoch in config.LR_EPOCH
]
lr_values = [
config.learning_rate * (0.1**x)
for x in range(0,
len(config.LR_EPOCH) + 1)
]
learning_rate = tf.train.piecewise_constant(global_step, boundaries,
lr_values)
tf.identity(learning_rate, name='learning_rate')
tf.summary.scalar('learning_rate', learning_rate)
#交叉熵损失
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=label_batch,
logits=logits,
name='cross_entropy_per_example')
cross_entropy_mean = tf.reduce_mean(cross_entropy,
name='cross_entropy')
tf.identity(cross_entropy_mean, name='cross_entropy_mean')
tf.summary.scalar('cross_entropy_mean', cross_entropy_mean)
#l2正则loss
L2_loss = tf.add_n(
tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
#总的loss
total_loss = cross_entropy_mean + config.center_loss_factor * prelogits_center_loss + L2_loss
tf.identity(total_loss, name='total_loss')
tf.summary.scalar('total_loss', total_loss)
#准确率
correct_prediction = tf.cast(
tf.equal(tf.argmax(logits, 1), tf.cast(label_batch, tf.int64)),
tf.float32)
accuracy = tf.reduce_mean(correct_prediction)
tf.identity(accuracy, name='accuracy')
tf.summary.scalar('accuracy', accuracy)
train_op = optimize(total_loss, global_step, learning_rate,
config.moving_average_decay, tf.global_variables())
saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
summary_op = tf.summary.merge_all()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
#训练和验证的graph保存地址
train_writer = tf.summary.FileWriter(config.graph_dir + 'train/',
sess.graph)
val_writer = tf.summary.FileWriter(config.graph_dir + 'val/',
sess.graph)
coord = tf.train.Coordinator()
tf.train.start_queue_runners(coord=coord, sess=sess)
with sess.as_default():
if os.path.exists(config.model_dir):
model_file = tf.train.latest_checkpoint(config.model_dir)
if model_file:
saver.restore(sess, model_file)
print('重载模型训练')
if not os.path.exists(config.model_dir):
os.mkdir(config.model_dir)
for epoch in range(1, config.max_nrof_epochs + 1):
step = sess.run(global_step, feed_dict=None)
#训练
batch_number = 0
#获取image和label
index_epoch = sess.run(index_dequeue_op)
label_epoch = np.array(label_list)[index_epoch]
image_epoch = np.array(image_list)[index_epoch]
labels_array = np.expand_dims(np.array(label_epoch), 1)
image_paths_array = np.expand_dims(np.array(image_epoch), 1)
#运行输入队列
sess.run(
enqueue_op, {
image_paths_placeholder: image_paths_array,
labels_placeholder: labels_array
})
while batch_number < epoch_size:
feed_dict = {
phase_train_placeholder: True,
batch_size_placeholder: config.batch_size,
keep_probability_placeholder: config.keep_probability
}
tensor_list = [
total_loss, train_op, global_step, learning_rate,
prelogits, cross_entropy_mean, accuracy,
prelogits_center_loss
]
#每经过100个batch更新一次graph
if batch_number % 100 == 0:
loss_, _, step_, lr_, prelogits_, cross_entropy_mean_, accuracy_, center_loss_, summary_str = sess.run(
tensor_list + [summary_op], feed_dict=feed_dict)
train_writer.add_summary(summary_str,
global_step=step_)
saver.save(sess=sess,
save_path=config.model_dir + 'model.ckpt',
global_step=(step_))
print('epoch:%d/%d' % (epoch, config.max_nrof_epochs))
print(
"Step: %d/%d, accuracy: %3f, center loss: %4f, cross loss: %4f, Total Loss: %4f ,lr:%f "
% (step_, epoch_size * config.max_nrof_epochs,
accuracy_, center_loss_, cross_entropy_mean_,
loss_, lr_))
else:
loss_, _, step_, lr_, prelogits_, cross_entropy_mean_, accuracy_, center_loss_, = sess.run(
tensor_list, feed_dict=feed_dict)
batch_number += 1
train_writer.add_summary(summary_str, global_step=step_)
#验证
nrof_val_batches = len(val_label_list) // config.batch_size
nrof_val_images = nrof_val_batches * config.batch_size
labels_val_array = np.expand_dims(
np.array(val_label_list[:nrof_val_images]), 1)
image_paths_val_array = np.expand_dims(
np.array(val_image_list[:nrof_val_images]), 1)
#运行输入队列
sess.run(
enqueue_op, {
image_paths_placeholder: image_paths_val_array,
labels_placeholder: labels_val_array
})
loss_val_mean = 0
center_loss_val_mean = 0
cross_entropy_mean_val_mean = 0
accuracy_val_mean = 0
for i in range(nrof_val_batches):
feed_dict = {
phase_train_placeholder: False,
batch_size_placeholder: config.batch_size,
keep_probability_placeholder: 1.0
}
loss_val, center_loss_val, cross_entropy_mean_val, accuracy_val, summary_val = sess.run(
[
total_loss, prelogits_center_loss,
cross_entropy_mean, accuracy, summary_op
],
feed_dict=feed_dict)
loss_val_mean += loss_val
center_loss_val_mean += center_loss_val
cross_entropy_mean_val_mean += cross_entropy_mean_val
accuracy_val_mean += accuracy_val
if i % 10 == 9:
print('.', end='')
sys.stdout.flush()
val_writer.add_summary(summary_val, global_step=epoch)
loss_val_mean /= nrof_val_batches
center_loss_val_mean /= nrof_val_batches
cross_entropy_mean_val_mean /= nrof_val_batches
accuracy_val_mean /= nrof_val_batches
print('到这了！')
print(
"val: accuracy: %3f, center loss: %4f, cross loss: %4f, Total Loss: %4f "
% (accuracy_val_mean, center_loss_val_mean,
cross_entropy_mean_val_mean, loss_val_mean))
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
#config paramss
nrof_age_classes = 10
nrof_gender_classes = 2
df_graph = tf.Graph()
with df_graph.as_default():
image_batch = tf.identity(image_batch, 'input')
label_age_batch = tf.identity(label_age_batch, 'label_age_batch')
label_gender_batch = tf.identity(label_gender_batch, 'label_gender_batch')
with df_graph.as_default():
phase_train_placeholder = tf.placeholder(tf.bool, name='Phase_train')
age, gender, _ = inception_resnet_v1.inference(image_batch,
keep_probability=0.8,
phase_train=True,
bottleneck_layer_size=128)
fn_age = slim.fully_connected(
age,
nrof_age_classes,
activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
weights_regularizer=slim.l2_regularizer(1e-5),
scopr='fn_age')
fn_gender = slim.fully_connected(
gender,
nrof_gender_classes,
activation_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
weights_regularizer=slim.l2_regularizer(1e-5),
scopr='fn_gender')
for row in c.execute('select * from people_unknown order by old'):
print(row)
# Load model and run graph
tf.reset_default_graph()
# sess = tf.InteractiveSession()
sess = tf.Session()
images_pl = tf.placeholder(tf.float32,
shape=[None, 160, 160, 3],
name='input_image')
images_norm = tf.map_fn(
lambda frame: tf.image.per_image_standardization(frame), images_pl)
train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images_norm,
keep_probability=0.8,
phase_train=train_mode,
weight_decay=1e-5)
gender = tf.argmax(tf.nn.softmax(gender_logits), 1)
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits), age_), axis=1)
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state("../gender_age_tf/models/")
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print("restore model!")
else:
def _predict_drgan_multipie(self, reuse=False):
'''
网络训练
:param reuse: True | False netG_encoder_gamma
:return:inference_recognition
'''
self.softresult, self.logits_cl, self.encode_fr = nets.inference_recognition(
self.batch_data, classnums=self.class_nums, reuse=reuse)
noise = tf.random_uniform(shape=(self.batch_size, self.noise_z),
minval=-1,
maxval=1,
dtype=tf.float32,
name='input_noise')
self.encode_add_z = tf.concat([self.encode_fr, noise], 1)
self.output_syn_middle = nets.netG_deconder_gamma(self.encode_add_z,
self.output_channel,
reuse=reuse)
self.output_syn_middle_profile, self.output_syn_middle_front = tf.split(
self.output_syn_middle, 2, axis=0)
self.output_syn_front = nets.merge_net_16_unet(self.output_syn_middle,
self.batch_data,
reuse=reuse)
self.identity_real, _ = inference(self.batch_data,
keep_prob=1,
phase_train=False)
self.identity_syn, _ = inference(self.output_syn_front,
keep_prob=1,
phase_train=False,
reuse=True)
self.output_syn, self.output_gt_syn = tf.split(self.output_syn_front,
2,
axis=0)
self.real_logits = nets.Custom_netD_discriminator_adloss(
self.gt_input_data, reuse=reuse)
self.fake_logits = nets.Custom_netD_discriminator_adloss(
self.output_syn, reuse=True)
self.profile_content, self.front_content = tf.split(self.encode_fr,
2,
axis=0)
# 生成图像的features
self.syn_softmax,self.fake_logits_all, self.syn_encode \
= resnet_yd(self.output_syn_front,reuse=True)
self.syn_content, self.syn_front_content = tf.split(self.syn_encode,
2,
axis=0)
# 计算cosine距离
self.cosine_real = tf.divide(
tf.reduce_sum(tf.multiply(self.profile_content,
self.front_content),
axis=1),
tf.multiply(
tf.sqrt(tf.reduce_sum(tf.square(self.front_content), axis=1)),
tf.sqrt(tf.reduce_sum(tf.square(self.profile_content),
axis=1))))
self.cosine_syn = tf.divide(
tf.reduce_sum(tf.multiply(self.syn_content,
self.syn_front_content),
axis=1),
tf.multiply(
tf.sqrt(tf.reduce_sum(tf.square(self.syn_content), axis=1)),
tf.sqrt(
tf.reduce_sum(tf.square(self.syn_front_content), axis=1))))
[image_paths_placeholder, labels_placeholder, control_placeholder],
name='enqueue_op')
image_batch, label_batch = data_utils.create_input_pipeline(
input_queue, image_size, nrof_preprocess_threads, batch_size)
image_batch = tf.identity(image_batch, 'input')
label_batch = tf.identity(label_batch, 'label_batch')
with df_graph.as_default():
# training phase placeholder
phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
# build the model here
prelogits, _ = model.inference(image_batch,
keep_prob,
phase_train=phase_train_placeholder,
bottleneck_layer_size=embedding_size)
logits = slim.fully_connected(
prelogits,
nrof_classes,
activation_fn=None,
weights_initializer=slim.initializers.xavier_initializer(),
weights_regularizer=slim.l2_regularizer(5e-4),
scope='Logits',
reuse=False)
embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings')
with df_graph.as_default():
# Add center loss
prelogits_center_loss, _ = model_utils.center_loss(prelogits, label_batch,
def main(argv=None):
with tf.Graph().as_default():
BATCH_SIZE = 10
NUM = 860
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 128, 128, 3],
name='anchor')
labels_anchor = tf.placeholder(tf.int32, shape=[BATCH_SIZE, 30])
_, prelogits, _ = inception_resnet_v1.inference(
train_anchor_data,
keep_probability=1.0,
phase_train=False,
bottleneck_layer_size=30,
weight_decay=0.0005)
clas_loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=labels_anchor,
logits=prelogits))
logits = tf.nn.softmax(prelogits)
clas_acc = tf.reduce_mean(tf.cast(
tf.equal(tf.argmax(labels_anchor, 1), tf.argmax(logits, 1)),
tf.float32),
name='clas_acc')
Saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
data, labels = data_process.input_valid_data()
print(data.shape)
print(labels.shape)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
Saver.restore(
sess,
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard2/')
print('Initialized!')
loss = 0
accuracy = 0
for step in range(NUM // BATCH_SIZE):
batch_anchor, batch_labels_anchor = data[step * BATCH_SIZE:(step + 1) * BATCH_SIZE],\
labels[step * BATCH_SIZE:(step + 1) * BATCH_SIZE]
feed_dict = {
train_anchor_data: batch_anchor,
labels_anchor: batch_labels_anchor
}
Clas_loss, Clas_acc = sess.run([clas_loss, clas_acc],
feed_dict=feed_dict)
print("%d the %s train reslut" %
(step, datetime.datetime.now()))
print('the Clas_loss %g' % Clas_loss)
print('the Clas_acc %g' % Clas_acc)
loss += Clas_loss
accuracy += Clas_acc
loss = loss / float(NUM // BATCH_SIZE)
accuracy = accuracy / float(NUM // BATCH_SIZE)
print(loss)
print(accuracy)
def run_training(image_path, batch_size, epoch, model_path, log_dir, start_lr,
wd, kp):
# Tell TensorFlow that the model will be built into the default Graph.
with tf.Graph().as_default():
# Create a session for running operations in the Graph.
sess = tf.Session()
# Input images and labels.
images, age_labels, gender_labels, _ = inputs(
path=get_files_name(image_path),
batch_size=batch_size,
num_epochs=epoch)
# load network
# face_resnet = face_resnet_v2_generator(101, 'channels_first')
train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images,
keep_probability=kp,
phase_train=train_mode,
weight_decay=wd)
# Build a Graph that computes predictions from the inference model.
# logits = face_resnet(images, train_mode)
# if you want to transfer weight from another model,please uncomment below codes
# sess = restore_from_source(sess,'./models')
# if you want to transfer weight from another model,please uncomment above codes
# Add to the Graph the loss calculation.
age_cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=age_labels, logits=age_logits)
age_cross_entropy_mean = tf.reduce_mean(age_cross_entropy)
gender_cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=gender_labels, logits=gender_logits)
gender_cross_entropy_mean = tf.reduce_mean(gender_cross_entropy)
# l2 regularization
total_loss = tf.add_n(
[gender_cross_entropy_mean, age_cross_entropy_mean] +
tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits), age_),
axis=1)
abs_loss = tf.losses.absolute_difference(age_labels, age)
gender_acc = tf.reduce_mean(
tf.cast(tf.nn.in_top_k(gender_logits, gender_labels, 1),
tf.float32))
tf.summary.scalar("age_cross_entropy", age_cross_entropy_mean)
tf.summary.scalar("gender_cross_entropy", gender_cross_entropy_mean)
tf.summary.scalar("total loss", total_loss)
tf.summary.scalar("train_abs_age_error", abs_loss)
tf.summary.scalar("gender_accuracy", gender_acc)
# Add to the Graph operations that train the model.
global_step = tf.Variable(0, name="global_step", trainable=False)
lr = tf.train.exponential_decay(start_lr,
global_step=global_step,
decay_steps=3000,
decay_rate=0.9,
staircase=True)
optimizer = tf.train.AdamOptimizer(lr)
tf.summary.scalar("lr", lr)
update_ops = tf.get_collection(
tf.GraphKeys.UPDATE_OPS) # update batch normalization layer
with tf.control_dependencies(update_ops):
train_op = optimizer.minimize(total_loss, global_step)
# if you want to transfer weight from another model,please comment below codes
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
# if you want to transfer weight from another model, please comment above codes
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(log_dir, sess.graph)
# if you want to transfer weight from another model,please uncomment below codes
# sess, new_saver = save_to_target(sess,target_path='./models/new/',max_to_keep=100)
# if you want to transfer weight from another model, please uncomment above codes
# if you want to transfer weight from another model,please comment below codes
new_saver = tf.train.Saver(max_to_keep=100)
ckpt = tf.train.get_checkpoint_state(model_path)
if ckpt and ckpt.model_checkpoint_path:
new_saver.restore(sess, ckpt.model_checkpoint_path)
print("restore and continue training!")
else:
pass
# if you want to transfer weight from another model, please comment above codes
# Start input enqueue threads.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
step = sess.run(global_step)
start_time = time.time()
while not coord.should_stop():
# start_time = time.time()
# Run one step of the model. The return values are
# the activations from the `train_op` (which is
# discarded) and the `loss` op. To inspect the values
# of your ops or variables, you may include them in
# the list passed to sess.run() and the value tensors
# will be returned in the tuple from the call.
_, summary = sess.run([train_op, merged], {train_mode: True})
train_writer.add_summary(summary, step)
# duration = time.time() - start_time
# # Print an overview fairly often.
if step % 100 == 0:
duration = time.time() - start_time
print('%.3f sec' % duration)
start_time = time.time()
if step % 1000 == 0:
save_path = new_saver.save(sess,
os.path.join(
model_path, "model.ckpt"),
global_step=global_step)
print("Model saved in file: %s" % save_path)
step = sess.run(global_step)
except tf.errors.OutOfRangeError:
print('Done training for %d epochs, %d steps.' % (epoch, step))
finally:
# When done, ask the threads to stop.
save_path = new_saver.save(sess,
os.path.join(model_path, "model.ckpt"),
global_step=global_step)
print("Model saved in file: %s" % save_path)
coord.request_stop()
# Wait for threads to finish.
coord.join(threads)
sess.close()
def test_once(image_path, batch_size, model_checkpoint_path):
with tf.Graph().as_default():
sess = tf.Session()
images, age_labels, gender_labels, file_paths = inputs(
path=get_files_name(image_path),
batch_size=batch_size,
num_epochs=1,
allow_smaller_final_batch=True)
train_mode = tf.placeholder(tf.bool)
age_logits, gender_logits, _ = inception_resnet_v1.inference(
images,
keep_probability=0.8,
phase_train=train_mode,
weight_decay=1e-5)
age_cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=age_labels, logits=age_logits)
age_cross_entropy_mean = tf.reduce_mean(age_cross_entropy)
gender_cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=gender_labels, logits=gender_logits)
gender_cross_entropy_mean = tf.reduce_mean(gender_cross_entropy)
total_loss = tf.add_n(
[gender_cross_entropy_mean, age_cross_entropy_mean] +
tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES),
name="total_loss")
age_ = tf.cast(tf.constant([i for i in range(0, 101)]), tf.float32)
prob_age = tf.reduce_sum(tf.multiply(tf.nn.softmax(age_logits), age_),
axis=1)
abs_age_error = tf.losses.absolute_difference(prob_age, age_labels)
prob_gender = tf.argmax(tf.nn.softmax(gender_logits), 1)
gender_acc = tf.reduce_mean(
tf.cast(tf.nn.in_top_k(gender_logits, gender_labels, 1),
tf.float32))
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
saver = tf.train.Saver()
saver.restore(sess, model_checkpoint_path)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
mean_error_age, mean_gender_acc, mean_loss = [], [], []
try:
while not coord.should_stop():
prob_gender_val, real_gender, prob_age_val, real_age, image_val, gender_acc_val, abs_age_error_val, cross_entropy_mean_val, file_names = sess.run(
[
prob_gender, gender_labels, prob_age, age_labels,
images, gender_acc, abs_age_error, total_loss,
file_paths
], {train_mode: False})
mean_error_age.append(abs_age_error_val)
mean_gender_acc.append(gender_acc_val)
mean_loss.append(cross_entropy_mean_val)
print("Age_MAE:%.2f,Gender_Acc:%.2f%%,Loss:%.2f" %
(abs_age_error_val, gender_acc_val * 100,
cross_entropy_mean_val))
except tf.errors.OutOfRangeError:
print('!!!TESTING DONE!!!')
finally:
# When done, ask the threads to stop.
coord.request_stop()
coord.join(threads)
sess.close()
return prob_age_val, real_age, prob_gender_val, real_gender, image_val, np.mean(
mean_error_age), np.mean(mean_gender_acc), np.mean(
mean_loss), file_names