def resnet_v2_50(init_weights):
tf_compat.reset_default_graph()
image_size = 224
inputs = tf_compat.random_normal([1, image_size, image_size, 3])
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, _ = resnet_v2.resnet_v2_50(inputs, 1000, is_training=False)
return tf_compat.get_default_graph()
def resnet_50(inputs, is_training, num_classes):
logits, _ = resnet_v2.resnet_v2_50(inputs,
num_classes=num_classes,
is_training=is_training)
logits = tf.squeeze(logits,
[1, 2]) # resnet output is (N,1,1,C, remove the
return tf.identity(logits, name='logits')
def _ConvNet2D(self, x, is_training, reuse=False):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
f, _ = resnet_v2.resnet_v2_50(x,
num_classes=None,
is_training=is_training,
global_pool=False,
reuse=reuse)
print("resnet.out.shape: %s" % f.get_shape())
with tf.variable_scope("ConvNet2D", reuse=reuse):
f = tf.reduce_mean(f, [1, 2],
name='global_avg_pooling',
keep_dims=True)
z = slim.conv2d(f,
4096, [1, 1],
padding='VALID',
normalizer_fn=None,
scope='f2zfeture')
z = slim.conv2d(z,
self.z_dim, [1, 1],
padding='VALID',
normalizer_fn=None,
scope='z_2d')
#g_feature = tf.squeeze(g_feature, [1, 2], name='global_spatial_squeeze')
return tf.expand_dims(z, 1)
def load(self, **kwargs):
session = kwargs["session"]
assert isinstance(session, tf.Session)
x_input = tf.placeholder(tf.float32, shape=(None, ) + self.x_shape)
with tf.contrib.framework.arg_scope(resnet_v2.resnet_arg_scope()):
logits, _ = resnet_v2.resnet_v2_50(x_input,
self.n_class,
is_training=False,
reuse=tf.AUTO_REUSE)
model_path = get_model_path('alp')
url = 'http://download.tensorflow.org/models/adversarial_logit_pairing/imagenet64_alp025_2018_06_26.ckpt.tar.gz'
fname = os.path.join(model_path, url.split('/')[-1])
if not os.path.exists(fname):
if not os.path.exists(model_path):
os.makedirs(model_path)
from six.moves import urllib
urllib.request.urlretrieve(url, fname, show_progress)
import tarfile
t = tarfile.open(fname)
t.extractall(model_path)
print('Extracted model')
saver = tf.train.Saver()
saver.restore(session, fname.split('.tar.gz')[0])
def featureExtractor(input,
feature_norm,
model='101',
reuse=False,
scope='resnet_v2_101'):
with tf.variable_scope(scope, reuse=reuse) as scope:
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
input = scale_RGB(input)
if '50' in model:
net, end_points = resnet_v2.resnet_v2_50(input,
global_pool=True,
is_training=False,
reuse=reuse)
elif '101' in model:
_, end_points = resnet_v2.resnet_v2_101(input,
global_pool=True,
is_training=False,
reuse=reuse)
#f = end_points['stabNet/pathFinder/featureExtractor/resnet_v2_101/block3/unit_23/bottleneck_v2/conv1'] #(18 X 32) X (18 X 32)
f = end_points[
'{}/resnet_v2_101/block4/unit_2/bottleneck_v2/conv1'.
format(scope.name)] #(9 X 16) X (9 X 16)
if feature_norm:
f = featureL2Norm(f)
return f
def main(_):
with tf.Graph().as_default():
url = 'https://upload.wikimedia.org/wikipedia/commons/5/5c/Tigershark3.jpg'
image_string = urllib.urlopen(url).read()
image = tf.image.decode_jpeg(image_string, channels=3)
processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False)
processed_images = tf.expand_dims(processed_image, 0)
# Create the model, use the default arg scope to configure the batch norm parameters.
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, _ = resnet_v2.resnet_v2_50(processed_images, num_classes=1001, is_training=False)
probabilities = tf.nn.softmax(logits)
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(checkpoints_dir, 'resnet_v2_50.ckpt'),
slim.get_model_variables('resnet_v2_50'))
with tf.Session() as sess:
init_fn(sess)
np_image, probabilities = sess.run([image, probabilities])
probabilities = np.reshape(probabilities, [1001])
print(probabilities.shape)
sorted_inds = [i[0] for i in sorted(enumerate(-probabilities), key=lambda x: x[1])]
print(sorted_inds)
plt.figure()
plt.imshow(np_image.astype(np.uint8))
plt.axis('off')
plt.show()
names = imagenet.create_readable_names_for_imagenet_labels()
for i in range(5):
index = sorted_inds[i]
# Shift the index of a class name by one.
print('Probability %0.6f%% => [%s]' % (probabilities[index] * 100, names[index + 1]))
def PSPNet(inputs, num_classes, is_training, reuse=None):
'''A TensorFlow implementation of PSPNet model based on
https://github.com/hszhao/PSPNet/tree/master/evaluation/prototxt
Args:
inputs: A 4-D tensor with dimensions [batch_size, height, width, channels]
num_classes: Integer, the total number of categories in the dataset
is_training : Bool, whether to updates the running means and variances during the training.
Returns:
A feature map with dimensions [batch_size, 1/8*height, 1/8*width, 512]
'''
with slim.arg_scope(resnet_utils.resnet_arg_scope()):
net, end_points = resnet_v2.resnet_v2_50(inputs,
num_classes=None,
is_training=is_training,
global_pool=False,
output_stride=8,
reuse=reuse,
scope='resnet_v2_50')
with tf.variable_scope("PSPNet", reuse=reuse) as sc:
shape = tf.shape(net)[1:3]
net = PyramidPoolingModule(net, shape=shape)
net = slim.conv2d(net, 512, [3, 3], activation_fn=None, scope='conv5')
net = slim.batch_norm(net, fused=True, scope='conv5_bn')
net = tf.nn.relu(net, name='conv5_bn_relu')
return net, end_points
def get_resnet(x_tensor, reuse, is_training, x_batch_size):
with tf.variable_scope('resnet', reuse=reuse):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
resnet, end_points = resnet_v2.resnet_v2_50(
x_tensor,
global_pool=False,
is_training=is_training,
reuse=reuse,
output_stride=32)
global_pool = tf.reduce_mean(resnet, [1, 2])
with tf.variable_scope('fc'):
global_pool = slim.fully_connected(global_pool,
2048,
scope='fc/fc_1')
global_pool = slim.fully_connected(global_pool,
1024,
scope='fc/fc_2')
global_pool = slim.fully_connected(global_pool,
512,
scope='fc/fc_3')
theta = output_layer(global_pool, (grid_h + 1) * (grid_w + 1) * 2)
with tf.name_scope('gen_theta'):
id2_loss = tf.reduce_mean(tf.abs(theta)) * id_mul
return theta, id2_loss, id2_loss
def yolonet(images, is_training=True):
with tf.Graph().as_default():
tf.logging.set_verbosity(tf.logging.INFO)
output_depth = NUM_CLASS + 5 * BOX_PER_CELL
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
bottleneck, _ = resnet_v2.resnet_v2_50(images,
global_pool=False,
is_training=is_training)
with arg_scope([layers.batch_norm], is_training=is_training):
net = bottleneck
net = layers_lib.conv2d(net,
512, [1, 1],
normalizer_fn=layers.batch_norm,
scope='yolo_layer1')
net = layers_lib.conv2d(net,
512, [3, 3],
normalizer_fn=layers.batch_norm,
scope='yolo_layer2')
net = layers_lib.conv2d(net,
512, [3, 3],
normalizer_fn=layers.batch_norm,
scope='yolo_layer3')
net = layers_lib.conv2d(net,
output_depth, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope='yolo_output')
return net
def resnet_inference(inputs, is_train=True):
x = tf.reshape(inputs, [FLAGS.batch_size, 64, 64, 1])
with slim.arg_scope(resnet_arg_scope(is_training=(MODE == "train"))):
net, enpoints = resnet_v2.resnet_v2_50(
x, num_classes=FLAGS.label_size)
net = tf.reshape(net, [FLAGS.batch_size, FLAGS.label_size])
return net
def main(_):
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
num_classes = 1001
itr = 30
a = FLAGS.input_dir
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
img_resize_tensor = tf.placeholder(tf.int32, [2])
x_input_resize = tf.image.resize_images(
x_input,
img_resize_tensor,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
shape_tensor = tf.placeholder(tf.int32, [3])
padded_input = padding_layer_iyswim(x_input_resize, shape_tensor)
# 330 is the last value to keep 8*8 output, 362 is the last value to keep 9*9 output, stride = 32
padded_input.set_shape(
(FLAGS.batch_size, FLAGS.image_resize, FLAGS.image_resize, 3))
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
net, end_points = resnet_v2.resnet_v2_50(x_input,
num_classes=num_classes,
is_training=False)
predicted_labels = tf.argmax(end_points['predictions'], 3)
# Run computation
saver = tf.train.Saver(slim.get_model_variables())
session_creator = tf.train.ChiefSessionCreator(
scaffold=tf.train.Scaffold(saver=saver),
checkpoint_filename_with_path=FLAGS.checkpoint_path,
master=FLAGS.master)
with tf.train.MonitoredSession(
session_creator=session_creator) as sess:
with tf.gfile.Open(FLAGS.output_file, 'w') as out_file:
for filenames, images in load_images(FLAGS.input_dir,
batch_shape):
if np.random.randint(0, 2, size=1) == 1:
images = images[:, :, ::-1, :]
resize_shape_ = np.random.randint(310, 331)
labels = sess.run(
predicted_labels,
feed_dict={
x_input:
images,
img_resize_tensor: [resize_shape_] * 2,
shape_tensor:
np.array([
random.randint(
0, FLAGS.image_resize - resize_shape_),
random.randint(
0, FLAGS.image_resize - resize_shape_),
FLAGS.image_resize
])
})
labels = labels.flatten()
for filename, label in zip(filenames, labels):
out_file.write('{0},{1}\n'.format(filename, label))
def built_network(self, inputs, is_training, dropout_rate):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
net, end_points = resnet_v2.resnet_v2_50(inputs,
self.opt.num_classes,
is_training=is_training)
net = tf.squeeze(net, axis=[1, 2])
return net
def built_network(self, inputs1, inputs2, is_training=False):
inputs = tf.concat([inputs1, inputs2], axis=0)
with tf.variable_scope("Seg"):
with tf.contrib.slim.arg_scope(
resnet_v2.resnet_arg_scope(
batch_norm_decay=_BATCH_NORM_DECAY)):
logits, end_points = resnet_v2.resnet_v2_50(
inputs, is_training=is_training)
return end_points
def build(self):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, self.endpoints = resnet_v2.resnet_v2_50(
self.inputs['images'],
num_classes=self.num_classes,
is_training=self.is_training)
self.outputs['logits'] = tf.reshape(logits, [-1, self.num_classes])
self.outputs['argmax'] = tf.argmax(self.outputs['logits'],
axis=1,
name='output/predict')
def __init__(self, inputs, true_labels, is_train=False, num_classes=None):
self.true_labels = true_labels
self.NUM_CLASSES = num_classes
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
self.output, self.features = resnet_v2.resnet_v2_50(
inputs=inputs, num_classes=None, is_training=False)
self.classifier, _ = cnn.fc(input=self.forward_pass(),
num_outputs=self.NUM_CLASSES,
use_relu=False,
name='classifier')
def _resnet50(input_img, training=True, embedding_size=64, dropout_keep_prob=0.5, middleRepr=False):
with tf.variable_scope('resnet', reuse=tf.AUTO_REUSE):
logits, _ = resnet_v2.resnet_v2_50(input_img, is_training=training) # ?x1x1x2048
if middleRepr:
return tf.squeeze(logits, [1,2])
logits = conv2d(logits, embedding_size, [1, 1], activation_fn=None,
normalizer_fn=None, scope='logits')
logits = tf.squeeze(logits, [1, 2])
return logits
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(resnet_v2.resnet_utils.resnet_arg_scope()):
_, end_points = resnet_v2.resnet_v2_50(
x_input, num_classes=self.num_classes, reuse=reuse)
self.built = True
output = end_points['Predictions']
# Strip off the extra reshape op at the output
probs = output.op.inputs[0]
return probs
def cnn_model_fn(features, labels, mode):
"""Model function for CNN."""
# Input Layer
# Reshape X to 4-D tensor: [batch_size, width, height, channels]
# MNIST images are 28x28 pixels, and have one color channel
# tf.logging.info(features)
input_layer = tf.reshape(features, [-1, 224, 224, 1])
net, end_points = resnet_v2.resnet_v2_50(input_layer, 33)
net = tf.squeeze(net, axis=[1, 2])
logits = slim.fully_connected(net,
num_outputs=33,
activation_fn=None,
scope='train')
slim.losses.sparse_softmax_cross_entropy(logits=logits,
labels=labels,
scope='Loss')
loss = slim.losses.get_total_loss()
predictions = {
# Generate predictions (for PREDICT and EVAL mode)
"classes": tf.argmax(input=logits, axis=1),
# Add `softmax_tensor` to the graph. It is used for PREDICT and by the
# `logging_hook`.
"probabilities": tf.nn.softmax(logits, name="softmax_tensor")
}
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
# Calculate Loss (for both TRAIN and EVAL modes)
# tf.logging.info(labels)
# onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=32)
# Configure the Training Op (for TRAIN mode)
if mode == tf.estimator.ModeKeys.TRAIN:
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001)
train_op = slim.learning.create_train_op(loss,
optimizer,
summarize_gradients=True)
return tf.estimator.EstimatorSpec(mode=mode,
train_op=train_op,
loss=loss)
# Add evaluation metrics (for EVAL mode)
eval_metric_ops = {
"accuracy":
tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])
}
return tf.estimator.EstimatorSpec(mode=mode,
loss=loss,
eval_metric_ops=eval_metric_ops)
def resnet50(inputs, num_classes, is_training, global_pool = True):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, end_points = resnet_v2.resnet_v2_50(inputs,
num_classes,
global_pool = global_pool,
reuse=tf.AUTO_REUSE)
predictions = {
"classes": tf.argmax(logits, axis=1),
"probabilities": end_points["predictions"]
}
return logits, predictions
def resnet_layers(input, output_stride=8, training=True):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
_, endpoint = resnet_v2.resnet_v2_50(inputs=input,
output_stride=output_stride,
is_training=training)
conv_feat = tf.squeeze(endpoint['resnet_v2_50/block4'],
axis=0,
name='conv_feat')
return conv_feat
def logits_and_labels(self, xs_ph):
xs_ph = xs_ph * 2.0 - 1.0
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, _ = resnet_v2.resnet_v2_50(xs_ph,
self.n_class,
is_training=False,
reuse=tf.AUTO_REUSE)
logits = tf.squeeze(logits, [1, 2])
predicts = tf.nn.softmax(logits)
predicted_labels = tf.argmax(predicts, 1)
return logits, predicted_labels
def __init__(self,
sess,
inputs,
labels,
stage_of_development,
model_path,
num_of_classes,
min_bins=None,
max_bins=None):
#self.resnet = tf.contrib.slim
self.batch_inputs = tf.reshape(tf.cast(inputs, tf.float32), [-1, 224, 224, 3])
self.stage_of_development = stage_of_development
self.model_path = model_path
self.labels = tf.reshape(tf.cast(labels, tf.float32), [-1, 1])
self.num_of_classes = num_of_classes
print(stage_of_development=="training")
with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=0.0001)):
self.logits, _ = resnet_v2.resnet_v2_50(self.batch_inputs, num_classes=self.num_of_classes, is_training=stage_of_development=="training", scope='resnet_v2_50')
# Specify where the model checkpoint is (pretrained weights).
self.model_path = model_path
# Restore only the layers up to "logits" (included)
# Calling function `init_fn(sess)` will load all the pretrained weights.
self.variables_to_restore = tf.contrib.framework.get_variables_to_restore(exclude=['resnet_v2_50/logits'])
print("ResNet 50 - VARIABLES TO RESTORE", self.variables_to_restore)
self.init_fn = tf.contrib.framework.assign_from_checkpoint_fn(self.model_path, self.variables_to_restore)
# Initialization operation from scratch for the new "logits" layers
# `get_variables` will only return the variables whose name starts with the given pattern
self.logits_variables = tf.contrib.framework.get_variables('resnet_v2_50/logits')
self.logits_init = tf.variables_initializer(self.logits_variables)
# ---------------------------------------------------------------------
# Using tf.losses, any loss is added to the tf.GraphKeys.LOSSES collection
# We can then call the total loss easily
self.logits = tf.reshape(tf.nn.relu(self.logits), [-1, num_of_classes])
self.validation_logits = tf.reshape(tf.nn.relu(self.logits), [-1, num_of_classes])
if self.num_of_classes == 1:
self.predictions = self.logits
self.validation_predictions = self.validation_logits
else:
self.predictions = tf.reshape(tf.cast(tf.argmax(self.logits, 1), tf.float32), [-1, 1])
self.validation_predictions = tf.reshape(tf.cast(tf.argmax(self.validation_predictions, 1), tf.float32), [-1, 1])
self.all_variables = tf.trainable_variables()
self.variables_trained_from_scratch = self.logits_variables
print("ResNet - ALL VARIABLES: ", self.all_variables)
print("ResNet - VARIABLES TRAINED FROM SCRATCH: ", self.variables_trained_from_scratch)
def main(_):
# download and conver flower_photos dataset to tfrecord
download_dataset.maybe_download_and_extract(FLOWERS_DATA_DIR, _DATA_URL)
convert_flowers_to_tfrecord.run(FLOWERS_DATA_DIR)
with tf.Graph().as_default() as g:
tf.logging.set_verbosity(tf.logging.INFO)
dataset = flowers.get_split('train', FLOWERS_DATA_DIR)
images, _, labels = load_batch(dataset,
batch_size=BATCH_SIZE,
is_training=True)
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, _ = resnet_v2.resnet_v2_50(images,
num_classes=dataset.num_classes,
is_training=True)
logits = tf.squeeze(tf.convert_to_tensor(logits, tf.float32))
one_hot_labels = slim.one_hot_encoding(labels, dataset.num_classes)
loss = tf.losses.softmax_cross_entropy(onehot_labels=one_hot_labels,
logits=logits)
slim.losses.add_loss(loss)
total_loss = slim.losses.get_total_loss()
tf.summary.scalar('losses/total_loss', total_loss)
# 梯度根性只更新最后一层
var2training = slim.get_trainable_variables(
scope="resnet_v2_50/logits")
optimizer = tf.train.AdamOptimizer()
train_op = slim.learning.create_train_op(
total_loss, optimizer, variables_to_train=var2training)
init_fn = get_init_fn(
checkpoint_exclude_scopes=CHECKPOINT_EXCLUDE_SCOPES,
checkpoint_dir=PRETRAIN_DIR)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
print("start training")
final_loss = slim.learning.train(train_op,
logdir=TRAIN_DIR,
init_fn=init_fn,
number_of_steps=NUMBER_OF_STEPS,
trace_every_n_steps=500,
log_every_n_steps=50,
session_config=config,
save_interval_secs=60)
print('Finished training. Last batch loss %f' % final_loss)
def convolutional_model(self, num_images, images, img_indices, training):
with tf.variable_scope('cnn/resnet', reuse=tf.AUTO_REUSE):
bs = tf.shape(images)[0]
imgsize = [224, 224]
# Flatten and cast to float
images = tf.reshape(
images, [-1, imgsize[0], imgsize[1], 1
]) # num images x img_height x img_width x channels
images = tf.cast(images, dtype=tf.float32)
# Run through ResNet
logits, _ = resnet_v2.resnet_v2_50(
images, is_training=training) # ?x1x1x2048
logits = conv2d(inputs=logits,
num_outputs=self.FLAGS.cnn_size,
kernel_size=[1, 1],
activation_fn=None,
normalizer_fn=None,
scope='logits')
if not self.FLAGS.finetuning_cnn:
logits = tf.stop_gradient(logits)
logits = tf.reshape(logits, [bs, -1, self.FLAGS.cnn_size])
# Add first 0 logits, not yet an image available
logits_0 = tf.concat([tf.zeros_like(logits[:, :1]), logits],
axis=1)
# propagate logits to the corresponding input (input el has last used snapshot img logits)
# bs x num_snapshots x logit_size ---> bs x max_seqlen x logit_size
def _propagate(logits, indices):
bs = tf.shape(logits)[0]
# prepare indices to get the correct logits
bs_ind = tf.range(bs)
bs_ind = tf.tile(bs_ind[:, None], [1, self.max_seqlen])
tog_ind = tf.stack([bs_ind, indices], axis=2)
tog_ind = tf.reshape(tog_ind, (-1, 2))
# gather imgs from indices
out = tf.gather_nd(logits, tog_ind)
return tf.reshape(out,
(bs, self.max_seqlen, self.FLAGS.cnn_size))
output_dict = {
'last_img_logits':
batch_gather(logits,
num_images), # img logits for finished sketches
'all_padded_img_logits': logits
} # img logits for snapshot images
if self.max_seqlen: # at every sketch point, corresponding img logits
output_dict.update(
{'sketch_img_logits': _propagate(logits_0, img_indices)})
return output_dict
def build_resnet(images_tn, num_classes, is_training):
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
resnet_logits, end_points = resnet_v2.resnet_v2_50(
images_tn, is_training=is_training)
resnet_init_fn = slim.assign_from_checkpoint_fn(
checkpoint_file, [var for var in tf.global_variables()])
with tf.variable_scope('ClassificationPart'):
resnet_flat = tf.layers.flatten(resnet_logits)
dense2 = tf.layers.dense(resnet_flat, 1024, activation=tf.nn.relu)
dropout2 = tf.layers.dropout(dense2, 0.75, training=is_training)
logits = tf.layers.dense(dropout2, num_classes, activation=tf.nn.relu)
return resnet_init_fn, logits
def net(self):
#This function is finished.
#Try to figure out what endpoints are and why they might be useful.
#This creates your model architecture, a 50 layer resnet.
net, end_points = resnet_v2.resnet_v2_50(
self.inputs,
num_classes=self.num_classes,
is_training=self.is_train,
global_pool=True, #check out this global pooling ;)
output_stride=None,
reuse=tf.AUTO_REUSE,
scope="resnet_v2_50"
)
return net, end_points
def main(_):
with tf.Graph().as_default() as g:
tf.logging.set_verbosity(tf.logging.INFO)
dataset = flowers.get_split(VAL, FLOWERS_DATA_DIR)
images, images_raw, labels = load_batch(dataset,
batch_size=BATCH_SIZE,
height=IMAGE_SIZE,
width=IMAGE_SIZE,
is_training=False,
shuffle=False)
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, _ = resnet_v2.resnet_v2_50(images,
num_classes=dataset.num_classes,
is_training=False)
logits = tf.squeeze(tf.convert_to_tensor(logits, tf.float32))
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
with slim.queues.QueueRunners(sess):
writer = tf.summary.FileWriter(EVAL_DIR, g)
step = 0
num_iter = int(np.ceil(NUM_VALIDATION / BATCH_SIZE))
total_sample_count = num_iter * BATCH_SIZE
while step < 100:
true_count = 0
# sess.run(tf.local_variables_initializer())
checkpoint_name = tf.train.latest_checkpoint(TRAIN_DIR)
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(TRAIN_DIR, checkpoint_name),
slim.get_model_variables())
init_fn(sess)
top_k_op = tf.nn.in_top_k(logits, labels, 1)
for _ in range(num_iter):
predictions = sess.run([top_k_op])
true_count += np.sum(predictions)
step += 1
precision = true_count / total_sample_count
tf.summary.scalar("precision", precision)
print('%s: accuracy = %.3f' % (datetime.now(), precision))
step += 1
time.sleep(5)
writer.close()
def Resnet(inputs,
scope='Resnet',
class_number=65,
is_training=True,
reuse=False,
batch_size=128,
dropout_ratio=1.0):
#with tf.variable_scope(scope,reuse=reuse):
#net,end_points=resnet50v1.resnet_v1_50(inputs,is_training=is_training,scope=scope,reuse=reuse)
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
net, end_points = resnet_v2.resnet_v2_50(inputs,
is_training=is_training,
reuse=reuse)
net = tf.squeeze(net, [1, 2])
return net
def backend_resnet50_v2_slim(x_input):
BATCH_SIZE, NUM_FRAMES, HEIGHT, WIDTH, NUM_CHANNELS = x_input.get_shape(
).as_list()
# RESNET
video_input = tf.reshape(
x_input, (BATCH_SIZE * NUM_FRAMES, HEIGHT, WIDTH, NUM_CHANNELS))
features, end_points = resnet_v2.resnet_v2_50(video_input, num_classes=512)
# features, end_points = resnet_v2.resnet_v1_50(video_input, None)
features = tf.reshape(
features, (BATCH_SIZE, NUM_FRAMES, int(features.get_shape()[3])))
print("shape after resnet is %s" % features.get_shape())
return features
def __call__(self, x_input, return_logits=False):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
_, end_points = resnet_v2.resnet_v2_50(
x_input, num_classes=self.num_classes, is_training=False,
reuse=reuse)
self.built = True
self.logits = end_points['resnet_v2_50/logits']
output = end_points['predictions']
# Strip off the extra reshape op at the output
self.probs = output.op.inputs[0]
if return_logits:
return self.logits
else:
return self.probs
def build(self, images):
"""Builds a ResNet50 embedder for the input images.
It assumes that the range of the pixel values in the images tensor is
[0,255] and should be castable to tf.uint8.
Args:
images: a tensor that contains the input images which has the shape of
NxTxHxWx3 where N is the batch size, T is the maximum length of the
sequence, H and W are the height and width of the images and C is the
number of channels.
Returns:
The embedding of the input image with the shape of NxTxL where L is the
embedding size of the output.
Raises:
ValueError: if the shape of the input does not agree with the expected
shape explained in the Args section.
"""
shape = images.get_shape().as_list()
if len(shape) != 5:
raise ValueError(
'The tensor shape should have 5 elements, {} is provided'.format(
len(shape)))
if shape[4] != 3:
raise ValueError('Three channels are expected for the input image')
images = tf.cast(images, tf.uint8)
images = tf.reshape(images,
[shape[0] * shape[1], shape[2], shape[3], shape[4]])
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
def preprocess_fn(x):
x = tf.expand_dims(x, 0)
x = tf.image.resize_bilinear(x, [299, 299],
align_corners=False)
return(tf.squeeze(x, [0]))
images = tf.map_fn(preprocess_fn, images, dtype=tf.float32)
net, _ = resnet_v2.resnet_v2_50(
images, is_training=False, global_pool=True)
output = tf.reshape(net, [shape[0], shape[1], -1])
return output
