def __init__(self, name):
super(Classifier, self).__init__(name)
file_handler = RotatingFileHandler(FLAGS.log,
maxBytes=1024 * 1024 * 100,
backupCount=20)
file_handler.setLevel(logging.INFO)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)
self.names = create_readable_names_for_imagenet_labels()
self.image_size = default_image_size
self.image_str_placeholder = tf.placeholder(tf.string)
image = tf.image.decode_jpeg(self.image_str_placeholder, channels=3)
processed_image = preprocess_image(image, self.image_size,
self.image_size)
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(inception_v4_arg_scope()):
logits, _ = inception_v4(processed_images,
num_classes=1001,
is_training=False)
self.probabilities = tf.nn.softmax(logits)
dest_directory = FLAGS.model_dir
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(dest_directory, 'inception_v4.ckpt'),
slim.get_model_variables('InceptionV4'))
self.sess = tf.Session()
init_fn(self.sess)
def buildNN(self,x,reuse=False,isTraining=True):
h = x
# Slim
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
_,end_points = inception_v4.inception_v4(h,is_training=isTraining,reuse=reuse,create_aux_logits=False)
h = end_points["Mixed_5b"]
if not reuse:
self.variables_to_restore_bbNet = slim.get_variables_to_restore()
with tf.variable_scope("NN") as scope:
if reuse: scope.reuse_variables()
# avgpool
n_b, n_h, n_w, n_f = self.getShape(h)
h = tf.nn.avg_pool(h,ksize=[1,n_h,n_w,1],strides=[1,1,1,1],padding="VALID")
# fc1
n_b, n_h, n_w, n_f = self.getShape(h)
assert n_h==n_w==1, "invalid shape after avg pool:(%d,%d)"%(n_h,n_w)
h = tf.reshape(h,[n_b,n_f])
self.fc1_w, self.fc1_b = self._fc_variable([n_f,self.zdim],name="fc1")
h = tf.matmul(h, self.fc1_w) + self.fc1_b
# L2 normalization
h = h / tf.norm(h,axis=1,keep_dims=True)
if not reuse:
tf.summary.histogram("fc1_w" ,self.fc1_w)
tf.summary.histogram("fc1_b" ,self.fc1_b)
return h
def __init__(self, name):
super(Classifier, self).__init__(name)
file_handler = RotatingFileHandler(FLAGS.log, maxBytes=1024 * 1024 * 100, backupCount=20)
file_handler.setLevel(logging.INFO)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)
self.names = create_readable_names_for_imagenet_labels()
self.image_size = default_image_size
self.image_str_placeholder = tf.placeholder(tf.string)
image = tf.image.decode_jpeg(self.image_str_placeholder, channels=3)
processed_image = preprocess_image(image, self.image_size, self.image_size)
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(inception_v4_arg_scope()):
logits, _ = inception_v4(processed_images, num_classes=1001, is_training=False)
self.probabilities = tf.nn.softmax(logits)
dest_directory = FLAGS.model_dir
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(dest_directory, 'inception_v4.ckpt'),
slim.get_model_variables('InceptionV4'))
self.sess = tf.Session()
init_fn(self.sess)
def main(_):
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
num_classes = 1001
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
# Prepare graph
x_input = tf.placeholder(tf.float32, shape=batch_shape)
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
_, end_points = inception_v4.inception_v4(x_input,
num_classes=num_classes,
is_training=False)
predicted_labels = tf.argmax(end_points['Predictions'], 1)
# 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):
labels = sess.run(predicted_labels,
feed_dict={x_input: images})
for filename, label in zip(filenames, labels):
out_file.write('{0},{1}\n'.format(filename, label))
def test():
model_dir = '/Users/alexwang/data/'
checkpoint_path = os.path.join(model_dir, 'inception_v4.ckpt')
img_path = '../data/laska.png'
img = cv2.imread(img_path)
print('shape of img:', img.shape)
# preprocess image
batch_size = 2
image_size = inception_v4.inception_v4.default_image_size
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.
preprocessed_image_one = inception_preprocessing.preprocess_for_eval(
tf.convert_to_tensor(img_rgb, tf.float32),
image_size,
image_size,
central_fraction=1)
zeros_mat = np.zeros(shape=(image_size, image_size, 3), dtype=np.float32)
preprocessed_image_two = inception_preprocessing.preprocess_for_eval(
tf.convert_to_tensor(zeros_mat, tf.float32),
image_size,
image_size,
central_fraction=1)
inputs = tf.concat([
tf.expand_dims(preprocessed_image_one, 0),
tf.expand_dims(preprocessed_image_two, 0)
],
axis=0)
# construct net
# print_tensors_in_checkpoint_file(checkpoint_path, None, False)
arg_scope = inception_v4.inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(inputs,
is_training=False,
num_classes=1001)
for tensor in tf.all_variables():
print(tensor.name, tensor.shape)
probabilities = tf.nn.softmax(logits)
# restore net
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, checkpoint_path)
# predict
inputs_value, probabilitie_values, end_points_values = sess.run(
[inputs, probabilities, end_points])
print('shape of inputs:', inputs_value.shape)
print('shape of predict', probabilitie_values.shape)
# print('end_point:', end_points_values)
for key in end_points_values.keys():
print(key, end_points_values[key].shape)
for predict in probabilitie_values:
sorted_predict = np.argsort(predict)
top_5 = sorted_predict[::-1][0:5]
top_5_labels = [(label_names[i], predict[i]) for i in top_5]
print(top_5_labels)
def arch_inception_v4_rnn(self, X, num_classes, dropout_keep_prob=0.8, is_train=False):
rnn_size = 256
num_layers = 2
arg_scope = inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
net_vis, end_points = inception_v4(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'):
# 8 x 8 x 1536
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(rnn_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))
# 1536
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 network_fn(images, **kwargs):
arg_scope = inception_v4_arg_scope(weight_decay=weight_decay)
with slim.arg_scope(arg_scope):
return func(images,
num_classes=num_classes,
is_training=is_training,
**kwargs)
def arch_inception_v4(self,
X,
num_classes,
dropout_keep_prob=0.8,
is_train=False):
arg_scope = inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
net_vis, end_points = inception_v4(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'):
# 8 x 8 x 1536
net = slim.avg_pool2d(net_vis,
net_vis.get_shape()[1:3],
padding='VALID',
scope='AvgPool_1a_out')
# 1 x 1 x 1536
net = slim.dropout(net,
dropout_keep_prob,
scope='Dropout_1b_out')
net = slim.flatten(net, scope='PreLogitsFlatten_out')
# 1536
net = slim.fully_connected(net,
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 build_frontend(inputs,
frontend,
is_training=True,
pretrained_dir="models"):
if frontend == 'ResNet50':
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, end_points = resnet_v2.resnet_v2_50(
inputs, is_training=is_training, scope='resnet_v2_50')
frontend_scope = 'resnet_v2_50'
init_fn = slim.assign_from_checkpoint_fn(
model_path=os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'),
var_list=slim.get_model_variables('resnet_v2_50'),
ignore_missing_vars=True)
elif frontend == 'ResNet101':
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, end_points = resnet_v2.resnet_v2_101(
inputs, is_training=is_training, scope='resnet_v2_101')
frontend_scope = 'resnet_v2_101'
init_fn = slim.assign_from_checkpoint_fn(
model_path=os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'),
var_list=slim.get_model_variables('resnet_v2_101'),
ignore_missing_vars=True)
elif frontend == 'ResNet152':
with slim.arg_scope(resnet_v2.resnet_arg_scope()):
logits, end_points = resnet_v2.resnet_v2_152(
inputs, is_training=is_training, scope='resnet_v2_152')
frontend_scope = 'resnet_v2_152'
init_fn = slim.assign_from_checkpoint_fn(
model_path=os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'),
var_list=slim.get_model_variables('resnet_v2_152'),
ignore_missing_vars=True)
elif frontend == 'MobileNetV2':
with slim.arg_scope(mobilenet_v2.training_scope()):
logits, end_points = mobilenet_v2.mobilenet(
inputs,
is_training=is_training,
scope='mobilenet_v2',
base_only=True)
frontend_scope = 'mobilenet_v2'
init_fn = slim.assign_from_checkpoint_fn(
model_path=os.path.join(pretrained_dir,
'mobilenet_v2_1.4_224.ckpt'),
var_list=slim.get_model_variables('mobilenet_v2'),
ignore_missing_vars=True)
elif frontend == 'InceptionV4':
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
logits, end_points = inception_v4.inception_v4(
inputs, is_training=is_training, scope='inception_v4')
frontend_scope = 'inception_v4'
init_fn = slim.assign_from_checkpoint_fn(
model_path=os.path.join(pretrained_dir, 'inception_v4.ckpt'),
var_list=slim.get_model_variables('inception_v4'),
ignore_missing_vars=True)
else:
raise ValueError(
"Unsupported fronetnd model '%s'. This function only supports ResNet50, ResNet101, ResNet152, and MobileNetV2"
% (frontend))
return logits, end_points, frontend_scope, init_fn
def predict(image, version='V3'):
tf.reset_default_graph()
# Process the image
raw_image, processed_image = process_image(image)
print(raw_image.shape)
class_names = imagenet.create_readable_names_for_imagenet_labels()
# Create a placeholder for the images
X = tf.placeholder(tf.float32, [None, 299, 299, 3], name="X")
'''
inception_v3 function returns logits and end_points dictionary
logits are output of the network before applying softmax activation
'''
if version.upper() == 'V3':
print("V3!!")
model_ckpt_path = INCEPTION_V3_CKPT_PATH
with tf.contrib.slim.arg_scope(inception_v3.inception_v3_arg_scope()):
# Set the number of classes and is_training parameter
logits, end_points = inception_v3.inception_v3(X, num_classes=1001, is_training=False)
elif version.upper() == 'V4':
model_ckpt_path = INCEPTION_V4_CKPT_PATH
with tf.contrib.slim.arg_scope(inception_v4.inception_v4_arg_scope()):
# Set the number of classes and is_training parameter
# Logits
logits, end_points = inception_v4.inception_v4(X, num_classes=1001, is_training=False)
predictions = end_points.get('Predictions', 'No key named predictions')
saver = tf.train.Saver()
with tf.Session() as sess:
print("model_ckpt_path", model_ckpt_path)
saver.restore(sess, model_ckpt_path)
prediction_values = predictions.eval({X: processed_image})
try:
# Add an index to predictions and then sort by probability
prediction_values = [(i, prediction) for i, prediction in enumerate(prediction_values[0,:])]
prediction_values = sorted(prediction_values, key=lambda x: x[1], reverse=True)
# Plot the image
#plot_color_image(raw_image)
#plt.show()
print("Using Inception_{} CNN\nPrediction: Probability\n".format(version))
# Display the image and predictions
for i in range(10):
predicted_class = class_names[prediction_values[i][0]]
probability = prediction_values[i][1]
print("{}: {:.2f}%".format(predicted_class, probability*100))
# If the predictions do not come out right
except:
print(predictions)
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
_, end_points = inception_v4.inception_v4(
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_sampler(self):
images = self.images
batch_size = tf.shape(images)[0]
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
netOut, _ = inception_v4.inception_v4(images,
is_training=True,
dropout_keep_prob=1.0)
features = tf.reshape(netOut, (batch_size, -1, 1536))
with tf.variable_scope('Attention'):
features = self._batch_norm(features,
mode='test',
name='conv_features')
c, h = self._get_initial_lstm(features=features)
features_proj = self._project_features(features=features)
sampled_word_list = []
alpha_list = []
beta_list = []
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=self.H)
for t in range(self.T):
if t == 0:
x = self._word_embedding(
inputs=tf.fill([tf.shape(features)[0]], 0))
else:
x = self._word_embedding(inputs=sampled_word, reuse=True)
context, alpha = self._attention_layer(features,
features_proj,
h,
reuse=(t != 0))
alpha_list.append(alpha)
if self.selector:
context, beta = self._selector(context, h, reuse=(t != 0))
beta_list.append(beta)
with tf.variable_scope('lstm', reuse=(t != 0)):
_, (c, h) = lstm_cell(inputs=tf.concat([x, context], 1),
state=[c, h])
logits = self._decode_lstm(x, h, context, reuse=(t != 0))
sampled_word = tf.argmax(logits, 1)
sampled_word_list.append(sampled_word)
alphas = tf.transpose(tf.stack(alpha_list), (1, 0, 2)) # (N, T, L)
# betas = tf.transpose(tf.squeeze(beta_list), (1, 0)) # (N, T)
sampled_captions = tf.transpose(tf.stack(sampled_word_list),
(1, 0)) # (N, max_len)
return alphas, sampled_captions
def __call__(self, x_input):
"""Constructs model and return probabilities for given input."""
reuse = True if self.built else None
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
logits, end_points = inception_v4.inception_v4(
x_input,
num_classes=self.num_classes,
is_training=False,
reuse=reuse,
scope=self.scope)
self.built = True
return logits, end_points
def _build(self):
reuse = True if self.built else None
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
logits, end_points = inception_v4.inception_v4(
self.input, num_classes=self.num_classes, is_training=False,
reuse=reuse)
self.built = True
self.end_points = end_points
self.logits = logits
if not self.ckpt_loaded:
saver = tf.train.Saver()
print ckpt_dir + 'inception_v4_dir'
saver.restore(self.sess, ckpt_dir + 'inception_v4.ckpt')
self.ckpt_loaded = True
def build_inception(inputs, reuse=True, scope='InceptionV4'):
is_training = False
arg_scope = inception_v4_arg_scope(weight_decay=0.0)
with slim.arg_scope(arg_scope):
with tf.variable_scope(scope, 'InceptionV4', [inputs],
reuse=reuse) as scope:
with slim.arg_scope([slim.batch_norm, slim.dropout],
is_training=is_training):
logits, end_points = inception_v4_base(
inputs, final_endpoint='Mixed_5b', scope=scope)
return [
end_points['Conv2d_2a_3x3'], end_points['Mixed_4a'],
end_points['Mixed_5b']
]
def __init__(self, weights_file):
config = tf.ConfigProto(log_device_placement=False)
config.gpu_options.allow_growth = True
self.__graph = tf.Graph()
self.image_size = inception_v4.inception_v4.default_image_size
with self.__graph.as_default():
self.__session = tf.Session(config=config, graph=self.__graph)
self.images_placeholder = tf.placeholder(
tf.float32,
shape=(None, self.image_size, self.image_size, 3),
name='image')
self.phase_train_placeholder = tf.placeholder(tf.bool,
name='phase_train')
arg_scope = inception_v4.inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(
self.images_placeholder,
is_training=False,
num_classes=1001,
create_aux_logits=False)
for tensor in tf.all_variables():
print(tensor.name, tensor.shape)
self.predict = tf.nn.softmax(logits)
self.end_points = end_points
# preprocess
with tf.device('/cpu:0'):
self.one_image_placeholder = tf.placeholder(tf.float32,
shape=(None, None,
3),
name='one_image')
self.preprocessed_image = inception_preprocessing.preprocess_for_eval(
self.one_image_placeholder,
self.image_size,
self.image_size,
central_fraction=1)
print('[{}]:InceptionV4 model restoring...'.format(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
saver = tf.train.Saver(tf.global_variables(), max_to_keep=3)
saver.restore(self.__session, weights_file)
self.__session.graph.finalize()
print('[{}]:InceptionV4 model restore succeed!'.format(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
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, _ = dataset_utils.get_batch(FLAGS.dataset_dir,
FLAGS.batch_size)
inputs = tf.image.resize_images(inputs,
[FLAGS.image_size, FLAGS.image_size])
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
logits, _ = inception_v4.inception_v4(
inputs, is_training=True, num_classes=FLAGS.num_classes)
labels = slim.one_hot_encoding(labels, FLAGS.num_classes)
tf.losses.softmax_cross_entropy(labels, logits)
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 = 7340
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.RMSPropOptimizer(learning_rate,
momentum=0.9,
epsilon=1.0)
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')
return g, train_tensor
def getfeatures(file_name):
# Extract the features from InceptionNet (The features of Mixed_6a layer)
slim = tf.contrib.slim
image_size = inception_v4.inception_v4.default_image_size
checkpoints_dir = os.getcwd()
with tf.Graph().as_default():
image_path = tf.read_file(file_name)
image = tf.image.decode_jpeg(image_path, channels=3)
processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False)
processed_images = tf.expand_dims(processed_image, 0)
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
vector = inception_v4.inception_v4(processed_images, num_classes=1001, is_training=False)
init_fn = slim.assign_from_checkpoint_fn(os.path.join(checkpoints_dir, 'inception_v4.ckpt'), slim.get_model_variables('InceptionV4'))
with tf.Session() as sess:
init_fn(sess)
np_image, vector = sess.run([image, vector])
vector = np.asarray(vector)
# print vector[1]['Mixed_6a'].shape
return vector[1]['Mixed_6a']
def cnvert_ckpt_to_pb(ckpt_path, output_path):
g = tf.Graph()
output_node_names = ['Outputs']
with g.as_default():
inputs = tf.placeholder(tf.float32, [None, 256, 256, 3], 'Inputs')
inputs = tf.image.resize_images(inputs, [299, 299])
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
_, end_points = inception_v4.inception_v4(inputs,
is_training=False,
num_classes=6)
outputs = tf.argmax(end_points['Predictions'], 1, name='Outputs')
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, ckpt_path)
output_graph_def = tf.graph_util.convert_variables_to_constants(
sess, g.as_graph_def(), output_node_names)
with tf.gfile.GFile(output_path, "wb") as f:
f.write(output_graph_def.SerializeToString())
def __init__(self, weight_file):
config = tf.ConfigProto(log_device_placement=False)
config.gpu_options.allow_growth = True
self.__graph = tf.Graph()
self.image_size = inception_v4.inception_v4.default_image_size
with self.__graph.as_default():
self.__session = tf.Session(config=config, graph=self.__graph)
self.images_placeholder = tf.placeholder(
tf.float32,
shape=(None, self.image_size, self.image_size, 3),
name='image')
self.phase_train_placeholder = tf.placeholder(tf.bool,
name='phase_train')
arg_scope = inception_v4.inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(
self.images_placeholder,
is_training=False,
num_classes=1001)
for tensor in tf.all_variables():
print(tensor.name, tensor.shape)
self.predict = tf.nn.softmax(logits)
self.end_points = end_points
# preprocess
self.one_image_placeholder = tf.placeholder(tf.float32,
shape=(None, None, 3),
name='one_image')
self.preprocessed_image = inception_preprocessing.preprocess_for_eval(
self.one_image_placeholder,
self.image_size,
self.image_size,
central_fraction=1)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=3)
saver.restore(self.__session, weight_file)
def get_bottlenecks(name):
tf.reset_default_graph()
inputs, labels = dataset.inputs(name=name, batch_size=1, num_epochs=1, predict=True)
inputs = tf.reshape(inputs, [1, 299, 299, 3])
# note about num_classes:
# we set num_classes=1001 so that the output layer weights are the same size as in the checkpoint
# otherwise restoring raises an InvalidArgumentError
# we could of course also use `inception_v4_base` to output the model without the output layer
# but this way we can still use the final pooling and dropout layers from the original architecture
# we don't care about the size of num_classes since we are only interested in `PreLogitsFlatten` anyway
with tf.contrib.slim.arg_scope(inception_v4_arg_scope()):
_, end_points = inception_v4(
inputs=inputs,
num_classes=1001,
create_aux_logits=False,
is_training=False,
dropout_keep_prob=1.0,
)
return end_points['PreLogitsFlatten'], labels
def test_inception_layer_info():
"""
print layer name, input tensor and output tensor
print example:
Operation:InceptionV4/Logits/Logits/MatMul
InceptionV4/Logits/Logits/MatMul Input: InceptionV4/Logits/PreLogitsFlatten/flatten/Reshape:0 (?, 1536)
InceptionV4/Logits/Logits/MatMul Input: InceptionV4/Logits/Logits/weights/read:0 (1536, 1001)
InceptionV4/Logits/Logits/MatMul Output:InceptionV4/Logits/Logits/MatMul:0
Operation:InceptionV4/Logits/Logits/BiasAdd
InceptionV4/Logits/Logits/BiasAdd Input: InceptionV4/Logits/Logits/MatMul:0 (?, 1001)
InceptionV4/Logits/Logits/BiasAdd Input: InceptionV4/Logits/Logits/biases/read:0 (1001,)
InceptionV4/Logits/Logits/BiasAdd Output:InceptionV4/Logits/Logits/BiasAdd:0
Operation:InceptionV4/Logits/Predictions
InceptionV4/Logits/Predictions Input: InceptionV4/Logits/Logits/BiasAdd:0 (?, 1001)
InceptionV4/Logits/Predictions Output:InceptionV4/Logits/Predictions:0
:return:
"""
image_size = inception_v4.inception_v4.default_image_size
inputs = tf.placeholder(dtype=tf.float32,
shape=(None, image_size, image_size, 3))
arg_scope = inception_v4.inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(inputs,
is_training=False,
num_classes=1001)
operations = tf.get_default_graph().get_operations()
for operation in operations:
print("Operation:{}".format(operation.name))
for k in operation.inputs:
print("{} Input: {} {}".format(operation.name, k.name,
k.get_shape()))
for k in operation.outputs:
print("{} Output:{}".format(operation.name, k.name))
print("\n")
def test_inception_variable_info():
"""
print every variable and its shape in graph
print example:
InceptionV4/Mixed_7d/Branch_2/Conv2d_0d_1x3/BatchNorm/moving_variance:0 (256,)
InceptionV4/Mixed_7d/Branch_2/Conv2d_0e_3x1/weights:0 (3, 1, 512, 256)
InceptionV4/Mixed_7d/Branch_2/Conv2d_0e_3x1/BatchNorm/beta:0 (256,)
InceptionV4/Mixed_7d/Branch_2/Conv2d_0e_3x1/BatchNorm/moving_mean:0 (256,)
InceptionV4/Mixed_7d/Branch_2/Conv2d_0e_3x1/BatchNorm/moving_variance:0 (256,)
InceptionV4/Mixed_7d/Branch_3/Conv2d_0b_1x1/weights:0 (1, 1, 1536, 256)
InceptionV4/Mixed_7d/Branch_3/Conv2d_0b_1x1/BatchNorm/beta:0 (256,)
InceptionV4/Mixed_7d/Branch_3/Conv2d_0b_1x1/BatchNorm/moving_mean:0 (256,)
InceptionV4/Mixed_7d/Branch_3/Conv2d_0b_1x1/BatchNorm/moving_variance:0 (256,)
InceptionV4/AuxLogits/Conv2d_1b_1x1/weights:0 (1, 1, 1024, 128)
InceptionV4/AuxLogits/Conv2d_1b_1x1/BatchNorm/beta:0 (128,)
InceptionV4/AuxLogits/Conv2d_1b_1x1/BatchNorm/moving_mean:0 (128,)
InceptionV4/AuxLogits/Conv2d_1b_1x1/BatchNorm/moving_variance:0 (128,)
InceptionV4/AuxLogits/Conv2d_2a/weights:0 (5, 5, 128, 768)
InceptionV4/AuxLogits/Conv2d_2a/BatchNorm/beta:0 (768,)
InceptionV4/AuxLogits/Conv2d_2a/BatchNorm/moving_mean:0 (768,)
InceptionV4/AuxLogits/Conv2d_2a/BatchNorm/moving_variance:0 (768,)
InceptionV4/AuxLogits/Aux_logits/weights:0 (768, 1001)
InceptionV4/AuxLogits/Aux_logits/biases:0 (1001,)
InceptionV4/Logits/Logits/weights:0 (1536, 1001)
InceptionV4/Logits/Logits/biases:0 (1001,)
:return:
"""
image_size = inception_v4.inception_v4.default_image_size
inputs = tf.placeholder(dtype=tf.float32,
shape=(None, image_size, image_size, 3))
arg_scope = inception_v4.inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(inputs,
is_training=False,
num_classes=1001)
for tensor in tf.all_variables():
print(tensor.name, tensor.shape)
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, _ = dataset_utils.get_batch(FLAGS.dataset_dir,
FLAGS.batch_size)
inputs = tf.image.resize_images(inputs,
[FLAGS.image_size, FLAGS.image_size])
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
_, end_points = inception_v4.inception_v4(
inputs, is_training=False, num_classes=FLAGS.num_classes)
eval_ops = metrics(end_points['Predictions'], labels)
return g, eval_ops
def getfeatures(file_name):
# Extract the features from InceptionNet (The features of Mixed_6a layer)
slim = tf.contrib.slim
image_size = inception_v4.inception_v4.default_image_size
checkpoints_dir = os.getcwd()
with tf.Graph().as_default():
image_path = tf.read_file(file_name)
image = tf.image.decode_jpeg(image_path, channels=3)
processed_image = inception_preprocessing.preprocess_image(
image, image_size, image_size, is_training=False)
processed_images = tf.expand_dims(processed_image, 0)
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
vector = inception_v4.inception_v4(processed_images,
num_classes=1001,
is_training=False)
init_fn = slim.assign_from_checkpoint_fn(
os.path.join(checkpoints_dir, 'inception_v4.ckpt'),
slim.get_model_variables('InceptionV4'))
with tf.Session() as sess:
init_fn(sess)
np_image, vector = sess.run([image, vector])
vector = np.asarray(vector)
# print vector[1]['Mixed_6a'].shape
return vector[1]['Mixed_6a']
def build_inception_model(x_input, y_input, reg_input, reuse, is_training,
FLAGS):
dropout = FLAGS.dropout
batch_size = FLAGS.batch_size
arg_scope = inception_v4.inception_v4_arg_scope()
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(
x_input,
is_training=is_training,
num_classes=None,
dropout_keep_prob=dropout,
reuse=reuse,
create_aux_logits=False)
with tf.variable_scope('Beauty', 'BeautyV1', reuse=reuse) as scope:
# 1 x 1 x 1536
net = slim.dropout(end_points['global_pool'],
dropout,
scope='Dropout_1b')
net = slim.flatten(net, scope='PreLogitsFlatten')
end_points['PreLogitsFlatten'] = net # 1536
# added by Alex Wang for face beauty predict
# mid_full_conn = slim.fully_connected(end_points['PreLogitsFlatten'],
# 1000, activation_fn=tf.nn.relu,
# scope='mid_full_conn',
# trainable=is_training,
# reuse=reuse)
# end_points['mid_full_conn'] = mid_full_conn
predict_conn = slim.fully_connected(end_points['PreLogitsFlatten'],
100,
activation_fn=None,
scope='100_class_conn',
trainable=is_training,
reuse=reuse)
beauty_weight = tf.convert_to_tensor([[i] for i in range(0, 100)],
dtype=tf.float32)
regress_conn = tf.matmul(tf.nn.softmax(predict_conn),
beauty_weight) # 32 * 1
y_pred_softmax = tf.argmax(predict_conn, 1)
correct_prediction = tf.equal(y_pred_softmax, y_input)
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
reg_input_reshape = tf.reshape(reg_input, shape=(batch_size, 1))
# TODO
diff = tf.subtract(tf.cast(reg_input_reshape, tf.float32),
tf.cast(regress_conn, tf.float32))
cost_rmse = tf.reduce_mean(tf.square(diff), name='cost_rmse')
# cost_rmse = tf.reduce_mean(tf.exp(tf.abs(diff)), name='cost_rmse')
## define cost
cost_entropy = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=y_input, logits=predict_conn, name='cross_entropy'))
L2 = 0
for w in tl.layers.get_variables_with_name('InceptionV4', True, True):
L2 += tf.contrib.layers.l2_regularizer(0.0001)(w)
for w in tl.layers.get_variables_with_name('Beauty', True, True):
L2 += tf.contrib.layers.l2_regularizer(0.0001)(w)
# cost = 10000 * cost_entropy + L2 + 0.001 * cost_rmse
# cost = 10 * cost_entropy + L2 + 100 * cost_rmse
# cost = L2 + 0.01 * cost_rmse + 0.01 * cost_entropy
# TODO
cost = L2 + 1000 * cost_rmse
end_points['cost_rmse'] = cost_rmse
end_points['predict'] = y_pred_softmax
end_points['regress_conn'] = regress_conn
end_points['predict_conn'] = predict_conn
end_points['regress_label'] = diff
end_points['predict_softmax'] = tf.nn.softmax(predict_conn)
end_points['beauty_weight'] = beauty_weight
end_points['acc'] = acc
end_points['cost_entropy'] = cost_entropy
end_points['L2'] = L2
end_points['cost'] = cost
return end_points
def build_model(self):
images = self.images
captions = self.captions
batch_size = tf.shape(images)[0]
captions_in = captions[:, :self.T]
captions_out = captions[:, 1:]
# do conv distract feature max
with slim.arg_scope(inception_v4.inception_v4_arg_scope()):
netOut, _ = inception_v4.inception_v4(images,
is_training=True,
dropout_keep_prob=1.0)
features = tf.reshape(netOut, (batch_size, -1, 1536))
# batch normalize feature vectors
with tf.variable_scope('Attention'):
features = self._batch_norm(features,
mode='train',
name='conv_features')
c, h = self._get_initial_lstm(features=features)
x = self._word_embedding(inputs=captions_in)
features_proj = self._project_features(features=features)
loss = 0.0
alpha_list = []
lstm_cell = tf.nn.rnn_cell.DropoutWrapper(
tf.nn.rnn_cell.BasicLSTMCell(num_units=self.H),
output_keep_prob=0.6)
logitLabels = []
for t in range(self.T):
context, alpha = self._attention_layer(features,
features_proj,
h,
reuse=(t != 0))
alpha_list.append(alpha)
if self.selector:
context, beta = self._selector(context, h, reuse=(t != 0))
with tf.variable_scope('lstm', reuse=(t != 0)):
_, (c,
h) = lstm_cell(inputs=tf.concat([x[:, t, :], context],
1),
state=[c, h])
logits = self._decode_lstm(x[:, t, :],
h,
context,
dropout=self.dropout,
reuse=(t != 0))
logitLabels.append(logits)
loss += tf.reduce_sum(
tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=captions_out[:, t], logits=logits))
if self.alpha_c > 0:
alphas = tf.transpose(tf.stack(alpha_list),
(1, 0, 2)) # (N, T, L)
alphas_all = tf.reduce_sum(alphas, 1) # (N, L)
alpha_reg = self.alpha_c * tf.reduce_sum(
(6. / 96 - alphas_all)**2)
loss += alpha_reg
return (logitLabels, loss / tf.to_float(batch_size))
def __init__(self, **kwargs):
super().__init__('inception_v4.ckpt', 'InceptionV4', \
inception_v4.inception_v4_arg_scope(), \
inception_v4.inception_v4, 1, **kwargs)
def __init__(self, weight_file):
self.image_size = inception_v4.inception_v4.default_image_size
config = tf.ConfigProto(log_device_placement=False)
config.gpu_options.allow_growth = True
self.__graph = tf.Graph()
with self.__graph.as_default():
self.__session = tf.Session(config=config, graph=self.__graph)
self.images_placeholder = tf.placeholder(tf.float32,
shape=(None, None, 3),
name='image')
img_process = inception_preprocessing.preprocess_for_eval(
self.images_placeholder,
self.image_size,
self.image_size,
central_fraction=1,
scope='preprocess_test')
img_process = tf.expand_dims(img_process, 0)
arg_scope = inception_v4.inception_v4_arg_scope()
with tf.variable_scope('big', reuse=False) as scope:
with slim.arg_scope(arg_scope):
logits, end_points = inception_v4.inception_v4(
img_process,
is_training=False,
num_classes=1001,
dropout_keep_prob=1.0,
reuse=False,
create_aux_logits=False)
with tf.variable_scope('Beauty', 'BeautyV1',
reuse=False) as scope:
mid_full_conn = slim.fully_connected(
end_points['PreLogitsFlatten'],
1000,
activation_fn=tf.nn.relu,
scope='mid_full_conn',
trainable=False,
reuse=False)
predict_conn = slim.fully_connected(mid_full_conn,
100,
activation_fn=None,
scope='100_class_conn',
trainable=False,
reuse=False)
beauty_weight = tf.convert_to_tensor(
[[i] for i in range(0, 100)], dtype=tf.float32)
regress_conn = tf.matmul(tf.nn.softmax(predict_conn),
beauty_weight) # 32 * 1
self.end_points = {
'mid_full_conn': mid_full_conn,
'regress_conn': regress_conn,
'predict_conn': predict_conn
}
saver = tf.train.Saver(tf.global_variables(), max_to_keep=3)
saver.restore(self.__session, weight_file)
def main(_):
batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3]
num_classes = 1001
itr = 30
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(inception_v4.inception_v4_arg_scope()):
_, end_points = inception_v4.inception_v4(x_input,
num_classes=num_classes,
is_training=False,
create_aux_logits=True)
predicted_labels = tf.argmax(end_points['Predictions'], 1)
# 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):
final_preds = np.zeros(
[FLAGS.batch_size, num_classes, itr])
for j in range(itr):
if np.random.randint(0, 2, size=1) == 1:
images = images[:, :, ::-1, :]
resize_shape_ = np.random.randint(310, 331)
pred, aux_pred = sess.run(
[
end_points['Predictions'],
end_points['AuxPredictions']
],
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
])
})
final_preds[..., j] = pred + 0.4 * aux_pred
#pred = sess.run(end_points['Predictions'],
# 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 = 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])})
final_preds[..., j] = pred
final_probs = np.sum(final_preds, axis=-1)
labels = np.argmax(final_probs, 1)
for filename, label in zip(filenames, labels):
out_file.write('{0},{1}\n'.format(filename, label))
image_pixels = 299
classes = 5
flowers_299x299 = "flowers_299x299"
data = "data"
error = "error"
daisy = "daisy"
dandelion = "dandelion"
roses = "roses"
sunflowers = "sunflowers"
tulips = "tulips"
images = tf.placeholder(tf.float32, [None, image_pixels, image_pixels, 3],
name="input/x_input")
with slim.arg_scope(inception_v4_arg_scope()):
logits, end_points = inception_v4(images,
num_classes=classes,
is_training=False)
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state("ckpt")
if ckpt:
print(ckpt.model_checkpoint_path)
tf.train.Saver().restore(sess, ckpt.model_checkpoint_path)
else:
raise ValueError("The ckpt file is None.")
if os.path.exists(os.path.join(data, tulips)):
shutil.rmtree(os.path.join(data, tulips))
if not os.path.exists(os.path.join(data, tulips)):
os.makedirs(os.path.join(data, tulips))
def feature_extractor(input_tensor, scope_name="FeatureExtractor"):
last_layer_name = 'Mixed_5e'
with tf.contrib.slim.arg_scope(inception_v4.inception_v4_arg_scope()):
inception_output, end_points = inception_v4.inception_v4_base(
input_tensor, final_endpoint=last_layer_name, scope=scope_name)
return inception_output