def testEndPoints(self):
batch_size = 5
height, width = 224, 224
num_classes = 1000
for is_training in [True, False]:
with ops.Graph().as_default():
inputs = random_ops.random_uniform(
(batch_size, height, width, 3))
_, end_points = vgg.vgg_16(inputs,
num_classes,
is_training=is_training)
expected_names = [
'vgg_16/conv1/conv1_1', 'vgg_16/conv1/conv1_2',
'vgg_16/pool1', 'vgg_16/conv2/conv2_1',
'vgg_16/conv2/conv2_2', 'vgg_16/pool2',
'vgg_16/conv3/conv3_1', 'vgg_16/conv3/conv3_2',
'vgg_16/conv3/conv3_3', 'vgg_16/pool3',
'vgg_16/conv4/conv4_1', 'vgg_16/conv4/conv4_2',
'vgg_16/conv4/conv4_3', 'vgg_16/pool4',
'vgg_16/conv5/conv5_1', 'vgg_16/conv5/conv5_2',
'vgg_16/conv5/conv5_3', 'vgg_16/pool5', 'vgg_16/fc6',
'vgg_16/fc7', 'vgg_16/fc8'
]
self.assertSetEqual(set(end_points.keys()),
set(expected_names))
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(vgg.vgg_arg_scope()):
out, end_points = vgg.vgg_16(inputs=input_images,
num_classes=labels_nums,
dropout_keep_prob=1.0,
is_training=False)
# 将输出结果进行softmax分布,再求最大概率所属类别
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'))
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 = sess.run([out], feed_dict={input_images: im})
print "image_path:{},pre_score:{}".format(image_path, pre_score)
sess.close()
def extract_features(self, inputs):
with tf.variable_scope('fcn_16s'):
with slim.arg_scope(
vgg.vgg_arg_scope(weight_decay=self._weight_decay)):
fc8_logits, end_points = vgg.vgg_16(
inputs=inputs,
num_classes=self._num_classes,
is_training=self._is_training,
spatial_squeeze=self._spatial_squeeze,
fc_conv_padding='SAME',
global_pool=self._global_pool)
upsampled_fc8_logits = slim.conv2d_transpose(
fc8_logits, self._num_classes, kernel_size=[4, 4],
stride=[2, 2], padding='SAME', activation_fn=None,
normalizer_fn=None, scope='deconv1')
pool4 = end_points['fcn_16s/vgg_16/pool4']
pool4_logits = slim.conv2d(
pool4, self._num_classes, [1, 1], activation_fn=None,
normalizer_fn=None, scope='pool4_conv')
fused_logits = tf.add(pool4_logits, upsampled_fc8_logits,
name='fused_logits')
logits = tf.image.resize_bilinear(
fused_logits, tf.shape(inputs)[1:3], align_corners=True)
return logits
def retrieve(image_dir, gallery_dir, model_path, gallery_encode, feature_code):
"""
:param image_dir: 图片根目录，内有两个子文件夹，query和gallery，都保存有图片
:param gallery_dir: build_gallery将数据保存在此目录，single_query从此目录读取数据
:param model_path: 加载指定模型
:param gallery_encode: True 则进行特征编码，否则加载已经保存的文件
:param feature_code: 1-scda ,2-scda_flip,3-scda_plus,4-scda_flip_plus.input_batch and output_layer also different
:return:
"""
# check dir
assert os.path.isdir(gallery_dir), 'no directory name {}'.format(
gallery_dir) # 保存gallery的文件夹
assert os.path.isdir(image_dir), 'no directory name {}'.format(
image_dir) # 数据集文件夹
assert os.path.isfile(model_path), 'model path not given!'
# build model
input_shape = (None, None, None, 3)
images = tf.placeholder(shape=input_shape, dtype=tf.float32)
final_output, feature_dict = vgg.vgg_16(inputs=images,
num_classes=None,
is_training=False)
# print(feature_dict)
feature_1 = feature_dict['vgg_16/pool5']
feature_2 = feature_dict['vgg_16/conv5/conv5_2']
# final output node depend on feature code
if feature_code == 1 or feature_code == 2:
feature = feature_1
else:
feature = [feature_1, feature_2]
# restore 过滤掉一些不需要加载参数 返回dict可以将保存的变量对应到模型中新的变量，返回list直接加载
include_vars_map = None
saver = tf.train.Saver(include_vars_map)
# define session
with tf.Session() as sess:
# load param
sess.run(tf.global_variables_initializer())
print(model_path)
saver.restore(sess, model_path)
# data_set
query_im_paths, query_labels, gallery_im_paths, gallery_labels = data_utils.split_dataset(
image_dir)
# gallery特征提取或加载
if gallery_encode:
gallery_features = build_gallery(sess, images, feature,
feature_code, gallery_im_paths,
gallery_dir)
else:
gallery_features = np.load(
os.path.join(gallery_dir, 'gallery_features.npy'))
# 开始检索
query(sess, images, feature, feature_code, query_im_paths,
gallery_features, query_labels, gallery_labels)
def testModelVariables(self):
batch_size = 5
height, width = 224, 224
num_classes = 1000
with self.test_session():
inputs = random_ops.random_uniform((batch_size, height, width, 3))
vgg.vgg_16(inputs, num_classes)
expected_names = [
'vgg_16/conv1/conv1_1/weights',
'vgg_16/conv1/conv1_1/biases',
'vgg_16/conv1/conv1_2/weights',
'vgg_16/conv1/conv1_2/biases',
'vgg_16/conv2/conv2_1/weights',
'vgg_16/conv2/conv2_1/biases',
'vgg_16/conv2/conv2_2/weights',
'vgg_16/conv2/conv2_2/biases',
'vgg_16/conv3/conv3_1/weights',
'vgg_16/conv3/conv3_1/biases',
'vgg_16/conv3/conv3_2/weights',
'vgg_16/conv3/conv3_2/biases',
'vgg_16/conv3/conv3_3/weights',
'vgg_16/conv3/conv3_3/biases',
'vgg_16/conv4/conv4_1/weights',
'vgg_16/conv4/conv4_1/biases',
'vgg_16/conv4/conv4_2/weights',
'vgg_16/conv4/conv4_2/biases',
'vgg_16/conv4/conv4_3/weights',
'vgg_16/conv4/conv4_3/biases',
'vgg_16/conv5/conv5_1/weights',
'vgg_16/conv5/conv5_1/biases',
'vgg_16/conv5/conv5_2/weights',
'vgg_16/conv5/conv5_2/biases',
'vgg_16/conv5/conv5_3/weights',
'vgg_16/conv5/conv5_3/biases',
'vgg_16/fc6/weights',
'vgg_16/fc6/biases',
'vgg_16/fc7/weights',
'vgg_16/fc7/biases',
'vgg_16/fc8/weights',
'vgg_16/fc8/biases',
]
model_variables = [
v.op.name for v in variables_lib.get_model_variables()
]
self.assertSetEqual(set(model_variables), set(expected_names))
def testForward(self):
batch_size = 1
height, width = 224, 224
with self.test_session() as sess:
inputs = random_ops.random_uniform((batch_size, height, width, 3))
logits, _ = vgg.vgg_16(inputs)
sess.run(variables.global_variables_initializer())
output = sess.run(logits)
self.assertTrue(output.any())
def testFullyConvolutional(self):
batch_size = 1
height, width = 256, 256
num_classes = 1000
with self.test_session():
inputs = random_ops.random_uniform((batch_size, height, width, 3))
logits, _ = vgg.vgg_16(inputs, num_classes, spatial_squeeze=False)
self.assertEquals(logits.op.name, 'vgg_16/fc8/BiasAdd')
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, 2, 2, num_classes])
def testBuild(self):
batch_size = 5
height, width = 224, 224
num_classes = 1000
with self.test_session():
inputs = random_ops.random_uniform((batch_size, height, width, 3))
logits, _ = vgg.vgg_16(inputs, num_classes)
self.assertEquals(logits.op.name, 'vgg_16/fc8/squeezed')
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
def testEvaluation(self):
batch_size = 2
height, width = 224, 224
num_classes = 1000
with self.test_session():
eval_inputs = tf.random_uniform((batch_size, height, width, 3))
logits, _ = vgg.vgg_16(eval_inputs, is_training=False)
self.assertListEqual(logits.get_shape().as_list(),
[batch_size, num_classes])
predictions = tf.argmax(logits, 1)
self.assertListEqual(predictions.get_shape().as_list(),
[batch_size])
def vgg_model_fn(features, labels, mode, params):
"""Model function for tf.estimator
Args:
features: input batch of images
labels: labels of the images
mode: can be one of tf.estimator.ModeKeys.{TRAIN, EVAL, PREDICT}
params: contains hyperparameters of the model (ex: `params.learning_rate`)
Returns:
model_spec: tf.estimator.EstimatorSpec object
"""
images = features
labels = tf.cast(labels, tf.int64)
# images = tf.reshape(images, [-1, params.image_size, params.image_size, 1])
assert images.shape[1:] == [params.image_size, params.image_size,
3], "{}".format(images.shape)
# MODEL: define the layers of the model
is_training = (mode == tf.estimator.ModeKeys.TRAIN)
embeddings = vgg.vgg_16(inputs=images,
num_classes=params.embedding_size,
is_training=is_training,
dropout_keep_prob=params.dropout_keep_prob)
# 增加一个l2 norm
embedding_mean_norm = tf.reduce_mean(tf.norm(embeddings, axis=1))
# Define triplet loss
if params.triplet_strategy == "batch_all":
loss, fraction = batch_all_triplet_loss(labels,
embeddings,
margin=params.margin,
squared=params.squared)
elif params.triplet_strategy == "batch_hard":
loss = batch_hard_triplet_loss(labels,
embeddings,
margin=params.margin,
squared=params.squared)
else:
raise ValueError("Triplet strategy not recognized: {}".format(
params.triplet_strategy))
# Define training step that minimizes the loss with the Adam optimizer
optimizer = tf.train.AdamOptimizer(params.learning_rate)
global_step = tf.train.get_global_step()
# Add a dependency to update the moving mean and variance for batch normalization
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
train_op = optimizer.minimize(loss, global_step=global_step)
return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
def extract_features(self, inputs):
with slim.arg_scope(
vgg.vgg_arg_scope(weight_decay=self._weight_decay)):
with tf.variable_scope('fcn_32s'):
fc8_logits, end_points = vgg.vgg_16(
inputs=inputs,
num_classes=self._num_classes,
is_training=self._is_training,
spatial_squeeze=self._spatial_squeeze,
fc_conv_padding='SAME',
global_pool=self._global_pool)
logits = tf.image.resize_bilinear(
fc8_logits, tf.shape(inputs)[1:3], align_corners=True)
return logits
def testTrainEvalWithReuse(self):
train_batch_size = 2
eval_batch_size = 1
train_height, train_width = 224, 224
eval_height, eval_width = 256, 256
num_classes = 1000
with self.test_session():
train_inputs = random_ops.random_uniform(
(train_batch_size, train_height, train_width, 3))
logits, _ = vgg.vgg_16(train_inputs)
self.assertListEqual(logits.get_shape().as_list(),
[train_batch_size, num_classes])
variable_scope.get_variable_scope().reuse_variables()
eval_inputs = random_ops.random_uniform(
(eval_batch_size, eval_height, eval_width, 3))
logits, _ = vgg.vgg_16(eval_inputs,
is_training=False,
spatial_squeeze=False)
self.assertListEqual(logits.get_shape().as_list(),
[eval_batch_size, 2, 2, num_classes])
logits = math_ops.reduce_mean(logits, [1, 2])
predictions = math_ops.argmax(logits, 1)
self.assertEquals(predictions.get_shape().as_list(),
[eval_batch_size])
def testEndPoints(self):
batch_size = 5
height, width = 224, 224
num_classes = 1000
with self.test_session():
inputs = tf.random_uniform((batch_size, height, width, 3))
_, end_points = vgg.vgg_16(inputs, num_classes)
expected_names = [
'vgg_16/conv1/conv1_1', 'vgg_16/conv1/conv1_2', 'vgg_16/pool1',
'vgg_16/conv2/conv2_1', 'vgg_16/conv2/conv2_2', 'vgg_16/pool2',
'vgg_16/conv3/conv3_1', 'vgg_16/conv3/conv3_2',
'vgg_16/conv3/conv3_3', 'vgg_16/pool3', 'vgg_16/conv4/conv4_1',
'vgg_16/conv4/conv4_2', 'vgg_16/conv4/conv4_3', 'vgg_16/pool4',
'vgg_16/conv5/conv5_1', 'vgg_16/conv5/conv5_2',
'vgg_16/conv5/conv5_3', 'vgg_16/pool5', 'vgg_16/fc6',
'vgg_16/fc7', 'vgg_16/fc8'
]
self.assertSetEqual(set(end_points.keys()), set(expected_names))
def se_vgg_model_fn(features, labels, mode, params):
"""Model function for tf.estimator
Args:
features: input batch of images
labels: labels of the images
mode: can be one of tf.estimator.ModeKeys.{TRAIN, EVAL, PREDICT}
params: contains hyperparameters of the model (ex: `params.learning_rate`)
Returns:
model_spec: tf.estimator.EstimatorSpec object
"""
images = features
labels = tf.cast(labels, tf.int64)
# images = tf.reshape(images, [-1, params.image_size, params.image_size, 1])
assert images.shape[1:] == [params.image_size, params.image_size,
3], "{}".format(images.shape)
# MODEL: define the layers of the model
is_training = (mode == tf.estimator.ModeKeys.TRAIN)
_, end_points = vgg.vgg_16(images,
num_classes=1000,
is_training=is_training,
dropout_keep_prob=0.5,
spatial_squeeze=True,
scope='vgg_16',
fc_conv_padding='VALID',
global_pool=False)
# SE module 2 loc feature vector
net = end_points['pool5']
loc_feature1 = se_moduel(net, 16)
loc_feature2 = se_moduel(net, 16)
# Define training step that minimizes the loss with the Adam optimizer
optimizer = tf.train.AdamOptimizer(params.learning_rate)
global_step = tf.train.get_global_step()
# Add a dependency to update the moving mean and variance for batch normalization
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
train_op = optimizer.minimize(loss, global_step=global_step)
return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
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(vgg.vgg_arg_scope()):
out, end_points = vgg.vgg_16(inputs=input_images,
num_classes=labels_nums,
dropout_keep_prob=1.0,
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'))
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,
list(labels_filename.keys())[list(
labels_filename.values()).index(pre_label)], max_score))
sess.close()
def extract_feature(imgList, args):
tf.reset_default_graph()
queue = tf.train.string_input_producer(imgList,
num_epochs=None,
shuffle=False)
reader = tf.WholeFileReader()
img_path, img_data = reader.read(queue)
img = vgg_preprocessing.preprocess_image(
tf.image.decode_jpeg(contents=img_data, channels=3), args.imgSize,
args.imgSize)
img = tf.expand_dims(img, 0)
_, _, features = vgg.vgg_16(img, is_training=False)
pool5 = features['pool5']
fc7 = features['fc7']
saver = tf.train.Saver()
init_op = tf.global_variables_initializer()
pool5s = []
fc7s = []
with tf.Session() as sess:
sess.run(init_op)
saver.restore(sess, args.cnnModel)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
feats = []
for i in range(len(imgList)):
p, f = sess.run([pool5, fc7]) # (1, 7, 7, 512) (1, 1, 1, 4096)
pool5s.append(p[0])
fc7s.append(f[0][0][0])
coord.request_stop()
coord.join(threads)
return pool5s, fc7s
#################### 改这里 ########################################
#导入模型
from slim.nets.vgg import vgg_16
from slim.nets.vgg import vgg_arg_scope
#要测试的如数尺寸
input_size = [224, 224, 3]
# 给模型的输入口
inputs = tf.placeholder(tf.float32,
shape=(1, input_size[0], input_size[1], input_size[2]))
num_class = 32
#建造模型
with slim.arg_scope(vgg_arg_scope()):
net, end_points = vgg_16(inputs, num_class)
#只要有logits就可以评估了，中间过程layers_end_points有的话就显示，没有就不显示
logits = net
layers_end_points = end_points
#################### end ###########################################
def show_parament_numbers():
from functools import reduce
from operator import mul
def get_num_params():
num_params = 0
for variable in tf.trainable_variables():
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))
# 从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(vgg.vgg_arg_scope()):
out, end_points = vgg.vgg_16(inputs=input_images,
num_classes=labels_nums,
dropout_keep_prob=keep_prob,
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))
# Specify the optimization scheme:
optimizer = tf.train.GradientDescentOptimizer(learning_rate=base_lr)
# 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)
# 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, 0.9)
# # train_op = optimizer.minimize(loss, global_step)
# train_op = slim.learning.create_train_op(loss, optimizer,global_step=global_step)
saver = tf.train.Saver()
max_acc = 0.0
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(max_steps + 1):
batch_input_images, batch_input_labels = sess.run(
[train_images_batch, train_labels_batch])
_, train_loss = sess.run(
[train_op, loss],
feed_dict={
input_images: batch_input_images,
input_labels: batch_input_labels,
keep_prob: 0.5,
is_training: True
})
# train测试(这里仅测试训练集的一个batch)
if i % train_log_step == 0:
train_acc = sess.run(accuracy,
feed_dict={
input_images: batch_input_images,
input_labels: batch_input_labels,
keep_prob: 1.0,
is_training: False
})
print(
"%s: Step [%d] train Loss : %f, training accuracy : %g" %
(datetime.now(), i, train_loss, train_acc))
# val测试(测试全部val数据)
if i % val_log_step == 0:
mean_loss, mean_acc = net_evaluation(sess, loss, accuracy,
val_images_batch,
val_labels_batch,
val_nums)
print("%s: Step [%d] val Loss : %f, val accuracy : %g" %
(datetime.now(), i, mean_loss, mean_acc))
# 模型保存:每迭代snapshot次或者最后一次保存模型
if (i % snapshot == 0 and i > 0) or i == max_steps:
print('-----save:{}-{}'.format(snapshot_prefix, i))
saver.save(sess, snapshot_prefix, global_step=i)
# 保存val准确率最高的模型
if mean_acc > max_acc and mean_acc > 0.5:
max_acc = mean_acc
path = os.path.dirname(snapshot_prefix)
best_models = os.path.join(
path, 'best_models_{}_{:.4f}.ckpt'.format(i, max_acc))
print('------save:{}'.format(best_models))
saver.save(sess, best_models)
coord.request_stop()
coord.join(threads)
padding_size[1],
target_input_size[0],
target_input_size[1])
processed_images = tf.expand_dims(mean_centered_image, 0)
upsample_filter_np = biliner_upsample_weights(upsample_factor,
number_of_classes)
upsample_factor_tensor = tf.Variable(upsample_filter_np,
name='vgg_16/fc8/t_conv')
with slim.arg_scope(vgg.vgg_arg_scope()):
logits, end_points = vgg.vgg_16(processed_images,
num_classes=2,
is_training=is_training_placeholder,
spatial_squeeze=False,
fc_conv_padding='SAME')
downsampled_logits_shape = tf.shape(logits)
upsampled_logits_shape = tf.stack([
downsampled_logits_shape[0], original_shape[0], original_shape[1],
downsampled_logits_shape[3]
])
upsample_logits = tf.nn.conv2d_transpose(
logits,
upsample_factor_tensor,
output_shape=upsampled_logits_shape,
strides=[1, upsample_factor, upsample_factor, 1],
################################################
## Defining the generators for training and validation batches
################################################
train_gen = data_gen_small(train_images, batch_size, width, height)
val_gen = data_gen_small(validation_images, batch_size, width, height)
with tf.Graph().as_default():
x = tf.placeholder(tf.float32, [None, width, height, 3])
y = tf.placeholder(tf.float32, [None, 1])
################################################
## Load the VGG16 model from slim extract the fully connected layer
## before the final output layer
################################################
with slim.arg_scope(vgg.vgg_arg_scope()):
logits, end_points = vgg.vgg_16(x, num_classes=1000, is_training=False)
fc_7 = end_points['vgg_16/fc7']
## Define the only set of weights that we will learn W1 and b1
################################################
W1 = tf.Variable(tf.random_normal([4096, 1], mean=0.0, stddev=0.02),
name='W1')
b = tf.Variable(tf.random_normal([1], mean=0.0, stddev=0.02), name='b')
################################################
## Reshape the fully connected layer fc_7 and define
## the logits and probability
################################################
fc_7 = tf.reshape(fc_7, [-1, W1.get_shape().as_list()[0]])
logitx = tf.nn.bias_add(tf.matmul(fc_7, W1), b)
probx = tf.nn.sigmoid(logitx)
def train(data_csv_path_train, train_log_step, train_param, data_csv_path_val,
val_log_step, labels_nums, data_shape, snapshot, snapshot_prefix):
'''
:param data_csv_path_train: 训练的csv文件
:param train_log_step: 显示训练过程log信息间隔
:param train_param: train参数
:param data_csv_path_val: 验证的val文件
: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
# 获得训练和测试的样本数
with open(dataset_csv_path_train, 'r') as f:
train_nums = len(f.readlines())
with open(dataset_csv_path_val, 'r') as v:
val_nums = len(v.readlines())
print('train nums:%d,val nums:%d' % (train_nums, val_nums))
train_batch = data_loader.load_data(data_csv_path_train,
image_type=args.image_type,
image_size_before_crop=resize_height,
labels_nums=labels_nums)
train_images_batch = train_batch['image']
train_labels_batch = train_batch['label']
# print('......................................................')
# print(train_images_batch)
# print(train_labels_batch)
# val数据,验证数据可以不需要打乱数据
val_batch = data_loader.load_data(data_csv_path_val,
image_type=args.image_type,
image_size_before_crop=resize_height,
labels_nums=labels_nums,
do_shuffle=False)
val_images_batch = val_batch['image']
val_labels_batch = val_batch['label']
# Define the model:
with slim.arg_scope(vgg.vgg_arg_scope()):
out, end_points = vgg.vgg_16(inputs=input_images,
num_classes=labels_nums,
dropout_keep_prob=keep_prob,
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=False) #添加正则化损失loss=2.2
accuracy = tf.reduce_mean(
tf.cast(tf.equal(tf.argmax(out, 1), tf.argmax(input_labels, 1)),
tf.float32))
# 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)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=base_lr)
# # 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, 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)
model_dir = "../model/vgg_16/"
x_shape = np.append([None], (IMAGE_SIZE, IMAGE_SIZE, 3), axis=0)
x = tf.placeholder(tf.float32, x_shape, "x")
y_shape = np.append([None], [NUM_CLASSES], axis=0)
y = tf.placeholder(tf.float32, y_shape, "y")
y_test = tf.placeholder(tf.float32, y_shape, "y_test")
is_training = tf.placeholder(dtype=tf.bool, name="is_training")
with slim.arg_scope(vgg.vgg_arg_scope()):
logits, _ = vgg.vgg_16(x, num_classes=NUM_CLASSES, is_training=is_training)
# Name logits Tensor, so that is can be loaded from disk after training
logits = tf.identity(logits, name='logits')
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))
optimizer = tf.train.AdamOptimizer().minimize(cost)
correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name='accuracy')
saver = tf.train.Saver()
epochs = 1000
batch_size = 128
log_every_n_iter = 50
def train(train_filename, train_images_dir, train_log_step, train_param,
val_filename, val_images_dir, 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
# # 从record中读取图片和labels数据
tf_image, tf_labels = read_images(train_filename,
train_images_dir,
data_shape,
shuffle=True,
type='normalization')
train_images_batch, train_labels_batch = get_batch_images(
tf_image,
tf_labels,
batch_size=batch_size,
labels_nums=labels_nums,
one_hot=False,
shuffle=True)
# Define the model:
with slim.arg_scope(vgg.vgg_arg_scope()):
out, end_points = vgg.vgg_16(inputs=input_images,
num_classes=labels_nums,
dropout_keep_prob=keep_prob,
is_training=is_training)
loss = tf.reduce_sum(tf.squared_difference(x=out, y=input_labels))
# loss1=tf.squared_difference(x=out,y=input_labels)
# loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y))
train_op = tf.train.AdamOptimizer(learning_rate=base_lr).minimize(loss)
# tf.losses.add_loss(loss1)
# # slim.losses.add_loss(my_loss)
# loss = tf.losses.get_total_loss(add_regularization_losses=True) # 添加正则化损失loss=2.2
# # Specify the optimization scheme:
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=base_lr)
# # 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)
saver = tf.train.Saver(max_to_keep=4)
max_acc = 0.0
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(max_steps + 1):
batch_input_images, batch_input_labels = sess.run(
[train_images_batch, train_labels_batch])
_, train_loss = sess.run(
[train_op, loss],
feed_dict={
input_images: batch_input_images,
input_labels: batch_input_labels,
keep_prob: 0.5,
is_training: True
})
if i % train_log_step == 0:
print("%s: Step [%d] train Loss : %f" %
(datetime.now(), i, train_loss))
# # train测试(这里仅测试训练集的一个batch)
# if i%train_log_step == 0:
# train_acc = sess.run(accuracy, feed_dict={input_images:batch_input_images,
# input_labels: batch_input_labels,
# keep_prob:1.0, is_training: False})
# print "%s: Step [%d] train Loss : %f, training accuracy : %g" % (datetime.now(), i, train_loss, train_acc)
#
# # val测试(测试全部val数据)
# if i%val_log_step == 0:
# _, train_loss = sess.run([train_step, loss], feed_dict={input_images: batch_input_images,
# input_labels: batch_input_labels,
# keep_prob: 1.0, is_training: False})
# print "%s: Step [%d] val Loss : %f, val accuracy : %g" % (datetime.now(), i, mean_loss, mean_acc)
#
# 模型保存:每迭代snapshot次或者最后一次保存模型
if (i % snapshot == 0 and i > 0) or i == max_steps:
print('-----save:{}-{}'.format(snapshot_prefix, i))
saver.save(sess, snapshot_prefix, global_step=i)
# # 保存val准确率最高的模型
# if mean_acc>max_acc and mean_acc>0.5:
# max_acc=mean_acc
# path = os.path.dirname(snapshot_prefix)
# best_models=os.path.join(path,'best_models_{}_{:.4f}.ckpt'.format(i,max_acc))
# print('------save:{}'.format(best_models))
# saver.save(sess, best_models)
coord.request_stop()
coord.join(threads)
# # Subtract the mean pixel value from each pixel
processed_image = _mean_image_subtraction(image_float,
[_R_MEAN, _G_MEAN, _B_MEAN])
print "processed_image: ", processed_image
input_image = tf.expand_dims(processed_image, 0)
print "input_image: ", input_image
with slim.arg_scope(vgg.vgg_arg_scope()):
# spatial_squeeze option enables to use network in a fully
# convolutional manner
logits, _ = vgg.vgg_16(input_image,
num_classes=1000,
is_training=False,
spatial_squeeze=False)
print "logits: ", logits
# For each pixel we get predictions for each class
# out of 1000. We need to pick the one with the highest
# probability. To be more precise, these are not probabilities,
# because we didn't apply softmax. But if we pick a class
# with the highest value it will be equivalent to picking
# the highest value after applying softmax
pred = tf.argmax(logits, dimension=3)
var_list = slim.get_model_variables('vgg_16')
init_fn = slim.assign_from_checkpoint_fn(
