def testBatchNormScopeDoesHasIsTrainingWhenItsNotNone(self):
global numbers
numbers += 1
print('testBatchNormScopeDoesHasIsTrainingWhenItsNotNone: ',numbers)
sc = mobilenet_v1.mobilenet_v1_arg_scope(is_training=True)
self.assertIn('is_training', sc[slim.arg_scope_func_key(slim.batch_norm)])
sc = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False)
self.assertIn('is_training', sc[slim.arg_scope_func_key(slim.batch_norm)])
sc = mobilenet_v1.mobilenet_v1_arg_scope()
self.assertIn('is_training', sc[slim.arg_scope_func_key(slim.batch_norm)])
def build_model():
"""Build the mobilenet_v1 model for evaluation.
Returns:
g: graph with rewrites after insertion of quantization ops and batch norm
folding.
eval_ops: eval ops for inference.
variables_to_restore: List of variables to restore from checkpoint.
"""
g = tf.Graph()
with g.as_default():
# inputs, labels = imagenet_input(is_training=False)
inputs = np.random.randint(0, 255, size=(1,224,224,3))
labels = np.random.randint(0, 10, size=(1,10))
inputs = tf.Variable(inputs,dtype=tf.float32)
labels = tf.Variable(labels,dtype=tf.float32)
scope = mobilenet_v1.mobilenet_v1_arg_scope(
is_training=False, weight_decay=0.0)
with slim.arg_scope(scope):
logits, _ = mobilenet_v1.mobilenet_v1(
inputs,
is_training=False,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes)
if FLAGS.quantize:
tf.contrib.quantize.create_eval_graph()
eval_ops = metrics(logits, labels)
return g, eval_ops
def visual_modulator_lite(guide_image,
model_params,
scope='osmn',
is_training=False):
"""Defines the visual modulator
Args:
gudie_image: visual guide image
model_params: parameters related to model structure
scope: scope name for the network
is_training: training or testing
Returns:
Tensor of the visual modulation parameters
"""
mod_early_conv = model_params.mod_early_conv
n_modulator_param = [128, 256, 512, 1024] # 1024 + 512 + 256 + 128
with tf.variable_scope(scope, [guide_image]) as sc, \
slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope(is_training=is_training)) as arg_sc:
modulator_params = None
# Collect outputs of all intermediate layers.
modulator_params, end_points = mobilenet_v1.mobilenet_v1(
guide_image,
scope='modulator',
num_classes=n_modulator_param,
spatial_squeeze=False,
is_training=is_training)
return modulator_params
def run():
image_size = 224
num_classes = 200
logdir = './log'
checkpoint_file = tf.train.latest_checkpoint(logdir)
with tf.Graph().as_default() as graph:
images = tf.placeholder("float", [1, image_size, image_size, 3], name="input")
#images = tf.placeholder(shape=[1, image_size, image_size, 3], dtype=tf.float32, name = 'Placeholder_only')
with slim.arg_scope(mobilenet_v1_arg_scope()):
logits, end_points = mobilenet_v1(images, num_classes = num_classes, is_training = False)
variables_to_restore = slim.get_variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
#Setup graph def
input_graph_def = graph.as_graph_def()
output_node_names = "MobilenetV1/Predictions/Softmax"
output_graph_name = "./frozen_model_mobilenet_v1.pb"
with tf.Session() as sess:
saver.restore(sess, checkpoint_file)
#Exporting the graph
print ("Exporting graph...")
output_graph_def = graph_util.convert_variables_to_constants(
sess,
input_graph_def,
output_node_names.split(","))
with tf.gfile.GFile(output_graph_name, "wb") as f:
f.write(output_graph_def.SerializeToString())
def test_mobilenet_v1():
batch_size = 5
height, width = 224, 224
num_classes = 1001
img = cv2.imread('laska.png')
img_resize = cv2.resize(img, (height, width))
img_rgb = cv2.cvtColor(img_resize, cv2.COLOR_BGR2RGB).astype(np.float32)
# input_mat = np.random.rand(batch_size, height, width, 3).astype(np.float32)
input_mat = np.zeros(shape=(batch_size, height, width, 3),
dtype=np.float32)
# input_mat[0, :, :, :] = (img_rgb - 127) / 127.0
input_mat[0, :, :, :] = img_rgb / 255.0
print('input_mat[0]:', input_mat[0, :, :, :])
print('input_mat[1]:', input_mat[1, :, :, :])
# inputs = tf.random_uniform((batch_size, height, width, 3), name='input')
inputs = tf.convert_to_tensor(input_mat, name='input', dtype=tf.float32)
arg_scope = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False,
weight_decay=0.0)
with slim.arg_scope(arg_scope):
logits, end_points = mobilenet_v1.mobilenet_v1(inputs,
num_classes,
is_training=False)
model_dir = '/Users/alexwang/data/mobilenet_v1_1.0_160'
checkpoint_path = os.path.join(model_dir, 'mobilenet_v1_1.0_160.ckpt')
print_tensors_in_checkpoint_file(checkpoint_path, None, False)
saver = tf.train.Saver()
# print all node in graph
# for tensor in tf.get_default_graph().as_graph_def().node:
# print(tensor.name)
input_get = tf.get_default_graph().get_tensor_by_name('input:0')
print('shape of input_get:{}'.format(input_get.shape))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
predict = sess.run([end_points['Predictions']])
print(predict)
classes = np.argmax(predict[0], axis=1)
print(classes)
saver.restore(sess, checkpoint_path)
predict = sess.run([end_points['Predictions']])[0]
print('predict:', predict)
classes = np.argsort(predict, axis=1)
for predict_result in classes:
# print(predict_result[::-1][0:5])
class_names = [(label_names[i], predict[0][i])
for i in predict_result[::-1][0:5]]
print(class_names)
def build_model():
"""Builds graph for model to train with rewrites for quantization.
Returns:
g: Graph with fake quantization ops and batch norm folding suitable for
training quantized weights.
train_tensor: Train op for execution during training.
"""
g = tf.Graph()
with g.as_default(), tf.device(
tf.train.replica_device_setter(FLAGS.ps_tasks)):
inputs, labels = imagenet_input(is_training=True)
with slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(is_training=True)):
logits, _ = mobilenet_v1.mobilenet_v1(
inputs,
is_training=True,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes)
tf.losses.softmax_cross_entropy(labels, logits)
# Call rewriter to produce graph with fake quant ops and folded batch norms
# quant_delay delays start of quantization till quant_delay steps, allowing
# for better model accuracy.
if FLAGS.quantize:
tf.contrib.quantize.create_training_graph(
quant_delay=get_quant_delay())
corr = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accr = tf.reduce_mean(tf.cast(corr, "float"))
total_loss = tf.losses.get_total_loss(name='total_loss')
# Configure the learning rate using an exponential decay.
num_epochs_per_decay = 2.5
imagenet_size = FLAGS.training_set_size
decay_steps = int(imagenet_size / FLAGS.batch_size *
num_epochs_per_decay)
learning_rate = tf.train.exponential_decay(
get_learning_rate(),
tf.train.get_or_create_global_step(),
decay_steps,
_LEARNING_RATE_DECAY_FACTOR,
staircase=True)
opt = tf.train.GradientDescentOptimizer(learning_rate)
train_tensor = slim.learning.create_train_op(total_loss, optimizer=opt)
slim.summaries.add_scalar_summary(total_loss, 'total_loss', 'losses')
slim.summaries.add_scalar_summary(learning_rate, 'learning_rate',
'training')
slim.summaries.add_scalar_summary(accr, 'accuracy', 'training')
return g, train_tensor
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope()):
_, end_points = mobilenet_v1.mobilenet_v1(
x_input, num_classes=self.num_classes, is_training=False,
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 build_model():
print('build model')
g = tf.Graph()
with g.as_default(), tf.device(
tf.train.replica_device_setter(FLAGS.ps_tasks)):
# inputs, labels = imagenet_input(is_training=True)
inputs, labels = cifar10_input.distorted_inputs(
'../cifar10/cifar-10-batches-bin', 100)
with slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(is_training=True)):
print('default layers')
logits, _ = mobilenet_v1.mobilenet_v1(
inputs,
is_training=True,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes,
)
print('start train')
one_hot_labels = tf.one_hot(tf.cast(labels, dtype=tf.uint8),
FLAGS.num_classes,
dtype=tf.float32)
slim.losses.softmax_cross_entropy(one_hot_labels, logits)
if FLAGS.quantize:
tf.contrib.quantize.create_training_graph(
quant_delay=get_quant_delay())
total_loss = tf.losses.get_total_loss(name='total_loss')
# configure the learning rate using an exponential decay
num_epochs_per_decay = 2.5
imagenet_size = 1271167
decay_steps = int(imagenet_size / FLAGS.batch_size *
num_epochs_per_decay)
learning_rate = tf.train.exponential_decay(
get_learning_rate(),
tf.train.get_or_create_global_step(),
decay_steps,
_LEARNING_RATE_DECAY_FACTOR,
staircase=True)
opt = tf.train.GradientDescentOptimizer(learning_rate)
train_tensor = slim.learning.create_train_op(total_loss, optimizer=opt)
slim.summaries.add_scalar_summary(total_loss, 'total_loss', 'losses')
slim.summaries.add_scalar_summary(learning_rate, 'learning_rate', 'traing')
return g, train_tensor
def ConvNet(input):
curr_arg_scope = mobilenet_v1.mobilenet_v1_arg_scope()
with slim.arg_scope(curr_arg_scope):
nets = mobilenet(input, is_training=False)
logits = slim.conv2d(nets,
1,
1,
activation_fn=tf.identity,
scope='outputR',
padding="VALID")
with tf.name_scope('regress'):
result = tf.identity(logits, name='result')
return result
def get_backbone_func_and_arg_scope(config):
"""
:param network_name: string
:return: network func
"""
if config.Network.encoder_backbone is None:
return None
elif config.Network.encoder_backbone == 'MobilenetV1':
from mobilenet_v1 import mobilenet_v1_base, mobilenet_v1_arg_scope
return mobilenet_v1_base, mobilenet_v1_arg_scope(is_training=config.is_training)
elif config.Network.encoder_backbone == 'Ori_Unet':
from unet_base import unet_base, unet_base_arg_scope
return unet_base, unet_base_arg_scope(is_training=config.is_training)
else:
raise Exception('invalid network name: %s' % config.Network.encoder_backbone)
def build_model(image_datas):
with tf.Graph().as_default():
image = tf.placeholder(dtype=tf.float32, shape=[None, None, 3])
def preprocessing_fn(image, output_height, output_width, **kwargs):
return preprocessing_factory.preprocess_image(
image, output_height, output_width, is_training=False, **kwargs)
processed_image = preprocessing_fn(image, FLAGS.image_size, FLAGS.image_size)
processed_images = tf.expand_dims(processed_image, 0)
scope = mobilenet_v1.mobilenet_v1_arg_scope(
weight_decay=0.0)
# Create the model, use the default arg scope to configure the batch norm parameters.
with slim.arg_scope(scope):
# 1000 classes instead of 1001.
logits, _ = mobilenet_v1.mobilenet_v1(
processed_images,
is_training=False,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes)
probabilities = tf.nn.softmax(logits)
variables_to_restore = slim.get_variables_to_restore()
saver = tf.train.Saver(var_list=variables_to_restore)
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint(FLAGS.checkpoint_path))
# print_tensor(sess)
for image_data in image_datas:
p_image, g_probabilities = sess.run([processed_image, probabilities], feed_dict={image: image_data})
g_probabilities = g_probabilities[0].squeeze()
sorted_inds = [i[0] for i in sorted(enumerate(-g_probabilities), key=lambda x: x[1])]
for i in range(len(sorted_inds)):
index = sorted_inds[i]
# print the probabilities of each category.
# print('Probability %0.2f%% => [%s]' % (g_probabilities[index] * 100, names[index]))
print('recognize character:', names[sorted_inds[0]])
cv2.imshow('1', p_image)
cv2.waitKey()
def freeze():
with tf.Graph().as_default() as graph:
placeholder = tf.placeholder(
name='input',
dtype=tf.float32,
shape=[FLAGS.batch_size, FLAGS.image_size, FLAGS.image_size, 1])
scope = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False,
weight_decay=0.0)
with slim.arg_scope(scope):
mobilenet_v1.mobilenet_v1(placeholder,
is_training=False,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes)
if FLAGS.quantize:
tf.contrib.quantize.create_eval_graph()
graph_def = graph.as_graph_def()
with tf.gfile.GFile(FLAGS.output_file, 'wb') as f:
f.write(graph_def.SerializeToString())
def mobilenetv1_fcn8_model(images,
num_classes,
is_training=False,
raw_image_shape=(520 - 170, 800),
data_aug_faster_mode=False,
decoder='fcn8'):
train_image_shape = (224 * 2, 224 * 4)
if decoder == 'fcn8':
decoder_fn = mobilenet_v1_fcn_decoder
elif decoder == 'fcn8_upsample':
decoder_fn = mobilenet_v1_fcn8_upsample_decoder
else:
raise ValueError("the decoder should be either fcn8 or fcn8_upsample")
# raw_image_shape=tf.constant((images.shape[2]),dtype=tf.int32)
# images=tf.map_fn(lambda img: preprocess_image(img,224,224,is_training), images)
tf.summary.image('image before resize', tf.expand_dims(images[0], 0))
images = rescale_and_resize_images(images, train_image_shape)
#if is_training:
# images = tf.map_fn(lambda x: inception_preprocessing.random_distort_images(x,fast_mode=data_aug_faster_mode),
# images, dtype=tf.float32)
with tf.contrib.slim.arg_scope(
mobilenet_v1_arg_scope(is_training=is_training)):
m_logits, end_points = mobilenet_v1(images,
num_classes=1001,
spatial_squeeze=False)
layer4 = end_points['Conv2d_4_pointwise']
layer6 = end_points['Conv2d_6_pointwise']
layer13 = end_points['Conv2d_13_pointwise']
last_layer = decoder_fn(layer13, layer4, layer6, num_classes)
last_layer = post_process_logits(end_points, last_layer, raw_image_shape,
train_image_shape)
return last_layer, end_points
def predict(self, preprocessed_inputs, is_training):
"""Predict prediction tensors from inputs tensor.
Outputs of this function can be passed to loss or postprocess functions.
Args:
preprocessed_inputs: A float32 tensor with shape [batch_size,
height, width, num_channels] representing a batch of images.
Returns:
prediction_dict: A dictionary holding prediction tensors to be
passed to the Loss or Postprocess functions.
"""
with slim.arg_scope(mobilenet_v1_arg_scope(is_training=is_training)):
logits, end_points = mobilenet_v1(preprocessed_inputs, is_training=is_training, depth_multiplier=1.0, num_classes=70)
prob = tf.nn.softmax(logits, name='prob')
prediction_dict = {'prob': prob}
return prediction_dict
def _tower_fn(is_training, dp_keep_prob, weight_decay, feature, label,
data_format, num_layers, batch_norm_decay, batch_norm_epsilon,
params):
if params.model_name == 'mobilenet_v2':
with slim.arg_scope(
mobilenet_v2.training_scope(is_training=True,
dropout_keep_prob=dp_keep_prob)):
logits, end_points = mobilenet_v2.mobilenet(
feature, num_classes=num_classes, prediction_fn=None)
if params.model_name == 'mobilenet_v1':
with slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(is_training=False)):
logits, end_points = mobilenet_v1.mobilenet_v1(
feature, num_classes=num_classes)
tower_pred = {
'classes': tf.argmax(input=logits, axis=1),
'probabilities': tf.nn.softmax(logits)
}
#tower_loss = tf.losses.softmax_cross_entropy(
# logits=logits, onehot_labels=tf.one_hot(label, depth=num_classes))
tower_loss = tf.losses.sparse_softmax_cross_entropy(logits=logits,
labels=label)
tower_loss = tf.reduce_mean(tower_loss)
model_params = tf.trainable_variables()
depthwise_params = [v for v in model_params if 'depthwise' in v.op.name]
if params.weight_decay_not_used_on_depthwise:
model_params_for_weight_decay = [
v for v in model_params if v not in depthwise_params
]
else:
model_params_for_weight_decay = model_params
tower_loss += weight_decay * tf.add_n(
[tf.nn.l2_loss(v) for v in model_params_for_weight_decay])
tower_grad = tf.gradients(tower_loss, model_params)
return tower_loss, zip(tower_grad, model_params), tower_pred
def visual_modulator_lite(guide_image,
model_params,
scope='osmn',
is_training=False):
"""Defines the visual modulator
Args:
gudie_image: visual guide image
model_params: parameters related to model structure
scope: scope name for the network
is_training: training or testing
Returns:
Tensor of the visual modulation parameters
"""
mod_early_conv = model_params.mod_early_conv
n_modulator_param = [128, 256, 512, 1024] # 1024 + 512 + 256 + 128
with tf.variable_scope(scope, [guide_image]) as sc, \
slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope(is_training=is_training)) as arg_sc:
modulator_params = None
# Collect outputs of all intermediate layers.
net, end_points = mobilenet_v1.mobilenet_v1(guide_image,
scope='modulator',
num_classes=2048,
spatial_squeeze=False,
is_training=is_training)
net = tf.nn.relu(net)
modulator_params = []
for i, n in enumerate(n_modulator_param):
logits = slim.conv2d(net,
n, [1, 1],
activation_fn=None,
weights_initializer=tf.zeros_initializer(),
biases_initializer=tf.ones_initializer(),
normalizer_fn=None,
scope='Conv2d_out_%d' % (i + 1))
modulator_params.append(logits)
return modulator_params
def build_model():
"""Build the mobilenet_v1 model for freeze.
Returns:
g: graph with rewrites after insertion of quantization ops and batch norm
folding.
"""
g = tf.Graph()
with g.as_default():
inputs = tf.placeholder(
dtype=tf.float32,
shape=[None, FLAGS.image_size, FLAGS.image_size, 3],
name="input_node")
scope = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False,
weight_decay=0.0)
with slim.arg_scope(scope):
logits, _ = mobilenet_v1.mobilenet_v1(
inputs,
is_training=False,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes)
logits = tf.identity(logits, name='output_node')
if FLAGS.quantize:
tf.contrib.quantize.create_eval_graph()
return g
def test_tf(inp):
import tensorflow.contrib.slim as slim
import mobilenet_v1
input = tf.placeholder(tf.float32, [None, args.image_size, args.image_size, 3])
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope()):
net = mobilenet_v1.mobilenet_v1(input, num_classes=1001, depth_multiplier=args.depth_multiplier, is_training=False)
# Add ops to restore all the variables.
restorer = tf.train.Saver()
# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:
# Restore variables from disk.
restorer.restore(sess, args.tensorflow_model)
# with tf.variable_scope('',reuse=True):
# tmp = tf.get_variable('MobilenetV1/Conv2d_0/weights').eval()
# sess.run(tf.assign(tf.get_variable('MobilenetV1/Conv2d_0/weights'), var_dict['features.Conv2d_0.0.weight'].numpy().transpose([2,3,1,0])))#tmp * 0+1))
print("Model restored.")
# Do some work with the model
out = sess.run(net, feed_dict={input: inp})
# out = sess.run(net[1]['Conv2d_0'], feed_dict={input: inp})
return out
def model(images, weight_decay=1e-5, is_training=True, reuse=False):
'''
define the model, we use slim's implemention of resnet
'''
#images = mean_image_subtraction(images)
images = (images - 127.5) / 128.0
#with slim.arg_scope(resnet_v1.resnet_arg_scope(weight_decay=weight_decay)):
# logits, end_points = resnet_v1.resnet_v1_50(images, is_training=is_training, scope='resnet_v1_50')
with slim.arg_scope(
mobilenet.mobilenet_v1_arg_scope(
is_training=is_training,
weight_decay=weight_decay,
regularize_depthwise=True if weight_decay > 0 else False)):
logits, end_points = mobilenet.mobilenet_v1(
images,
num_classes=None,
is_training=is_training,
is_finetuning=is_training,
final_endpoint='Conv2d_12_pointwise',
reuse=reuse)
with tf.variable_scope('feature_fusion', values=[end_points.values]):
batch_norm_params = {
'decay': 0.997,
'epsilon': 1e-5,
'scale': True,
'is_training': is_training
}
with slim.arg_scope(
[slim.conv2d],
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
weights_regularizer=slim.l2_regularizer(weight_decay)):
# f = [end_points['pool5'], end_points['pool4'],
# end_points['pool3'], end_points['pool2']]
f = [
end_points['Conv2d_12_pointwise'],
end_points['Conv2d_6_pointwise'],
end_points['Conv2d_4_pointwise'],
end_points['Conv2d_2_pointwise']
]
for i in range(4):
print('Shape of f_{} {}'.format(i, f[i].shape))
g = [None, None, None, None]
h = [None, None, None, None]
num_outputs = [None, 128, 64, 32]
for i in range(4):
if i == 0:
h[i] = f[i]
else:
c1_1 = slim.conv2d(tf.concat([g[i - 1], f[i]], axis=-1),
num_outputs[i], 1)
h[i] = slim.conv2d(c1_1, num_outputs[i], 3)
if i <= 2:
g[i] = unpool(h[i])
else:
g[i] = slim.conv2d(h[i], num_outputs[i], 3)
print('Shape of h_{} {}, g_{} {}'.format(
i, h[i].shape, i, g[i].shape))
# here we use a slightly different way for regression part,
# we first use a sigmoid to limit the regression range, and also
# this is do with the angle map
F_score = slim.conv2d(g[3],
1,
1,
activation_fn=tf.nn.sigmoid,
normalizer_fn=None)
# 4 channel of axis aligned bbox and 1 channel rotation angle
geo_map = slim.conv2d(
g[3], 4, 1, activation_fn=tf.nn.sigmoid,
normalizer_fn=None) * FLAGS.text_scale
angle_map = (slim.conv2d(
g[3], 1, 1, activation_fn=tf.nn.sigmoid, normalizer_fn=None) -
0.5) * np.pi / 2 # angle is between [-45, 45]
F_geometry = tf.concat([geo_map, angle_map], axis=-1)
return F_score, F_geometry
def debug():
g = tf.Graph()
inputs = tf.placeholder(shape=[None, 28, 28, 3], dtype=tf.float32)
labels = tf.placeholder(shape=[
None,
], dtype=tf.float32)
with g.as_default(), tf.device(
tf.train.replica_device_setter(FLAGS.ps_tasks)):
# inputs, labels = imagenet_input(is_training=True)
tf_inputs, tf_labels = cifar10_input.distorted_inputs(
'../cifar10/cifar-10-batches-bin', 100)
with slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(is_training=True)):
logits, _ = mobilenet_v1.mobilenet_v1(
inputs,
is_training=True,
depth_multiplier=FLAGS.depth_multiplier,
num_classes=FLAGS.num_classes,
)
one_hot_labels = tf.one_hot(tf.cast(labels, dtype=tf.uint8),
FLAGS.num_classes,
dtype=tf.float32)
slim.losses.softmax_cross_entropy(one_hot_labels, logits)
if FLAGS.quantize:
tf.contrib.quantize.create_training_graph(
quant_delay=get_quant_delay())
total_loss = tf.losses.get_total_loss(name='total_loss')
# configure the learning rate using an exponential decay
num_epochs_per_decay = 2.5
imagenet_size = 1271167
decay_steps = int(imagenet_size / FLAGS.batch_size *
num_epochs_per_decay)
learning_rate = tf.train.exponential_decay(
get_learning_rate(),
tf.train.get_or_create_global_step(),
decay_steps,
_LEARNING_RATE_DECAY_FACTOR,
staircase=True)
opt = tf.train.GradientDescentOptimizer(learning_rate)
train_tensor = slim.learning.create_train_op(total_loss, optimizer=opt)
slim.summaries.add_scalar_summary(total_loss, 'total_loss', 'losses')
slim.summaries.add_scalar_summary(learning_rate, 'learning_rate', 'traing')
init_op = [
tf.global_variables_initializer(),
tf.local_variables_initializer()
]
# accuracy
test_inputs, test_labels = cifar10_input.distorted_inputs(
'../cifar10/cifar-10-batches-bin', 1000, is_validdata=True)
accuracy = tf.metrics.accuracy(tf.argmax(logits, axis=1), test_labels)
with tf.Session(graph=g) as session:
session.run(init_op)
for step in range(10000):
_loss, _ = session.run([total_loss, train_tensor],
feed_dict={
inputs: tf_inputs,
labels: tf_labels,
})
if step % 100 == 0:
_accuracy = session.run(accuracy,
feed_dict={
inputs: test_inputs,
labels: test_labels
})
print('step: %d, loss: %s, accuracy: %s' %
(step, _loss, _accuracy))
dataset = Dataset(**vars(args))
# 1. Loads data set.
mnist = input_data.read_data_sets('MNIST_data')
# 2. Defines network.
# 2.1 Input feature dim = Nx784, N is sample number
# x = tf.placeholder(tf.float32, [None, 784], name='x-input')
x = tf.placeholder(tf.float32, [10, 224, 224, 3], name='x-input')
# 2.2 Reshapes the feature to Nx28x28 images
# x_image = tf.reshape(x, [-1, 28, 28, 1])
x_image = tf.reshape(x, [10, 224, 224, 3])
# 2.3 Defines the network.
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope(is_training=True)):
y, _ = mobilenet_v1.mobilenet_v1(
x_image,
# num_classes=10,
num_classes=2,
is_training=True,
)
# 2.4 Input ground truth labels in on-hot.
# y_ = tf.placeholder(tf.int32, [None, 10], name='y-input')
y_ = tf.placeholder(tf.int32, [None, 2], name='y-input')
# 2.5 Defines Loss function.
loss = tf.losses.softmax_cross_entropy(logits=y, onehot_labels=y_)
# 2.6 Defines accuracy.
accuracy = tf.metrics.accuracy(labels=tf.argmax(y_, axis=1),
def run():
#Create log_dir for evaluation information
if not os.path.exists(log_eval):
os.mkdir(log_eval)
#Just construct the graph from scratch again
with tf.Graph().as_default() as graph:
tf.logging.set_verbosity(tf.logging.INFO)
#Get the dataset first and load one batch of validation images and labels tensors. Set is_training as False so as to use the evaluation preprocessing
dataset = get_split('validation', dataset_dir)
images, raw_images, labels = load_batch(dataset,
batch_size=batch_size,
is_training=False)
#Create some information about the training steps
num_batches_per_epoch = dataset.num_samples / batch_size
num_steps_per_epoch = num_batches_per_epoch
#Now create the inference model but set is_training=False
with slim.arg_scope(mobilenet_v1_arg_scope()):
logits, end_points = mobilenet_v1(images,
num_classes=dataset.num_classes,
is_training=False)
# #get all the variables to restore from the checkpoint file and create the saver function to restore
variables_to_restore = slim.get_variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
def restore_fn(sess):
return saver.restore(sess, checkpoint_file)
#Just define the metrics to track without the loss or whatsoever
probabilities = end_points['Predictions']
predictions = tf.argmax(probabilities, 1)
accuracy, accuracy_update = tf.contrib.metrics.streaming_accuracy(
predictions, labels)
metrics_op = tf.group(accuracy_update)
#Create the global step and an increment op for monitoring
global_step = get_or_create_global_step()
global_step_op = tf.assign(
global_step, global_step + 1
) #no apply_gradient method so manually increasing the global_step
#Create a evaluation step function
def eval_step(sess, metrics_op, global_step):
'''
Simply takes in a session, runs the metrics op and some logging information.
'''
start_time = time.time()
_, global_step_count, accuracy_value = sess.run(
[metrics_op, global_step_op, accuracy])
time_elapsed = time.time() - start_time
#Log some information
logging.info(
'Global Step %s: Streaming Accuracy: %.4f (%.2f sec/step)',
global_step_count, accuracy_value, time_elapsed)
return accuracy_value
#Define some scalar quantities to monitor
tf.summary.scalar('Validation_Accuracy', accuracy)
my_summary_op = tf.summary.merge_all()
#Get your supervisor
sv = tf.train.Supervisor(logdir=log_eval,
summary_op=None,
init_fn=restore_fn)
#Now we are ready to run in one session
with sv.managed_session() as sess:
for step in xrange(int(num_batches_per_epoch * num_epochs)):
#print vital information every start of the epoch as always
if step % num_batches_per_epoch == 0:
logging.info('Epoch: %s/%s',
step / num_batches_per_epoch + 1, num_epochs)
logging.info('Current Streaming Accuracy: %.4f',
sess.run(accuracy))
#Compute summaries every 10 steps and continue evaluating
if step % 10 == 0:
eval_step(sess,
metrics_op=metrics_op,
global_step=sv.global_step)
summaries = sess.run(my_summary_op)
sv.summary_computed(sess, summaries)
#Otherwise just run as per normal
else:
eval_step(sess,
metrics_op=metrics_op,
global_step=sv.global_step)
#At the end of all the evaluation, show the final accuracy
logging.info('Final Streaming Accuracy: %.4f', sess.run(accuracy))
#Now we want to visualize the last batch's images just to see what our model has predicted
raw_images, labels, predictions, probabilities = sess.run(
[raw_images, labels, predictions, probabilities])
for i in range(10):
image, label, prediction, probability = raw_images[i], labels[
i], predictions[i], probabilities[i]
prediction_name, label_name = dataset.labels_to_name[
prediction], dataset.labels_to_name[label]
text = 'Prediction: %s \n Ground Truth: %s \n Probability: %s' % (
prediction_name, label_name, probability[prediction])
img_plot = plt.imshow(image)
#Set up the plot and hide axes
plt.title(text)
img_plot.axes.get_yaxis().set_ticks([])
img_plot.axes.get_xaxis().set_ticks([])
plt.show()
logging.info(
'Model evaluation has completed! Visit TensorBoard for more information regarding your evaluation.'
)
sv.saver.save(sess, sv.save_path, global_step=sv.global_step)
from tensorflow.contrib import slim
SOURCE_PATH = ''
TARGET_PATH = os.path.join('.', 'npy')
MULTIPLIER = os.getenv('MOBILENET_MULTIPLIER')
RESOLUTION = os.getenv('MOBILENET_RESOLUTION')
if os.path.isdir(TARGET_PATH):
shutil.rmtree(TARGET_PATH)
os.mkdir(TARGET_PATH)
with tf.Session() as sess:
input_shape = (None, int(RESOLUTION), int(RESOLUTION), 3)
input_node = tf.placeholder(tf.float32, shape=input_shape, name="input")
with slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(is_training=False)):
mobilenet_v1.mobilenet_v1(input_node,
num_classes=1001,
is_training=False,
depth_multiplier=float(MULTIPLIER))
saver = tf.train.Saver()
ckpt_file_prefix = 'mobilenet_v1_{}_{}.ckpt'.format(MULTIPLIER, RESOLUTION)
saver.restore(sess, os.path.join(SOURCE_PATH, ckpt_file_prefix))
for t in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES):
varname = t.name
if os.path.sep in t.name:
varname = varname.replace(os.path.sep, '_')
if varname.startswith('MobilenetV1_'):
varname = varname[12:]
def osmn_lite(inputs,
model_params,
visual_modulator_params=None,
scope='osmn',
is_training=False):
"""Defines the OSMN
Args:
inputs: Tensorflow placeholder that contains the input image, visual guide, and spatial guide
model_params: paramters related to the model structure
visual_modulator_params: if None it will generate new visual modulation parameters using guide image, otherwise
it will reuse the current paramters.
scope: Scope name for the network
is_training: training or testing
Returns:
net: Output Tensor of the network
end_points: Dictionary with all Tensors of the network
"""
guide_im_size = tf.shape(inputs[0])
im_size = model_params.im_size
batch_size = inputs[1].get_shape().as_list()[0]
use_visual_modulator = model_params.use_visual_modulator
use_spatial_modulator = model_params.use_spatial_modulator
train_seg = model_params.train_seg
n_modulator_param = 1024 + 512 + 256 + 128
mod_layer_ids = [3, 5, 11, 13]
output_stride = 32
batch_norm_params = {
'decay': 0.99,
'scale': True,
'epsilon': 0.001,
'updates_collections': None,
'is_training': not model_params.fix_bn and is_training
}
if use_visual_modulator and visual_modulator_params == None:
visual_modulator_params = visual_modulator_lite(
inputs[0], model_params, scope=scope, is_training=is_training)
with tf.variable_scope(scope, [inputs]) as sc, slim.arg_scope(
mobilenet_v1.mobilenet_v1_arg_scope(
is_training=is_training)) as arg_sc:
end_points_collection = sc.name + '_end_points'
# index to mark the current position of the modulation params
visual_mod_id = 0
with tf.variable_scope('modulator_sp'):
with slim.arg_scope(
[slim.conv2d],
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
padding='SAME',
outputs_collections=end_points_collection) as bn_arg_sc:
if not use_spatial_modulator:
sp_mod_params = None
else:
ds_mask = slim.avg_pool2d(inputs[1], [4, 4],
stride=4,
scope='pool4')
conv3_att = slim.conv2d(ds_mask,
128, [1, 1],
scope='conv3')
ds_mask = slim.avg_pool2d(ds_mask, [2, 2], scope='pool8')
conv5_att = slim.conv2d(ds_mask,
256, [1, 1],
scope='conv5')
ds_mask = slim.avg_pool2d(ds_mask, [2, 2], scope='pool16')
conv11_att = slim.conv2d(ds_mask,
512, [1, 1],
scope='conv11')
ds_mask = slim.avg_pool2d(ds_mask, [2, 2], scope='pool32')
conv13_att = slim.conv2d(ds_mask,
1024, [1, 1],
scope='conv13')
sp_mod_params = [
conv3_att, conv5_att, conv11_att, conv13_att
]
# Collect outputs of all intermediate layers.
net, end_points = mobilenet_v1.mobilenet_v1_base(
inputs[2],
output_stride=output_stride,
vis_mod_params=visual_modulator_params,
sp_mod_params=sp_mod_params,
mod_layer_ids=mod_layer_ids,
scope='seg')
with slim.arg_scope([slim.conv2d],
activation_fn=None,
normalizer_fn=None):
net_2 = end_points['Conv2d_3_pointwise']
net_3 = end_points['Conv2d_5_pointwise']
net_4 = end_points['Conv2d_11_pointwise']
net_5 = end_points['Conv2d_13_pointwise']
side_2 = slim.conv2d(net_2, 16, [3, 3], scope='conv3_16')
side_3 = slim.conv2d(net_3, 16, [3, 3], scope='conv5_16')
side_4 = slim.conv2d(net_4, 16, [3, 3], scope='conv11_16')
side_5 = slim.conv2d(net_5, 16, [3, 3], scope='conv13_16')
up_size = [im_size[1] / 2, im_size[0] / 2]
side_2_f = tf.image.resize_bilinear(side_2, up_size)
side_3_f = tf.image.resize_bilinear(side_3, up_size)
side_4_f = tf.image.resize_bilinear(side_4, up_size)
side_5_f = tf.image.resize_bilinear(side_5, up_size)
net = tf.concat([side_2_f, side_3_f, side_4_f, side_5_f], axis=3)
net = slim.conv2d(net, 1, [1, 1], scope='score')
net = tf.image.resize_bilinear(net, [im_size[1], im_size[0]])
#net = slim.conv2d_transpose(net, 1, output_stride * 2, output_stride, normalizer_fn=None, padding="SAME", scope='score-up')
end_points = slim.utils.convert_collection_to_dict(
end_points_collection)
return net, end_points
def run():
#Create the log directory here. Must be done here otherwise import will activate this unneededly.
if not os.path.exists(log_dir):
os.mkdir(log_dir)
#======================= TRAINING PROCESS =========================
#Now we start to construct the graph and build our model
with tf.Graph().as_default() as graph:
tf.logging.set_verbosity(
tf.logging.INFO) #Set the verbosity to INFO level
#First create the dataset and load one batch
dataset = get_split('train', dataset_dir, file_pattern=file_pattern)
images, _, labels = load_batch(dataset, batch_size=batch_size)
#Know the number steps to take before decaying the learning rate and batches per epoch
num_batches_per_epoch = dataset.num_samples // batch_size
num_steps_per_epoch = num_batches_per_epoch #Because one step is one batch processed
decay_steps = int(num_epochs_before_decay * num_steps_per_epoch)
#Create the model inference
with slim.arg_scope(mobilenet_v1_arg_scope()):
logits, end_points = mobilenet_v1(images,
num_classes=dataset.num_classes,
is_training=True)
#Perform one-hot-encoding of the labels (Try one-hot-encoding within the load_batch function!)
one_hot_labels = slim.one_hot_encoding(labels, dataset.num_classes)
#Performs the equivalent to tf.nn.sparse_softmax_cross_entropy_with_logits but enhanced with checks
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 = 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,
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)
# optimizer = tf.train.RMSPropOptimizer(learning_rate = lr, momentum=0.9)
#Create the train_op.
train_op = slim.learning.create_train_op(total_loss, optimizer)
#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']
accuracy, accuracy_update = tf.contrib.metrics.streaming_accuracy(
predictions, labels)
metrics_op = tf.group(accuracy_update, probabilities)
#Now finally create all the summaries you need to monitor and group them into one summary op.
tf.summary.scalar('losses/Total_Loss', total_loss)
tf.summary.scalar('accuracy', accuracy)
tf.summary.scalar('learning_rate', lr)
my_summary_op = tf.summary.merge_all()
#Now we need to create a training step function that runs both the train_op, metrics_op and updates the global_step concurrently.
def train_step(sess, train_op, global_step):
'''
Simply runs a session for the three arguments provided and gives a logging on the time elapsed for each global step
'''
#Check the time for each sess run
start_time = time.time()
total_loss, global_step_count, _ = sess.run(
[train_op, global_step, metrics_op])
time_elapsed = time.time() - start_time
#Run the logging to print some results
logging.info('global step %s: loss: %.4f (%.2f sec/step)',
global_step_count, total_loss, time_elapsed)
return total_loss, global_step_count
#Define your supervisor for running a managed session. Do not run the summary_op automatically or else it will consume too much memory
sv = tf.train.Supervisor(logdir=log_dir, summary_op=None)
#Run the managed session
with sv.managed_session() as sess:
for step in range(num_steps_per_epoch * num_epochs):
#At the start of every epoch, show the vital information:
if step % num_batches_per_epoch == 0:
logging.info('Epoch %s/%s',
step / num_batches_per_epoch + 1, num_epochs)
learning_rate_value, accuracy_value = sess.run(
[lr, accuracy])
logging.info('Current Learning Rate: %s',
learning_rate_value)
logging.info('Current Streaming Accuracy: %s',
accuracy_value)
# optionally, print your logits and predictions for a sanity check that things are going fine.
logits_value, probabilities_value, predictions_value, labels_value = sess.run(
[logits, probabilities, predictions, labels])
print('logits: \n', logits_value[:100])
print('Probabilities: \n', probabilities_value[:100])
print('predictions: \n', predictions_value[:100])
print('Labels:\n:', labels_value[:100])
#Log the summaries every 10 step.
if step % 10 == 0:
loss, _ = train_step(sess, train_op, sv.global_step)
summaries = sess.run(my_summary_op)
sv.summary_computed(sess, summaries)
#If not, simply run the training step
else:
loss, _ = train_step(sess, train_op, sv.global_step)
#We log the final training loss and accuracy
logging.info('Final Loss: %s', loss)
logging.info('Final Accuracy: %s', sess.run(accuracy))
#Once all the training has been done, save the log files and checkpoint model
logging.info('Finished training! Saving model to disk now.')
def ssd_net(inputs,
num_classes=SSDNet.default_params.num_classes,
feat_layers=SSDNet.default_params.feat_layers,
anchor_sizes=SSDNet.default_params.anchor_sizes,
anchor_ratios=SSDNet.default_params.anchor_ratios,
normalizations=SSDNet.default_params.normalizations,
is_training=True,
dropout_keep_prob=0.5,
prediction_fn=slim.softmax,
reuse=None,
scope='ssd_300_mobilenetv1'):
"""SSD net definition.
"""
# if data_format == 'NCHW':
# inputs = tf.transpose(inputs, perm=(0, 3, 1, 2))
# End_points collect relevant activations for external use.
end_points = {}
min_depth = 32
depth_multiplier = 1.0
with tf.variable_scope(scope, 'ssd_300_mobilenetv1', [inputs], reuse=reuse):
input_shape = inputs.get_shape().as_list()
if len(input_shape) != 4:
raise ValueError('Invalid input tensor rank, expected 4, was: %d' %
len(input_shape))
with slim.arg_scope(mobilenet_v1.mobilenet_v1_arg_scope(is_training=is_training)):
with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=is_training):
net, end_points = mobilenet_v1.mobilenet_v1_base(inputs, scope='MobilenetV1',
min_depth=min_depth,
depth_multiplier=depth_multiplier,
conv_defs=None)
'''
# Additional SSD blocks.
# Block 6: let's dilate the hell out of it!
end_point = 'block13'
with tf.variable_scope(end_point)
net = slim.conv2d(net, 1024, [3, 3], rate=6, scope='atrous_conv')
end_points['block13_atrous'] = net
net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training)
# Block 7: 1x1 conv. Because the f**k.
net = slim.conv2d(net, 1024, [1, 1], scope='conv1x1')
end_points['block13'] = net
net = tf.layers.dropout(net, rate=dropout_keep_prob, training=is_training)
'''
# Block 14/15/16/17: 1x1 and 3x3 convolutions stride 2 (except lasts).
end_point = 'block14'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 256, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = custom_layers.pad2d(net, pad=(1, 1))
net = slim.conv2d(net, 512, [3, 3], biases_initializer=None, trainable=is_training, stride=2, scope='conv3x3', padding='VALID')
end_points[end_point] = net
end_point = 'block15'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 128, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = custom_layers.pad2d(net, pad=(1, 1))
net = slim.conv2d(net, 256, [3, 3], biases_initializer=None, trainable=is_training, stride=2, scope='conv3x3', padding='VALID')
end_points[end_point] = net
end_point = 'block16'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 128, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = slim.conv2d(net, 256, [3, 3], biases_initializer=None, trainable=is_training, scope='conv3x3', padding='VALID')
end_points[end_point] = net
'''
end_point = 'block17'
with tf.variable_scope(end_point):
net = slim.conv2d(net, 64, [1, 1], biases_initializer=None, trainable=is_training, scope='conv1x1')
net = slim.conv2d(net, 128, [3, 3], biases_initializer=None, trainable=is_training, scope='conv3x3', padding='VALID')
end_points[end_point] = net
'''
# Prediction and localisations layers.
predictions = []
logits = []
localisations = []
for i, layer in enumerate(feat_layers):
with tf.variable_scope(layer + '_box'):
p, l = ssd_multibox_layer(end_points[layer],
num_classes,
anchor_sizes[i],
anchor_ratios[i],
normalizations[i],
is_training=is_training)
predictions.append(prediction_fn(p))
logits.append(p)
localisations.append(l)
# end_points['logits'] = logits
# end_points['predictions'] = predictions
# end_points['localisations'] = localisations
return predictions, localisations, logits, end_points
def network_fn(images):
arg_scope = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False)
with slim.arg_scope(arg_scope):
return networks_map[name](images, num_classes, is_training=False)
def main():
# 加载预处理好的数据。
train_data, train_labels, valid_data, valid_labels, label_keys = train_test(
IMAGE_PATH)
print("%d training examples, %d validation examples." %
(len(train_data), len(valid_data)))
# 定义inception-v1的输入，images为输入图片，labels为每一张图片对应的标签。
images = tf.placeholder(tf.float32, [None, IMAGE_SIZE, IMAGE_SIZE, 3],
name='input_images')
labels = tf.placeholder(tf.int64, [None, N_CLASSES], name='labels')
with slim.arg_scope(mobilenet.mobilenet_v1_arg_scope()):
logits, _ = mobilenet.mobilenet_v1(images,
num_classes=N_CLASSES,
is_training=True)
predictions = tf.nn.softmax(logits, name='output/prob')
# 定义损失函数和训练过程。
cost = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
loss_summary = tf.summary.scalar('loss', cost)
train_step = tf.train.AdamOptimizer(
learning_rate=LEARNING_RATE).minimize(cost)
# 计算正确率。
with tf.name_scope('evaluation'):
correct_prediction = tf.equal(tf.argmax(logits, 1),
tf.argmax(labels, 1))
evaluation_step = tf.reduce_mean(
tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()
tf.add_to_collection("predict", predictions)
with tf.Session() as sess:
merged_summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter('logs', sess.graph)
# 初始化没有加载进来的变量。
init = tf.global_variables_initializer()
sess.run(init)
for i in range(STEPS):
print('step:', i)
for batch_xs, batch_ys in minibatches(train_data,
train_labels,
BATCH_SIZE,
shuffle=True):
# 训练数据
_, summary_str = sess.run([train_step, merged_summary_op],
feed_dict={
images: batch_xs,
labels: batch_ys
})
summary_writer.add_summary(summary_str, i)
# 在验证集上测试正确率
if (i + 1) % 5 == 0 or i + 1 == STEPS:
valid_accuracy = sess.run(evaluation_step,
feed_dict={
images: valid_data,
labels: valid_labels
})
print('Step %d: Validation accuracy = %.1f%%' %
(i, valid_accuracy * 100.0))
# 保存ckpt
#if (i+1) % 20 == 0 or i + 1 == STEPS:
# path = saver.save(sess, TRAIN_FILE, global_step=i)
# print('Saved model to {}\n'.format(path))
# 保存标签
output_labels = os.path.join('./', 'labels.txt')
with tf.gfile.FastGFile(output_labels, 'w') as f:
k = {}
for i in range(N_CLASSES):
k[str(i)] = label_keys[i]
json.dump(k, f)
saver.save(sess, 'model/mobilenet.ckpt')
tf.train.write_graph(sess.graph_def,
'model/',
'trash_mobilenet.pb',
as_text=False)
