def __init__(self,is_training): self.input_image = tf.placeholder(dtype=tf.float32,shape=[None,224,224,3],name='input_image') logits, end_points = resnet_v2.resnet_v2_50(self.input_image, num_classes=100, is_training=True) self.feature = logits self.output = tf.sigmoid(logits)
def arch_resnet_v2_50(self, X, num_classes, dropout_keep_prob=0.8, is_train=False):
arg_scope = resnet_arg_scope()
with slim.arg_scope(arg_scope):
net_vis, end_points = resnet_v2_50(X, is_training=is_train)
with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='SAME'):
with tf.variable_scope('Logits_out'):
net = slim.conv2d(net_vis, 1000, [1, 1], activation_fn=None, normalizer_fn=None, scope='Logits_out0')
net = slim.dropout(net, dropout_keep_prob, scope='Dropout_1b_out0')
net = slim.conv2d(net, 200, [1, 1], activation_fn=None, normalizer_fn=None, scope='Logits_out1')
net = slim.dropout(net, dropout_keep_prob, scope='Dropout_1b_out1')
net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope='Logits_out2')
net = tf.squeeze(net,[1,2], name='SpatialSqueeze')
return net, net_vis
def __init__(self, is_training):
self.input_image = tf.placeholder(dtype=tf.float32,
shape=[None, 224, 224, 3],
name='input_image')
logits, end_points = resnet_v2.resnet_v2_50(self.input_image,
num_classes=100,
is_training=True)
self.feature = logits
self.output = tf.sigmoid(logits)
def build_deeplabv3(inputs, num_classes, preset_model='DeepLabV3-Res50', weight_decay=1e-5, is_training=True, pretrained_dir="models"):
"""
Builds the DeepLabV3 model.
Arguments:
inputs: The input tensor=
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
Returns:
DeepLabV3 model
"""
if preset_model == 'DeepLabV3-Res50':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(inputs, is_training=is_training, scope='resnet_v2_50')
resnet_scope='resnet_v2_50'
# DeepLabV3 requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50'))
elif preset_model == 'DeepLabV3-Res101':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_101(inputs, is_training=is_training, scope='resnet_v2_101')
resnet_scope='resnet_v2_101'
# DeepLabV3 requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101'))
elif preset_model == 'DeepLabV3-Res152':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_152(inputs, is_training=is_training, scope='resnet_v2_152')
resnet_scope='resnet_v2_152'
# DeepLabV3 requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152'))
else:
raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152" % (preset_model))
label_size = tf.shape(inputs)[1:3]
net = AtrousSpatialPyramidPoolingModule(end_points['pool4'])
net = Upsampling(net, label_size)
net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits')
return net, init_fn
def arch_resnet_v2_50_rnn_attention(self,
X,
num_classes,
dropout_keep_prob=0.8,
is_train=False):
rnn_size = 256
num_layers = 2
attention_size = 64
arg_scope = resnet_arg_scope()
with slim.arg_scope(arg_scope):
net_vis, end_points = resnet_v2_50(X, is_training=is_train)
with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
stride=1,
padding='SAME'):
with tf.variable_scope('Logits_out'):
orig_shape = net_vis.get_shape().as_list()
net = tf.reshape(
net_vis,
[-1, orig_shape[1] * orig_shape[2], orig_shape[3]])
def gru_cell():
return tf.contrib.rnn.GRUCell(run_size)
def lstm_cell():
return tf.contrib.rnn.LSTMCell(rnn_size)
def attn_cell():
return tf.contrib.rnn.DropoutWrapper(
lstm_cell(), output_keep_prob=dropout_keep_prob)
stack = tf.contrib.rnn.MultiRNNCell(
[lstm_cell() for _ in range(0, num_layers)],
state_is_tuple=True)
net, _ = tf.nn.dynamic_rnn(stack, net, dtype=tf.float32)
net = tf.transpose(net, (1, 0, 2))
net = attention(net, attention_size, True)
#
#net = slim.fully_connected(net[-1], 256, activation_fn=tf.nn.relu, scope='Logits_out0')
net = slim.fully_connected(net,
num_classes,
activation_fn=None,
scope='Logits_out1')
return net, net_vis
def __init__(self,is_training):
self.input_image = tf.placeholder(dtype=tf.float32,shape=[None,224,224,3],name='input_image')
self.input_label = tf.placeholder(dtype=tf.float32,shape=[None,100],name='input_label')
logits, end_points = resnet_v2.resnet_v2_50(self.input_image, num_classes=100, is_training=True)
self.ce_loss = tf.reduce_mean(tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(labels=self.input_label,logits=logits),1))
tf.summary.scalar('ce_loss',self.ce_loss)
slim.losses.add_loss(self.ce_loss)
self.l2_loss = tf.add_n(slim.losses.get_regularization_losses())
tf.summary.scalar('l2_loss',self.l2_loss)
self.total_loss = slim.losses.get_total_loss()
tf.summary.scalar('total_loss',self.total_loss)
self.output = tf.sigmoid(logits)
def build_encoder(input_shape,
encoder_name,
encoder_weights=None,
weight_decay=1e-4,
kernel_initializer="he_normal",
bn_epsilon=1e-3,
bn_momentum=0.99):
""" the main api to build a encoder.
:param input_shape: tuple, i.e., (height, width. channel).
:param encoder_name: string, name of the encoder, refer to 'scope_table' above.
:param encoder_weights: string, path of the weight, default None.
:param weight_decay: float, default 1e-4.
:param kernel_initializer: string, default "he_normal".
:param bn_epsilon: float, default 1e-3.
:param bn_momentum: float, default 0.99.
:return: a Keras Model instance.
"""
encoder_name = encoder_name.lower()
if encoder_name=="resnet_v2_50":
encoder = resnet_v2_50(input_shape, weight_decay=weight_decay, kernel_initializer=kernel_initializer, bn_epsilon=bn_epsilon, bn_momentum=bn_momentum)
elif encoder_name=="resnet_v2_50_nosam":
encoder = resnet_v2_50_nosam(input_shape, weight_decay=weight_decay, kernel_initializer=kernel_initializer,bn_epsilon=bn_epsilon, bn_momentum=bn_momentum)
elif encoder_name == "xception_41":
encoder = xception_41(input_shape, weight_decay=weight_decay, kernel_initializer=kernel_initializer, bn_epsilon=bn_epsilon, bn_momentum=bn_momentum)
elif encoder_name == "xception_41_nosam":
encoder = xception_41_nosam(input_shape, weight_decay=weight_decay, kernel_initializer=kernel_initializer, bn_epsilon=bn_epsilon, bn_momentum=bn_momentum)
else:
raise ValueError("Invalid encoder name")
if encoder_weights is not None and os.path.exists(encoder_weights):
encoder.load_weights(encoder_weights)
return encoder
def generate_features(predict_flag, gallery_flag):
print('generate_features(%s, %s)' % (predict_flag, gallery_flag))
with tf.Graph().as_default():
# define placeholder
train_mode = tf.placeholder(tf.bool, name='train_mode')
input_batch = tf.placeholder(tf.float32,
[None, IMAGE_HEIGHT, IMAGE_WIDTH, 3],
'input_batch')
# define model
resnet_reid = ResnetReid()
with slim.arg_scope(resnet_arg_scope()):
# input_batch: [batch, height, width, 3] values scaled [0.0, 1.0], dtype = tf.float32
resnet_avg_pool, end_points = resnet_v2_50(input_batch,
is_training=False,
global_pool=True)
resnet_reid.build(resnet_avg_pool, train_mode)
# define sess
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# load checkpoint
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(
train_flags.output_check_point_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('load checkpoint')
# define parameter
if gallery_flag and predict_flag:
features_num = train_flags.predict_gallery_num
features_npy_name = 'predict_gallery_features.npy'
get_image_batch = resnet_reid.get_predict_image_batch
file_title = 'predict'
elif gallery_flag and (not predict_flag):
features_num = train_flags.train_200_gallery_num
features_npy_name = 'train_200_gallery_features.npy'
get_image_batch = resnet_reid.get_test_image_batch
file_title = 'train_200'
elif (not gallery_flag) and predict_flag:
features_num = train_flags.predict_probe_num
features_npy_name = 'predict_probe_features.npy'
get_image_batch = resnet_reid.get_predict_image_batch
file_title = 'predict'
else:
features_num = train_flags.train_200_probe_num
features_npy_name = 'train_200_probe_features.npy'
get_image_batch = resnet_reid.get_test_image_batch
file_title = 'train_200'
print('start generate features')
# get feature batch
features = np.zeros((features_num, train_flags.output_feature_dim),
dtype=float)
batch_len = train_flags.test_batch_size
end_len = features_num % batch_len
for batch_index in range(0, features_num - end_len, batch_len):
batch = get_image_batch(batch_index, batch_len,
train_flags.id_image_path, file_title,
gallery_flag)
batch_feature = sess.run(resnet_reid.output,
feed_dict={
input_batch: batch,
train_mode: False
})
features[batch_index:batch_index +
batch_len, :] = batch_feature
print('batch_index: ' + str(batch_index) + '-' +
str(batch_index + batch_len - 1))
if end_len != 0:
batch_index += batch_len
batch = get_image_batch(batch_index, batch_len,
train_flags.id_image_path, file_title,
gallery_flag)
batch_feature = sess.run(resnet_reid.output,
feed_dict={
input_batch: batch,
train_mode: False
})
features[batch_index:batch_index +
end_len, :] = batch_feature[:end_len]
print('batch_index: ' + str(batch_index) + '-' +
str(batch_index + end_len - 1))
# save feature
features_npy_path = os.path.join(
train_flags.output_test_features_path, features_npy_name)
np.save(features_npy_path, features)
def build_model(self):
"""Builds the model.
Inputs:
self.images
self.target_labels
self.model_config.train_base_network
self.model_config.mode
Outputs:
self.sigmoid_result (inference)
self.cross_entropy (train, eval)
self.total_loss
"""
# build resnet_50
arg_scope = self.resnet_arg_scope()
is_base_network_training = self.model_config.train_base_network and (
self.model_config.mode == "train")
with slim.arg_scope(arg_scope):
net, end_points = resnet_v2_50(
self.images,
is_training=is_base_network_training,
global_pool=False)
with tf.variable_scope('my_sub_network'):
if self.model_config.use_regularizer:
weights_regularizer = slim.l2_regularizer(
self.model_config.weight_decay)
else:
weights_regularizer = None
net = slim.conv2d(net,
self.model_config.label_count, [1, 1],
weights_regularizer=weights_regularizer,
scope="my_conv_1")
net = slim.conv2d(net,
self.model_config.label_count, [1, 1],
weights_regularizer=weights_regularizer,
scope="my_conv_2")
net = slim.conv2d(net,
self.model_config.label_count, [7, 7],
weights_regularizer=weights_regularizer,
padding="VALID",
activation_fn=None,
scope="my_conv_3")
logits = tf.squeeze(net, [1, 2], name="logits")
self.sigmoid_result = tf.sigmoid(logits, name="sigmoid_result")
if self.model_config.mode == "inference":
return
tf.logging.info(
"Before:--- GraphKeys.LOSSES len: {}; GraphKeys.REGULARIZATION_LOSSES len: {}"
.format(len(tf.losses.get_losses()),
len(tf.losses.get_regularization_losses())))
# By default, all the losses in 'tf.losses' are collected into the GraphKeys.LOSSES collection.
sigmoid_cross_entropy_loss = tf.losses.sigmoid_cross_entropy(
multi_class_labels=self.target_labels,
logits=logits,
scope="sigmoid_cross_entropy")
# get_total_loss get both GraphKeys.LOSSES and GraphKeys.REGULARIZATION_LOSSES.
total_loss = tf.losses.get_total_loss()
tf.logging.info(
"After:--- GraphKeys.LOSSES len: {}; GraphKeys.REGULARIZATION_LOSSES len: {}"
.format(len(tf.losses.get_losses()),
len(tf.losses.get_regularization_losses())))
# Add summaries.
tf.summary.scalar("losses/sigmoid_cross_entropy_loss",
sigmoid_cross_entropy_loss)
tf.summary.scalar("losses/total_loss", total_loss)
self.sigmoid_cross_entropy_loss = sigmoid_cross_entropy_loss
self.total_loss = total_loss
def train():
tf.logging.set_verbosity(
tf.logging.INFO) # Set the verbosity to INFO level
initial_learning_rate = 0.0002
learning_rate_decay_factor = 0.7
decay_steps = 40000
checkpoint_file = tf.train.latest_checkpoint(log_root)
print(checkpoint_file)
images, one_hot_labels = get_input(20, FLAGS.batch_size, hand=FLAGS.hand)
with slim.arg_scope(resnet_utils.resnet_arg_scope()):
logits, end_points = resnet_v2_50(images, 20)
print logits, end_points
variables_to_restore = slim.get_variables_to_restore()
loss = tf.losses.softmax_cross_entropy(onehot_labels=one_hot_labels,
logits=logits)
total_loss = tf.losses.get_total_loss(
) # obtain the regularization losses as well
# Create the global step for monitoring the learning_rate and training.
global_step_1 = tf.contrib.framework.get_or_create_global_step()
# Define your exponentially decaying learning rate
lr = tf.train.exponential_decay(learning_rate=initial_learning_rate,
global_step=global_step_1,
decay_steps=decay_steps,
decay_rate=learning_rate_decay_factor,
staircase=True)
# Now we can define the optimizer that takes on the learning rate
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
#variables_to_train = [v for v in variables_to_restore if 'resnet_v2_50/logits' in v.name]
#print variables_to_train
#raw_input()
# Create the train_op.
train_op = slim.learning.create_train_op(
total_loss,
optimizer,
) # variables_to_train = variables_to_train)
# State the metrics that you want to predict. We get a predictions that is not one_hot_encoded.
predictions = tf.argmax(end_points['predictions'], 1)
probabilities = end_points['predictions']
labels = tf.argmax(one_hot_labels, 1)
precision = tf.reduce_mean(tf.to_float(tf.equal(predictions, labels)))
summary_writer = tf.summary.FileWriter(train_dir)
summary_op = tf.summary.merge([
tf.summary.scalar('costs/cost', total_loss),
tf.summary.scalar('Precision', precision),
tf.summary.scalar('learning_rate', lr)
])
saver = tf.train.Saver(max_to_keep=0)
sess = tf.Session()
saver.restore(sess, tf.train.latest_checkpoint(log_root))
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
var = [
v for v in tf.model_variables()
if "50/conv1" in v.name or "logits" in v.name
]
var_list = sess.run(var)
for v1, v in zip(var, var_list):
print v1.name, v.shape, np.min(v), np.max(v), np.mean(v), np.std(v)
saver.save(sess,
os.path.join(log_root, "model.ckpt"),
global_step=global_step_1)
checkpoint_time = time.time()
while True:
_, summary, g_step, loss, accuracy, l_rate = sess.run(
[train_op, summary_op, global_step_1, total_loss, precision, lr])
if g_step % 10 == 0:
tf.logging.info(
'Global_step_1: %d, loss: %f, precision: %.2f, lr: %f' %
(g_step, loss, accuracy, l_rate))
if time.time() - checkpoint_time > save_checkpoint_secs:
saver.save(sess,
os.path.join(log_root, "model.ckpt"),
global_step=global_step_1)
checkpoint_time = time.time()
if g_step % save_summaries_steps == 0:
summary_writer.add_summary(summary, g_step)
summary_writer.flush()
def evaluate():
"""Eval loop."""
images, one_hot_labels = get_input(20, FLAGS.batch_size, FLAGS.mode,
FLAGS.hand)
gesture_list = os.listdir(
"/s/red/a/nobackup/cwc/hands/rgb_hands_new_frames/s_01")
gesture_list.sort()
print gesture_list
with slim.arg_scope(resnet_utils.resnet_arg_scope()):
logits_tensor, end_points = resnet_v2_50(images, 20, False)
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(eval_dir)
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
tf.train.start_queue_runners(sess)
best_precision = 0.0
predictions_tensor = tf.argmax(end_points['predictions'], 1)
probabilities_tensor = end_points['predictions']
labels = tf.argmax(one_hot_labels, 1)
#precision = tf.reduce_mean(tf.to_float(tf.equal(predictions_tensor, labels)))
checkpoint_list = os.listdir(log_root)
checkpoint_list = [
c.replace(".index", "") for c in checkpoint_list if ".index" in c
]
print checkpoint_list
precision_list = []
#while True:
for c in checkpoint_list:
try:
ckpt_state = tf.train.get_checkpoint_state(log_root)
except tf.errors.OutOfRangeError as e:
tf.logging.error('Cannot restore checkpoint: %s', e)
continue
if not (ckpt_state and ckpt_state.model_checkpoint_path):
tf.logging.info('No model to eval yet at %s', log_root)
continue
ckpt_state.model_checkpoint_path = os.path.join(log_root, c)
tf.logging.info('Loading checkpoint %s',
ckpt_state.model_checkpoint_path)
saver.restore(sess, ckpt_state.model_checkpoint_path)
tf.logging.info("Checkpoint restoration done")
train_step = int(ckpt_state.model_checkpoint_path.split("-")[-1])
total_prediction, correct_prediction = 0, 0
gt_list = []
pred_list = []
for sample in range(212):
(predictions,
truth) = sess.run([probabilities_tensor, one_hot_labels])
gt_list.append(truth)
pred_list.append(predictions)
truth = np.argmax(truth, axis=1)
predictions = np.argmax(predictions, axis=1)
correct_prediction += np.sum(truth == predictions)
total_prediction += predictions.shape[0]
if sample % 40 == 0:
print sample, correct_prediction, total_prediction
gt = np.squeeze(np.vstack(gt_list))
pred = np.squeeze(np.vstack(pred_list))
precision = np.mean(np.argmax(gt, axis=1) == np.argmax(pred, axis=1))
precision_list.append(precision)
best_precision = max(precision, best_precision)
print gt.shape, pred.shape, precision, best_precision
gt = np.argmax(gt, axis=1)
pred = np.argmax(pred, axis=1)
'''cm = np.float(confusion_matrix(gt,pred))
cm /= np.sum(cm,axis=0)
plt.imshow(cm,interpolation='nearest')
plt.xticks(range(20),gesture_list,rotation=90)
plt.yticks(range(20),gesture_list)
plt.show()
precision_summ = tf.Summary()
precision_summ.value.add(tag='Precision', simple_value=precision)
summary_writer.add_summary(precision_summ, train_step)
best_precision_summ = tf.Summary()
best_precision_summ.value.add(tag='Best Precision', simple_value=best_precision)
summary_writer.add_summary(best_precision_summ, train_step)'''
tf.logging.info('precision: %.3f, best precision: %.3f' %
(precision, best_precision))
summary_writer.flush()
#time.sleep(60)
print "Max Precision : ", np.max(
precision_list), " Ckpt: ", checkpoint_list[np.argmax(precision_list)]
def build_pspnet(inputs,
label_size,
num_classes,
preset_model='PSPNet-Res50',
pooling_type="MAX",
weight_decay=1e-5,
upscaling_method="conv",
is_training=True,
pretrained_dir="models"):
"""
Builds the PSPNet model.
Arguments:
inputs: The input tensor
label_size: Size of the final label tensor. We need to know this for proper upscaling
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
pooling_type: Max or Average pooling
Returns:
PSPNet model
"""
if preset_model == 'PSPNet-Res50':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(
inputs, is_training=is_training, scope='resnet_v2_50')
resnet_scope = 'resnet_v2_50'
# PSPNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'),
slim.get_model_variables('resnet_v2_50'))
elif preset_model == 'PSPNet-Res101':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_101(
inputs, is_training=is_training, scope='resnet_v2_101')
resnet_scope = 'resnet_v2_101'
# PSPNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'),
slim.get_model_variables('resnet_v2_101'))
elif preset_model == 'PSPNet-Res152':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_152(
inputs, is_training=is_training, scope='resnet_v2_152')
resnet_scope = 'resnet_v2_152'
# PSPNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'),
slim.get_model_variables('resnet_v2_152'))
else:
raise ValueError(
"Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152"
% (preset_model))
feature_map_shape = [int(x / 8.0) for x in label_size]
print(feature_map_shape)
psp = PyramidPoolingModule(end_points['pool3'],
feature_map_shape=feature_map_shape,
pooling_type=pooling_type)
net = slim.conv2d(psp, 512, [3, 3], activation_fn=None)
net = slim.batch_norm(net, fused=True)
net = tf.nn.relu(net)
if upscaling_method.lower() == "conv":
net = ConvUpscaleBlock(net, 256, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 256)
net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 128)
net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 64)
elif upscaling_method.lower() == "bilinear":
net = Upsampling(net, label_size)
net = slim.conv2d(net,
num_classes, [1, 1],
activation_fn=None,
scope='logits')
return net, init_fn
def build_gcn(inputs, num_classes, preset_model='GCN-Res101', weight_decay=1e-5, is_training=True, upscaling_method="bilinear", pretrained_dir="models"):
"""
Builds the GCN model.
Arguments:
inputs: The input tensor
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
Returns:
GCN model
"""
inputs = mean_image_subtraction(inputs)
if preset_model == 'GCN-Res50':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(inputs, is_training=is_training, scope='resnet_v2_50')
resnet_scope = 'resnet_v2_50'
# GCN requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50'))
elif preset_model == 'GCN-Res101':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_101(inputs, is_training=is_training, scope='resnet_v2_101')
resnet_scope = 'resnet_v2_101'
# GCN requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101'))
elif preset_model == 'GCN-Res152':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_152(inputs, is_training=is_training, scope='resnet_v2_152')
resnet_scope = 'resnet_v2_152'
# GCN requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152'))
else:
raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 101 and ResNet 152" % (preset_model))
res = [end_points['pool5'], end_points['pool4'],
end_points['pool3'], end_points['pool2']]
down_5 = GlobalConvBlock(res[0], n_filters=21, size=3)
down_5 = BoundaryRefinementBlock(down_5, n_filters=21, kernel_size=[3, 3])
down_5 = ConvUpscaleBlock(down_5, n_filters=21, kernel_size=[3, 3], scale=2)
down_4 = GlobalConvBlock(res[1], n_filters=21, size=3)
down_4 = BoundaryRefinementBlock(down_4, n_filters=21, kernel_size=[3, 3])
down_4 = tf.add(down_4, down_5)
down_4 = BoundaryRefinementBlock(down_4, n_filters=21, kernel_size=[3, 3])
down_4 = ConvUpscaleBlock(down_4, n_filters=21, kernel_size=[3, 3], scale=2)
down_3 = GlobalConvBlock(res[2], n_filters=21, size=3)
down_3 = BoundaryRefinementBlock(down_3, n_filters=21, kernel_size=[3, 3])
down_3 = tf.add(down_3, down_4)
down_3 = BoundaryRefinementBlock(down_3, n_filters=21, kernel_size=[3, 3])
down_3 = ConvUpscaleBlock(down_3, n_filters=21, kernel_size=[3, 3], scale=2)
down_2 = GlobalConvBlock(res[3], n_filters=21, size=3)
down_2 = BoundaryRefinementBlock(down_2, n_filters=21, kernel_size=[3, 3])
down_2 = tf.add(down_2, down_3)
down_2 = BoundaryRefinementBlock(down_2, n_filters=21, kernel_size=[3, 3])
down_2 = ConvUpscaleBlock(down_2, n_filters=21, kernel_size=[3, 3], scale=2)
net = BoundaryRefinementBlock(down_2, n_filters=21, kernel_size=[3, 3])
net = ConvUpscaleBlock(net, n_filters=21, kernel_size=[3, 3], scale=2)
net = BoundaryRefinementBlock(net, n_filters=21, kernel_size=[3, 3])
net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits')
return net, init_fn
num_classes=num_classes,
shuffle=False)
# create an reinitializable iterator given the dataset structure
iterator_test = Iterator.from_structure(test_data.data.output_types,
test_data.data.output_shapes)
images_batch_test, labels_batch_test = iterator_test.get_next()
# Ops for initializing the two different iterators
test_init_op = iterator_test.make_initializer(test_data.data)
images_batch = tf.concat([images_batch_test, images_batch_test], axis=0)
y = tf.concat([labels_batch_test, labels_batch_test], axis=0)
with slim.arg_scope(resnet.resnet_arg_scope()):
Gap5, CONV5, net, _ = resnet.resnet_v2_50(images_batch, is_training=False)
net = tf.nn.dropout(net, 1.0)
net = slim.conv2d(net,
num_classes, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope='logits')
score = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
SCORE = tf.reshape(score, [2 * batch_size, -1])
# Evaluation op: Accuracy of the model
with tf.name_scope("accuracy"):
correct_pred = tf.equal(
tf.argmax(tf.slice(SCORE, [0, 0], [batch_size, num_classes]), 1),
tf.argmax(tf.slice(y, [0, 0], [batch_size, num_classes]), 1))
accuracy = tf.reduce_sum(tf.cast(correct_pred, tf.float32))
def test_resnet(device, num_classes, num_layers, dataset, normalization, checkpoint):
"""
Computes accuracy for the test dataset
Inputs: device - gpu device
num_classes - number of output classes
num_layers - number of layers selected for ResNet
dataset - dataset selected, options are val and test
normalization - normalization used options are standard z-score normalization or unet normalization
checkpoint - file where graph model weights are stored
Output: None
"""
print dataset
os.environ['CUDA_VISIBLE_DEVICES'] = str(device) # use nvidia-smi to see available options '0' means first gpu
config = GleasonConfig() # loads pathology configuration
if dataset == 'val':
print "Using val..."
config.test_fn = os.path.join(config.main_dir, 'tfrecords/val.tfrecords')
elif dataset == 'test':
print "Using test..."
config.test_fn = os.path.join(config.main_dir, 'tfrecords/test.tfrecords')
else:
config.test_fn = None
config.test_checkpoint = checkpoint
print "Loading checkpoint: {0}".format(checkpoint)
if int(num_classes) == 2:
print "Converting to Output Shape to Binary..."
config.output_shape = 2
elif int(num_classes) == 4:
config.output_shape = 4
else:
raise Exception('Invalid number of classes!')
batch_size = 128
# loading test data
test_meta = np.load(tfrecord2metafilename(config.test_fn))
print 'Using {0} tfrecords: {1} | {2} images'.format(dataset, config.test_fn, len(test_meta['labels']))
test_filename_queue = tf.train.string_input_producer([config.test_fn] , num_epochs=1) # 1 epoch, passing through the
# the dataset once
test_img, test_t_l, test_f_p = read_and_decode(filename_queue = test_filename_queue,
img_dims = config.input_image_size,
model_dims = config.model_image_size,
size_of_batch = batch_size,
augmentations_dic = config.val_augmentations_dic,
num_of_threads = 4,
shuffle = False)
if int(num_classes) == 2:
print "Converting labels to Binary..."
test_t_l = tf.clip_by_value(test_t_l, 0, 1)
if num_layers == "50":
print "Loading Resnet 50..."
if normalization == "standard":
print "Using standard normalization..."
test_img = normalize(test_img)
elif normalization == "unet":
print "Using unet normalization..."
test_img,_ = unet_preprocess.unet(test_img,
is_training = False,
is_batch_norm = False,
num_channels = 1)
else:
raise Exception('Not known normalization! Options are: standard and unet.')
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay = config.l2_reg)):
test_target_logits, _ = resnet_v2.resnet_v2_50(inputs = test_img,
num_classes = config.output_shape,
is_training = False)
elif num_layers == "101":
print "Loading Resnet 101..."
if normalization == "standard":
print "Using standard normalization..."
test_img = normalize(test_img)
elif normalization == "unet":
print "Using unet normalization..."
test_img,_ = unet_preprocess.unet(test_img,
is_training = False,
is_batch_norm = False,
num_channels = 1)
else:
raise Exception('Not known normalization! Options are: standard and unet.')
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay = config.l2_reg)):
test_target_logits, _ = resnet_v2.resnet_v2_101(inputs = test_img,
num_classes = config.output_shape,
is_training = False)
else:
raise Expection("Wrong number of layers! allowed numbers are 50 and 101.")
target_prob = tf.nn.softmax(test_target_logits)
prob_and_label_files = [target_prob, test_t_l, test_f_p]
restorer = tf.train.Saver()
print "Variables stored in checkpoint:"
print_tensors_in_checkpoint_file(file_name=config.test_checkpoint, tensor_name='', all_tensors='')
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
sess.run(tf.group(tf.global_variables_initializer(),tf.local_variables_initializer()))
restorer.restore(sess, config.test_checkpoint)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
all_predictions_target = []
all_predictions_t_n = []
all_labels = []
all_files = []
batch_num = 1
try:
print "Total number of batch iterations needed: {0}".format(int(math.ceil(len(test_meta['labels'])/batch_size)))
while not coord.should_stop():
np_prob_and_label_files = sess.run(prob_and_label_files)
target_probs = np_prob_and_label_files[0]
labels = np_prob_and_label_files[1]
files = np_prob_and_label_files[2]
all_labels += list(labels)
all_files += list(files)
all_predictions_target += list(np.argmax(target_probs, axis=1))
print "evaluating current batch number: {0}".format(batch_num)
batch_num +=1
except tf.errors.OutOfRangeError:
print "{0} accuracy: {1:.2f}".format(dataset, (metrics.accuracy_score(all_labels, all_predictions_target)*100))
if int(num_classes) == 2:
print "{0} precision: {1:.2f}".format(dataset, (metrics.precision_score(all_labels, all_predictions_target)*100))
print "{0} recall: {1:.2f}".format(dataset, (metrics.recall_score(all_labels, all_predictions_target)*100))
print
finally:
coord.request_stop()
coord.join(threads)
def build_refinenet(inputs,
num_classes,
preset_model='RefineNet-Res101',
weight_decay=1e-5,
is_training=True,
upscaling_method="bilinear",
pretrained_dir="models"):
"""
Builds the RefineNet model.
Arguments:
inputs: The input tensor
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
Returns:
RefineNet model
"""
inputs = mean_image_subtraction(inputs)
if preset_model == 'RefineNet-Res50':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(
inputs, is_training=is_training, scope='resnet_v2_50')
# RefineNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'),
slim.get_model_variables('resnet_v2_50'))
elif preset_model == 'RefineNet-Res101':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_101(
inputs, is_training=is_training, scope='resnet_v2_101')
# RefineNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'),
slim.get_model_variables('resnet_v2_101'))
elif preset_model == 'RefineNet-Res152':
with slim.arg_scope(
resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_152(
inputs, is_training=is_training, scope='resnet_v2_152')
# RefineNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'),
slim.get_model_variables('resnet_v2_152'))
else:
raise ValueError(
"Unsupported ResNet model '%s'. This function only supports ResNet 101 and ResNet 152"
% (preset_model))
f = [
end_points['pool5'], end_points['pool4'], end_points['pool3'],
end_points['pool2']
]
g = [None, None, None, None]
h = [None, None, None, None]
for i in range(4):
h[i] = slim.conv2d(f[i], 256, 1)
g[0] = RefineBlock(high_inputs=None, low_inputs=h[0])
g[1] = RefineBlock(g[0], h[1])
g[2] = RefineBlock(g[1], h[2])
g[3] = RefineBlock(g[2], h[3])
# g[3]=Upsampling(g[3],scale=4)
net = g[3]
if upscaling_method.lower() == "conv":
net = ConvUpscaleBlock(net, 256, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 256)
net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 128)
net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 64)
elif upscaling_method.lower() == "bilinear":
net = Upsampling(net, scale=4)
net = slim.conv2d(net,
num_classes, [1, 1],
activation_fn=None,
scope='logits')
return net, init_fn
def train(retain_flag=True, start_step=0):
print('train(retain_flag=%s, start_step=%s)' % (retain_flag, start_step))
with tf.Graph().as_default():
# define placeholder
train_mode = tf.placeholder(tf.bool, name='train_mode')
input_batch = tf.placeholder(tf.float32,
[None, IMAGE_HEIGHT, IMAGE_WIDTH, 3],
'input_batch')
# define model
resnet_reid = ResnetReid(train_flags.dropout)
input_batch = tf.cond(
train_mode, lambda: resnet_reid.process_image(
input_batch, train_flags.train_batch_size),
lambda: input_batch, 'process_image')
with slim.arg_scope(resnet_arg_scope()):
# input_batch: [batch, height, width, 3] values scaled [0.0, 1.0], dtype = tf.float32
resnet_avg_pool, end_points = resnet_v2_50(input_batch,
is_training=False,
global_pool=True)
# Define the scopes that you want to exclude for restoration
variables_to_restore = slim.get_variables_to_restore(
exclude=['beta2_power'])
resnet_reid.build(resnet_avg_pool, train_mode)
# define loss
loss = tf.cond(train_mode, lambda: _model_loss(resnet_reid),
lambda: tf.constant([0.0], dtype=tf.float32),
'chose_loss')
# Create an optimizer that performs gradient descent.
global_step = get_or_create_global_step()
lr = tf.train.exponential_decay(train_flags.initial_learning_rate,
global_step,
train_flags.decay_steps,
train_flags.decay_rate,
staircase=True)
vars_to_optimize = [v for v in tf.trainable_variables()]
# vars_to_optimize = [v for v in tf.trainable_variables() if ('add' in v.name)]
print('\nvariables to optimize')
for v in vars_to_optimize:
print(v.name, v.get_shape().as_list())
tf.summary.histogram(v.name, v)
opt = tf.train.AdamOptimizer(lr)
grads = opt.compute_gradients(loss, var_list=vars_to_optimize)
apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)
train_op = tf.group(apply_gradient_op)
# define sess
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# define summary and saver
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(train_flags.output_summary_path,
graph=sess.graph)
saver = tf.train.Saver(max_to_keep=8)
# retrain or continue
if retain_flag:
saver_resnet = tf.train.Saver(variables_to_restore)
saver_resnet.restore(sess, train_flags.resnet_checkpoint_file)
else:
# load checkpoint
ckpt = tf.train.get_checkpoint_state(
train_flags.output_check_point_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('load checkpoint')
print('start training')
for step in range(start_step, train_flags.max_step):
# input image
batch = resnet_reid.get_train_image_batch_direct(
train_flags.id_path_train_path, train_flags.return_id_num,
train_flags.image_num_every_id)
# if step == 0: # load mode
# change_file_flag = True
# else:
# change_file_flag = False
# batch = resnet_reid.get_train_image_batch(train_flags.id_image_path, train_flags.id_image_train_num,
# train_flags.return_id_num, train_flags.image_num_every_id,
# change_file=change_file_flag)
# start run
start_time = time.time()
_, loss_value = sess.run([train_op, loss],
feed_dict={
input_batch: batch,
train_mode: True
})
# _, loss_value, f = sess.run([train_op, loss, resnet_reid.output],
# feed_dict={input_batch: batch, train_mode: True})
# print('feature abs mean: %s' % (np.mean(np.abs(f))))
duration = time.time() - start_time
assert not np.isnan(loss_value), 'Model diverged with loss = NaN'
if step % 10 == 0:
examples_per_sec = train_flags.train_batch_size / float(
duration)
format_str = '%s: step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)'
print(format_str % (datetime.now(), step, loss_value,
examples_per_sec, duration))
if step % 100 == 0:
summary_str, feature = sess.run(
[summary_op, resnet_reid.output],
feed_dict={
input_batch: batch,
train_mode: True
})
print('feature abs mean: %s' % (np.mean(np.abs(feature))))
summary_str = sess.run(summary_op,
feed_dict={
input_batch: batch,
train_mode: True
})
summary_writer.add_summary(summary_str, step)
if step % 5000 == 0 or (step + 1) == train_flags.max_step:
# Save the model checkpoint periodically.
checkpoint_path = os.path.join(
train_flags.output_check_point_path,
train_flags.checkpoint_name)
saver.save(sess, checkpoint_path, global_step=step)
# do test: send every image in valid_gallery.csv and valid_probe.csv, then get feature vector
# save all feature vector in npy
def valid(gallery_flag):
# get feature batch
features_num = train_flags.valid_gallery_num if gallery_flag else train_flags.valid_probe_num
features = np.zeros(
(features_num, train_flags.output_feature_dim),
dtype=float)
batch_len = train_flags.test_batch_size
batch_name = 'valid_gallery_batch_index: ' if gallery_flag else 'valid_probe_batch_index: '
end_len = features_num % batch_len
for batch_index in range(0, features_num - end_len,
batch_len):
batch = resnet_reid.get_test_image_batch(
batch_index, batch_len, train_flags.id_image_path,
'valid', gallery_flag)
batch_feature = sess.run(resnet_reid.output,
feed_dict={
input_batch: batch,
train_mode: False
})
features[batch_index:batch_index +
batch_len, :] = batch_feature
print(batch_name + str(batch_index) + '-' +
str(batch_index + batch_len - 1))
if end_len != 0:
batch_index += batch_len
batch = resnet_reid.get_test_image_batch(
batch_index, batch_len, train_flags.id_image_path,
'valid', gallery_flag)
batch_feature = sess.run(resnet_reid.output,
feed_dict={
input_batch: batch,
train_mode: False
})
features[batch_index:batch_index +
end_len, :] = batch_feature[:end_len]
print(batch_name + str(batch_index) + '-' +
str(batch_index + end_len - 1))
# save feature
features_npy_name = 'valid_gallery_features_step-%d.npy' if gallery_flag else 'valid_probe_features_step-%d.npy'
features_npy_path = os.path.join(
train_flags.output_test_features_path,
features_npy_name % step)
np.save(features_npy_path, features)
valid(False)
valid(True)
sess.close()
def model_fn(features, labels, mode, params):
"""
This is a function for creating a computational tensorflow graph.
The function is in format required by tf.estimator.
"""
global INIT_FLAG
is_training = mode == tf.estimator.ModeKeys.TRAIN
logits = resnet_v2_50(features['images'],
num_classes=params['num_classes'],
is_training=is_training
#depth_multiplier=params['depth_multiplier']
)
predictions = {
'probabilities': tf.nn.softmax(logits, axis=1),
'classes': tf.argmax(logits, axis=1, output_type=tf.int32)
}
if mode == tf.estimator.ModeKeys.PREDICT:
export_outputs = tf.estimator.export.PredictOutput({
name: tf.identity(tensor, name)
for name, tensor in predictions.items()
})
return tf.estimator.EstimatorSpec(
mode,
predictions=predictions,
export_outputs={'outputs': export_outputs})
init_fn = None
if INIT_FLAG:
exclude = [
'global_step:0'
] #,'classifier/biases:0','classifier/weights:0'] # ['ShuffleNetV2/Conv1/weights:0','global_step:0','classifier/biases:0','classifier/weights:0'
#]
all_variables = tf.contrib.slim.get_variables_to_restore()
varialbes_to_use = []
num_params = 0
for v in all_variables:
shape = v.get_shape()
num_params += reduce(mul, [dim.value for dim in shape], 1)
if v.name not in exclude:
varialbes_to_use.append(v)
init_fn = tf.contrib.framework.assign_from_checkpoint_fn(
tf.train.latest_checkpoint('models/jiu-huan_0.33_9967'),
varialbes_to_use,
ignore_missing_vars=True)
print('***********************params: ', num_params)
with tf.name_scope('weight_decay'):
add_weight_decay(params['weight_decay'])
regularization_loss = tf.losses.get_regularization_loss()
with tf.name_scope('cross_entropy'):
losses = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels['labels'], logits=logits)
loss = tf.reduce_mean(losses, axis=0)
tf.losses.add_loss(loss)
total_loss = tf.losses.get_total_loss(add_regularization_losses=True)
tf.summary.scalar('cross_entropy_loss', loss)
tf.summary.scalar('regularization_loss', regularization_loss)
if mode == tf.estimator.ModeKeys.EVAL:
eval_metric_ops = {
'accuracy':
tf.metrics.accuracy(labels['labels'], predictions['classes']),
'top5_accuracy':
tf.metrics.mean(
tf.to_float(
tf.nn.in_top_k(predictions=predictions['probabilities'],
targets=labels['labels'],
k=5)))
}
return tf.estimator.EstimatorSpec(mode,
loss=total_loss,
eval_metric_ops=eval_metric_ops)
assert mode == tf.estimator.ModeKeys.TRAIN
with tf.variable_scope('learning_rate'):
global_step = tf.train.get_global_step()
learning_rate = tf.train.polynomial_decay(
params['initial_learning_rate'],
global_step,
params['decay_steps'],
params['end_learning_rate'],
power=1.0) # linear decay
tf.summary.scalar('learning_rate', learning_rate)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops), tf.variable_scope('optimizer'):
optimizer = tf.train.MomentumOptimizer(learning_rate,
momentum=MOMENTUM,
use_nesterov=USE_NESTEROV)
grads_and_vars = optimizer.compute_gradients(total_loss)
train_op = optimizer.apply_gradients(grads_and_vars, global_step)
for g, v in grads_and_vars:
tf.summary.histogram(v.name[:-2] + '_hist', v)
tf.summary.histogram(v.name[:-2] + '_grad_hist', g)
with tf.name_scope('evaluation_ops'):
train_accuracy = tf.reduce_mean(tf.to_float(
tf.equal(labels['labels'], predictions['classes'])),
axis=0)
train_top5_accuracy = tf.reduce_mean(tf.to_float(
tf.nn.in_top_k(predictions=predictions['probabilities'],
targets=labels['labels'],
k=5)),
axis=0)
tf.summary.scalar('train_accuracy', train_accuracy)
tf.summary.scalar('train_top5_accuracy', train_top5_accuracy)
with tf.control_dependencies([train_op]), tf.name_scope('ema'):
ema = tf.train.ExponentialMovingAverage(decay=MOVING_AVERAGE_DECAY,
num_updates=0)
train_op = ema.apply(tf.trainable_variables())
if INIT_FLAG:
INIT_FLAG = False
return tf.estimator.EstimatorSpec(
mode,
loss=total_loss,
train_op=train_op,
training_hooks=[RestoreHook(init_fn)])
else:
return tf.estimator.EstimatorSpec(mode,
loss=total_loss,
train_op=train_op)
def build_refinenet(inputs, num_classes, preset_model='RefineNet-Res101', weight_decay=1e-5, is_training=True, upscaling_method="bilinear", pretrained_dir="models"):
"""
Builds the RefineNet model.
Arguments:
inputs: The input tensor
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
Returns:
RefineNet model
"""
if preset_model == 'RefineNet-Res50':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_50(inputs, is_training=is_training, scope='resnet_v2_50')
# RefineNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50'))
elif preset_model == 'RefineNet-Res101':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_101(inputs, is_training=is_training, scope='resnet_v2_101')
# RefineNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101'))
elif preset_model == 'RefineNet-Res152':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits, end_points = resnet_v2.resnet_v2_152(inputs, is_training=is_training, scope='resnet_v2_152')
# RefineNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152'))
else:
raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 101 and ResNet 152" % (preset_model))
high = [end_points['pool5'], end_points['pool4'],
end_points['pool3'], end_points['pool2']]
low = [None, None, None, None]
# Get the feature maps to the proper size with bottleneck
high[0]=slim.conv2d(high[0], 512, 1)
high[1]=slim.conv2d(high[1], 256, 1)
high[2]=slim.conv2d(high[2], 256, 1)
high[3]=slim.conv2d(high[3], 256, 1)
# RefineNet
low[0]=RefineBlock(high_inputs=high[0],low_inputs=None) # Only input ResNet 1/32
low[1]=RefineBlock(high[1],low[0]) # High input = ResNet 1/16, Low input = Previous 1/16
low[2]=RefineBlock(high[2],low[1]) # High input = ResNet 1/8, Low input = Previous 1/8
low[3]=RefineBlock(high[3],low[2]) # High input = ResNet 1/4, Low input = Previous 1/4
# g[3]=Upsampling(g[3],scale=4)
net = low[3]
net = ResidualConvUnit(net)
net = ResidualConvUnit(net)
if upscaling_method.lower() == "conv":
net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 128)
net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2)
net = ConvBlock(net, 64)
elif upscaling_method.lower() == "bilinear":
net = Upsampling(net, scale=4)
net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits')
return net, init_fn
shape=[1, size, size, 3],
dtype=tf.float32)
input_image = tf.placeholder(shape=[None, 28, 28, 1], dtype=tf.float32)
channel_image = tf.concat([input_image, input_image, input_image],
axis=-1)
rgb_image = tf.pad(tf.concat([input_image, input_image, input_image],
axis=-1),
paddings=tf.constant([[0, 0], [136, 135],
[136, 135], [0, 0]]))
adv_image = tf.nn.tanh(tf.multiply(weights, mask)) + rgb_image
labels = tf.placeholder(tf.float32, shape=[None, 10])
logits, _ = resnet_v2_50(adv_image,
num_classes=1001,
is_training=False)
output_mapping_tensor = tf.constant(output_mapping, dtype=tf.float32)
new_logits = tf.matmul(logits, output_mapping_tensor)
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(
logits=new_logits,
labels=labels)) + reg_lambda * tf.nn.l2_loss(weights)
learning_rate = tf.train.exponential_decay(starter_learning_rate,
global_step,
decay_steps,
decay_rate,
staircase=True)
def build_icnet(inputs, label_size, num_classes, preset_model='ICNet-Res50', pooling_type = "MAX",
weight_decay=1e-5, is_training=True, pretrained_dir="models"):
"""
Builds the ICNet model.
Arguments:
inputs: The input tensor
label_size: Size of the final label tensor. We need to know this for proper upscaling
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
pooling_type: Max or Average pooling
Returns:
ICNet model
"""
inputs_4 = tf.image.resize_bilinear(inputs, size=[tf.shape(inputs)[1]*4, tf.shape(inputs)[2]*4])
inputs_2 = tf.image.resize_bilinear(inputs, size=[tf.shape(inputs)[1]*2, tf.shape(inputs)[2]*2])
inputs_1 = inputs
if preset_model == 'ICNet-Res50':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits_32, end_points_32 = resnet_v2.resnet_v2_50(inputs_4, is_training=is_training, scope='resnet_v2_50')
logits_16, end_points_16 = resnet_v2.resnet_v2_50(inputs_2, is_training=is_training, scope='resnet_v2_50')
logits_8, end_points_8 = resnet_v2.resnet_v2_50(inputs_1, is_training=is_training, scope='resnet_v2_50')
resnet_scope='resnet_v2_50'
# ICNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50'))
elif preset_model == 'ICNet-Res101':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits_32, end_points_32 = resnet_v2.resnet_v2_101(inputs_4, is_training=is_training, scope='resnet_v2_101')
logits_16, end_points_16 = resnet_v2.resnet_v2_101(inputs_2, is_training=is_training, scope='resnet_v2_101')
logits_8, end_points_8 = resnet_v2.resnet_v2_101(inputs_1, is_training=is_training, scope='resnet_v2_101')
resnet_scope='resnet_v2_101'
# ICNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101'))
elif preset_model == 'ICNet-Res152':
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)):
logits_32, end_points_32 = resnet_v2.resnet_v2_152(inputs_4, is_training=is_training, scope='resnet_v2_152')
logits_16, end_points_16 = resnet_v2.resnet_v2_152(inputs_2, is_training=is_training, scope='resnet_v2_152')
logits_8, end_points_8 = resnet_v2.resnet_v2_152(inputs_1, is_training=is_training, scope='resnet_v2_152')
resnet_scope='resnet_v2_152'
# ICNet requires pre-trained ResNet weights
init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152'))
else:
raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152" % (preset_model))
feature_map_shape = [int(x / 32.0) for x in label_size]
block_32 = PyramidPoolingModule(end_points_32['pool3'], feature_map_shape=feature_map_shape, pooling_type=pooling_type)
out_16, block_16 = CFFBlock(psp_32, end_points_16['pool3'])
out_8, block_8 = CFFBlock(block_16, end_points_8['pool3'])
out_4 = Upsampling_by_scale(out_8, scale=2)
out_4 = slim.conv2d(out_4, num_classes, [1, 1], activation_fn=None)
out_full = Upsampling_by_scale(out_4, scale=2)
out_full = slim.conv2d(out_full, num_classes, [1, 1], activation_fn=None, scope='logits')
net = tf.concat([out_16, out_8, out_4, out_final])
return net, init_fn
def run_training():
train_dir = 'G:/kaggel-cancer-detection/train_jpg/'
logs_train_dir = 'G:/kaggel-cancer-detection-code/SaveNet-ResNet/'
# 获取图片和标签集
train, train_label = input_data.get_files(train_dir)
# 生成批次
train_batch, train_label_batch = input_data.get_batch(
train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(
learning_rate=starter_learning_rate,
global_step=global_step,
decay_steps=steps_per_decay,
decay_rate=decay_factor,
staircase=True, #If `True` decay the learning rate at discrete intervals
#staircase = False,change learning rate at every step
)
print("Enter Model！")
train_logits, end_points = resnet_v2.resnet_v2_50(inputs=train_batch,
num_classes=N_CLASSES)
print("Get loss!")
train_loss = losses(train_logits, train_label_batch)
print("Start training!")
train_op = trainning(train_loss, learning_rate, global_step)
print("Get Acc!")
train__acc = evaluation(train_logits, train_label_batch)
summary_op = tf.summary.merge_all()
#sess = tf.Session()
print("Save summary")
saver = tf.train.Saver()
with tf.Session() as sess:
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for step in np.arange(MAX_STEP):
if coord.should_stop():
print("break!!!")
break
_, tra_loss, tra_acc = sess.run([train_op, train_loss,
train__acc]) #训练
if sess.run(global_step) % 50 == 0:
print(
'Step %d, train loss = %.2f, learning rate = %.10f,train accuracy = %.2f%%'
% (sess.run(global_step), tra_loss,
sess.run(learning_rate), tra_acc * 100.0))
#print('global_step:',sess.run(global_step))
#print('learning rate:',sess.run(learning_rate))
summary_str = sess.run(summary_op)
train_writer.add_summary(summary_str, step)
if sess.run(global_step) % 2000 == 0 or (
sess.run(global_step)) == MAX_STEP:
checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
saver.save(sess,
checkpoint_path,
global_step=sess.run(global_step))
coord.join(threads)
sess.close()
