def get_base_network(inputs,
name='resnet50',
weight_decay=1e-6,
training=True):
if name == 'resnet50':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(inputs,
is_training=training)
elif name == 'inception-resnet':
with slim.arg_scope(
inception_resnet_v2.inception_resnet_v2_arg_scope(
weight_decay=weight_decay)):
logits, end_points = inception_resnet_v2.inception_resnet_v2(
inputs, is_training=training)
else:
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_101(inputs,
is_training=training)
var_list_restore = {}
for i in end_points:
name = i.replace('generator/', '')
var_list_restore[i] = name
return var_list_restore, end_points
def get_res_network(self, inputs, name='resnet50', weight_decay=0.00001):
#with inception_resnet_v2.inception_resnet_v2_arg_scope(weight_decay=weight_decay):
# _, end_points2 = inception_resnet_v2.inception_resnet_v2(inputs, is_training=self.training)
# for i in end_points2:
# print(end_points2[i])
if name == 'resnet50':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(
inputs, is_training=self.training)
else:
print('now only support resnet 50')
### TO DO
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(
inputs, is_training=self.training)
return logits, end_points
def resnet_v2_50(images, is_training):
# images size is (None, 224, 224, 3), which is equal to default image size of ResNet-50.
# net is final output without activation.
fine_tune_batch_norm = False
with slim.arg_scope(
resnet_v2.resnet_arg_scope(batch_norm_decay=BATCH_NORM_DECAY)):
net, end_points = resnet_v2.resnet_v2_50(
inputs=images,
num_classes=NUMBER_OUTPUT,
is_training=(is_training and fine_tune_batch_norm),
global_pool=True,
spatial_squeeze=True,
scope='resnet_v2_50')
return net
def predict(models_path, image_dir, labels_filename, labels_nums, data_format):
[batch_size, resize_height, resize_width, depths] = data_format
labels = np.loadtxt(labels_filename, str, delimiter='\t')
input_images = tf.placeholder(
dtype=tf.float32,
shape=[None, resize_height, resize_width, depths],
name='input')
with slim.arg_scope(resnet.resnet_arg_scope()):
out, end_points = resnet.resnet_v2_50(inputs=input_images,
num_classes=labels_nums,
is_training=False)
# 将输出结果进行softmax分布,再求最大概率所属类别
score = tf.nn.softmax(out, name='pre')
class_id = tf.argmax(score, 1)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, models_path)
images_list = glob.glob(os.path.join(image_dir, '*.jpg'))
score_total = 0
for image_path in images_list:
im = read_image(image_path,
resize_height,
resize_width,
normalization=True)
im = im[np.newaxis, :]
#pred = sess.run(f_cls, feed_dict={x:im, keep_prob:1.0})
pre_score, pre_label = sess.run([score, class_id],
feed_dict={input_images: im})
max_score = pre_score[0, pre_label]
#print("{} is: pre labels:{},name:{} score: {}".format(image_path, pre_label, labels[pre_label], max_score))
if image_path.split(".jpg")[0].split("-")[2] == labels[pre_label]:
score_total += 1
else:
print("{} is predicted as label::{} ".format(
image_path, labels[pre_label]))
print("valuation accuracy is {}".format(score_total / len(images_list)))
sess.close()
def cnn_model(features, labels, mode):
images = features['images']
filenames = features['filenames']
onehot_labels = labels
axillary_labels = features['axillary_labels']
if FLAGS.network == 'alexnet':
# Format data
if FLAGS.data_format == 'NCHW':
print(colored("Converting data format to channels first (NCHW)", \
'blue'))
images = tf.transpose(images, [0, 3, 1, 2])
# Setup batch normalization
if mode == tf.estimator.ModeKeys.TRAIN:
norm_params={'is_training':True,
'data_format': FLAGS.data_format}
else:
norm_params={'is_training':False,
'data_format': FLAGS.data_format,
'updates_collections': None}
# Create the network
logits = alexnet(images, norm_params, mode)
elif FLAGS.network == 'resnet':
logits, end_points = resnet_v2.resnet_v2_50(inputs=images,
num_classes=ts._NUM_CLASSES,
is_training=(mode==tf.estimator.ModeKeys.TRAIN))
# Inference
predicted_classes = tf.argmax(logits, 1)
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(
mode,
predictions={
'pred_class': predicted_classes,
'gt_class': axillary_labels,
'embedding': logits,
# 'prob': tf.nn.softmax(logits),
})
# Training
groundtruth_classes = tf.argmax(onehot_labels, 1)
if FLAGS.mode == "triplet_training":
if FLAGS.triplet_mining_method == "batchall":
loss, fraction_positive_triplets, num_valid_triplets = \
triplet_loss.batch_all_triplet_loss(
axillary_labels, logits, FLAGS.triplet_margin)
elif FLAGS.triplet_mining_method == "batchhard":
loss = triplet_loss.batch_hard_triplet_loss(
axillary_labels, logits, FLAGS.triplet_margin)
else:
"ERROR: Wrong Triplet loss mining method, using softmax"
loss = tf.losses.softmax_cross_entropy(
onehot_labels=onehot_labels, logits=logits)
if FLAGS.loss_mode == "mix":
loss += tf.losses.softmax_cross_entropy(
onehot_labels=onehot_labels, logits=logits)
else:
loss = tf.losses.softmax_cross_entropy(
onehot_labels=onehot_labels, logits=logits)
if mode == tf.estimator.ModeKeys.TRAIN:
if FLAGS.optimizer == 'GD':
decay_factor = 0.96
learning_rate = tf.train.exponential_decay(FLAGS.learning_rate,
tf.train.get_global_step(),
int(math.ceil(float(ts._SPLITS_TO_SIZES['train'] /
FLAGS.batch_size))),
decay_factor)
optimizer = tf.train.GradientDescentOptimizer(
learning_rate=learning_rate)
elif FLAGS.optimizer == 'Momentum':
decay_factor = 0.96
learning_rate = tf.train.exponential_decay(FLAGS.learning_rate,
tf.train.get_global_step(),
int(math.ceil(float(ts._SPLITS_TO_SIZES['train'] /
FLAGS.batch_size))),
decay_factor)
optimizer = tf.train.MomentumOptimizer(
learning_rate=learning_rate, momentum=0.9)
else:
optimizer = tf.train.AdamOptimizer(
learning_rate=FLAGS.learning_rate)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_op = optimizer.minimize(loss,
global_step=tf.train.get_global_step())
return tf.estimator.EstimatorSpec(
mode, loss=loss, train_op=train_op)
# Testing
# top_5 = tf.metrics.precision_at_top_k(
# labels=groundtruth_classes,
# predictions=predicted_classes,
# k = 5)
# top_10 = tf.metrics.precision_at_top_k(
# labels=groundtruth_classes,
# predictions=predicted_classes,
# k = 10)
eval_metric_ops = {
'eval/accuracy': tf.metrics.accuracy(
labels=groundtruth_classes,
predictions=predicted_classes),
# 'eval/accuracy_top5': top_5,
# 'eval/accuracy_top10': top_10,
}
return tf.estimator.EstimatorSpec(
mode, loss=loss, eval_metric_ops=eval_metric_ops)
def train(train_record_file, train_log_step, train_param, val_record_file,
val_log_step, labels_nums, data_shape, snapshot, snapshot_prefix):
'''
:param train_record_file: 训练的tfrecord文件
:param train_log_step: 显示训练过程log信息间隔
:param train_param: train参数
:param val_record_file: 验证的tfrecord文件
:param val_log_step: 显示验证过程log信息间隔
:param val_param: val参数
:param labels_nums: labels数
:param data_shape: 输入数据shape
:param snapshot: 保存模型间隔
:param snapshot_prefix: 保存模型文件的前缀名
:return:
'''
[base_lr, max_steps] = train_param
[batch_size, resize_height, resize_width, depths] = data_shape
# 获得训练和测试的样本数
train_nums = get_example_nums(train_record_file)
val_nums = get_example_nums(val_record_file)
print('train nums:%d,val nums:%d' % (train_nums, val_nums))
regularizer = slim.l2_regularizer(0.0005)
# 从record中读取图片和labels数据
# train数据,训练数据一般要求打乱顺序shuffle=True
train_images, train_labels = read_records(train_record_file,
resize_height,
resize_width,
type='normalization')
train_images_batch, train_labels_batch = get_batch_images(
train_images,
train_labels,
batch_size=batch_size,
labels_nums=labels_nums,
one_hot=True,
shuffle=True)
# val数据,验证数据可以不需要打乱数据
val_images, val_labels = read_records(val_record_file,
resize_height,
resize_width,
type='normalization')
val_images_batch, val_labels_batch = get_batch_images(
val_images,
val_labels,
batch_size=batch_size,
labels_nums=labels_nums,
one_hot=True,
shuffle=False)
# Define the model:
with slim.arg_scope(resnet.resnet_arg_scope()):
out, end_points = resnet.resnet_v2_50(inputs=input_images,
num_classes=labels_nums,
is_training=is_training)
# Specify the loss function: tf.losses定义的loss函数都会自动添加到loss函数,不需要add_loss()了
tf.losses.softmax_cross_entropy(onehot_labels=input_labels,
logits=out) #添加交叉熵损失loss=1.6
# slim.losses.add_loss(my_loss)
loss = tf.losses.get_total_loss(
add_regularization_losses=True) #添加正则化损失loss=2.2
accuracy = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(out, 1), tf.argmax(input_labels, 1)),
tf.float32))
score = tf.nn.softmax(out, name='score')
classIds = tf.argmax(out, 1)
# Specify the optimization scheme:
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=base_lr)
# global_step = tf.Variable(0, trainable=False)
# learning_rate = tf.train.exponential_decay(0.05, global_step, 150, 0.9)
#
optimizer = tf.train.MomentumOptimizer(learning_rate=base_lr, momentum=0.9)
# # train_tensor = optimizer.minimize(loss, global_step)
# train_op = slim.learning.create_train_op(loss, optimizer,global_step=global_step)
# 在定义训练的时候, 注意到我们使用了`batch_norm`层时,需要更新每一层的`average`和`variance`参数,
# 更新的过程不包含在正常的训练过程中, 需要我们去手动像下面这样更新
# 通过`tf.get_collection`获得所有需要更新的`op`
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
# 使用`tensorflow`的控制流, 先执行更新算子, 再执行训练
with tf.control_dependencies(update_ops):
# create_train_op that ensures that when we evaluate it to get the loss,
# the update_ops are done and the gradient updates are computed.
# train_op = slim.learning.create_train_op(total_loss=loss,optimizer=optimizer)
train_op = slim.learning.create_train_op(total_loss=loss,
optimizer=optimizer)
# 循环迭代过程
step_train(train_op, loss, accuracy, score, classIds, train_images_batch,
train_labels_batch, train_nums, train_log_step,
val_images_batch, val_labels_batch, val_nums, val_log_step,
snapshot_prefix, snapshot)