def build_graph(self, data_paths, batch_size, is_training):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
_, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
parsed = parse_examples(tensors.examples)
# Build a Graph that computes predictions from the inference model.
logits = inference(parsed['images'], self.hidden1, self.hidden2)
# Add to the Graph the Ops for loss calculation.
loss_value = loss(logits, parsed['labels'])
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(
loss_value, self.learning_rate)
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, parsed['labels'])
# HYPERPARAMETER TUNING: Write the objective value.
if not is_training:
# Remove this if once Tensorflow 0.12 is standard.
try:
tf.contrib.deprecated.scalar_summary('accuracy', accuracy_op)
tf.contrib.deprecated.scalar_summary('loss', loss_op)
tf.contrib.deprecated.scalar_summary(
'training/hptuning/metric', accuracy_op)
except AttributeError:
tf.scalar_summary('accuracy', accuracy_op)
tf.scalar_summary('loss', loss_op)
tf.scalar_summary('training/hptuning/metric', accuracy_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
def build_graph(self, data_paths, batch_size, is_training):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
_, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
parsed = parse_examples(tensors.examples)
# Build a Graph that computes predictions from the inference model.
#logits = inference(parsed['images'], self.hidden1, self.hidden2)
logits = inference(parsed['images'], self.hidden1, self.hidden2)
# Add to the Graph the Ops for loss calculation.
loss_value = loss(logits, parsed['labels'])
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value,
self.learning_rate)
else:
tensors.global_step = tf.Variable(0, name='global_step', trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, parsed['labels'])
if not is_training:
# Remove this if once Tensorflow 0.12 is standard.
try:
tf.contrib.deprecated.scalar_summary('accuracy', accuracy_op)
tf.contrib.deprecated.scalar_summary('loss', loss_op)
except AttributeError:
tf.scalar_summary('accuracy', accuracy_op)
tf.scalar_summary('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
#trained_filename, model_params, words_to_ids, ids_to_words = train_attack_model(training_samples=20000, test_samples=5000, review_path = '/home/kalvin_kao/yelp_challenge_dataset/review.csv')
#generate_text(trained_filename, model_params, words_to_ids, ids_to_words)
def build_graph(self, data_paths, batch_size, is_training):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
_, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
parsed = parse_examples(tensors.examples)
# Build a Graph that computes predictions from the inference model.
logits = inference(parsed['images'], self.hidden1, self.hidden2)
# Add to the Graph the Ops for loss calculation.
loss_value = loss(logits, parsed['labels'])
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(
loss_value, self.learning_rate)
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, parsed['labels'])
if not is_training:
# TODO(b/33420312): remove the if once 0.12 is fully rolled out to prod.
if tf.__version__ < '0.12':
tf.scalar_summary('accuracy', accuracy_op)
tf.scalar_summary('loss', loss_op)
else:
tf.contrib.deprecated.scalar_summary('accuracy', accuracy_op)
tf.contrib.deprecated.scalar_summary('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
def build_graph(self, data_paths, batch_size, is_training):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
_, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
parsed = parse_examples(tensors.examples)
# Build a Graph that computes predictions from the inference model.
logits = inference(parsed['images'], self.hidden1, self.hidden2)
# Add to the Graph the Ops for loss calculation.
loss_value = loss(logits, parsed['labels'])
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value,
self.learning_rate)
else:
tensors.global_step = tf.Variable(0, name='global_step', trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, parsed['labels'])
if not is_training:
# Remove this if once Tensorflow 0.12 is standard.
try:
tf.contrib.deprecated.scalar_summary('accuracy', accuracy_op)
tf.contrib.deprecated.scalar_summary('loss', loss_op)
except AttributeError:
tf.scalar_summary('accuracy', accuracy_op)
tf.scalar_summary('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
def build_graph(self, data_paths, batch_size, graph_mod):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
is_training = graph_mod == GraphMod.TRAIN
if data_paths:
_, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
else:
tensors.examples = tf.placeholder(tf.string,
name='input',
shape=(None, ))
if graph_mod == GraphMod.PREDICT:
inception_input, inception_embeddings = self.build_inception_graph(
)
# Build the Inception graph. We later add final training layers
# to this graph. This is currently used only for prediction.
# For training, we use pre-processed data, so it is not needed.
embeddings = inception_embeddings
tensors.input_jpeg = inception_input
else:
# For training and evaluation we assume data is preprocessed, so the
# inputs are tf-examples.
# Generate placeholders for examples.
with tf.name_scope('inputs'):
feature_map = {
'image_uri':
tf.FixedLenFeature(shape=[],
dtype=tf.string,
default_value=['']),
# Some images may have no labels. For those, we assume a default
# label. So the number of labels is label_count+1 for the default
# label.
'label':
tf.FixedLenFeature(shape=[1],
dtype=tf.int64,
default_value=[self.label_count]),
'embedding':
tf.FixedLenFeature(shape=[BOTTLENECK_TENSOR_SIZE],
dtype=tf.float32)
}
parsed = tf.parse_example(tensors.examples,
features=feature_map)
labels = tf.squeeze(parsed['label'])
uris = tf.squeeze(parsed['image_uri'])
embeddings = parsed['embedding']
# We assume a default label, so the total number of labels is equal to
# label_count+1.
all_labels_count = self.label_count + 1
with tf.name_scope('final_ops'):
softmax, logits = self.add_final_training_ops(
embeddings,
all_labels_count,
BOTTLENECK_TENSOR_SIZE,
dropout_keep_prob=self.dropout if is_training else None)
# Prediction is the index of the label with the highest score. We are
# interested only in the top score.
prediction = tf.argmax(softmax, 1)
tensors.predictions = [prediction, softmax, embeddings]
if graph_mod == GraphMod.PREDICT:
return tensors
with tf.name_scope('evaluate'):
loss_value = loss(logits, labels)
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value)
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
tensors.uris = uris
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, labels)
if not is_training:
tf.summary.scalar('accuracy', accuracy_op)
tf.summary.scalar('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
def build_graph(self,
data_paths,
batch_size,
graph_mod,
l1_size,
imap,
omap,
reduce1x1,
dropout_prob=None):
tensors = GraphReferences()
is_training = graph_mod == GraphMod.TRAIN
if data_paths:
tensors.keys, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
else:
tensors.examples = tf.placeholder(tf.string,
name='input',
shape=(None, ))
if graph_mod != GraphMod.PREDICT:
with tf.name_scope('data'):
feature_map = {
'height': tf.FixedLenFeature(shape=1, dtype=tf.int64),
'kspace': tf.FixedLenFeature(shape=1, dtype=tf.string),
'width': tf.FixedLenFeature(shape=1, dtype=tf.int64),
'xspace': tf.FixedLenFeature(shape=1, dtype=tf.string)
}
parsed = tf.parse_example(tensors.examples,
features=feature_map)
inputs, outputs = self.decode(parsed['kspace'],
batch_size,
xspace=parsed['xspace'])
if graph_mod == GraphMod.PREDICT:
inputs = tf.placeholder(tf.float32, shape=(IMAGE_SIZE))
tensors.inputs = inputs
with tf.name_scope('network'):
layer1 = self.build_input_layer(inputs,
l1_size,
dropout_keep_prob=dropout_prob)
inception1 = self.build_inception_layer(layer1, imap[0], omap[0],
reduce1x1[0])
inception2 = self.build_inception_layer(inception1, imap[1],
omap[1], reduce1x1[1])
final = self.build_final_layer(inception2)
if graph_mod == GraphMod.PREDICT:
tensors.predictions = [final]
return tensors
with tf.name_scope('evaluate'):
loss_value = loss(final, outputs)
if is_training:
tensors.train, tensors.global_step = training(loss_value)
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
loss_updates, loss_op = util.loss(loss_value)
#accuracy_updates, accuracy_op = util.accuracy(final, outputs)
if not is_training:
# tf.summary.scalar('accuracy', accuracy_op)
tf.summary.scalar('loss', loss_op)
tensors.metric_updates = loss_updates # + accuracy_updates
tensors.metric_values = [loss_op] #, accuracy_op]
return tensors
def build_graph(self, data_paths, batch_size, max_time, is_training):
"""Construct the core RNNLM graph, needed for any use of the model.
This should include:
- Placeholders for input tensors (input_w_, initial_h_, target_y_)
- Variables for model parameters
- Tensors representing various intermediate states
- A Tensor for the final state (final_h_)
- A Tensor for the output logits (logits_), i.e. the un-normalized argument
of the softmax(...) function in the output layer.
- A scalar loss function (loss_)
Your loss function should be a *scalar* value that represents the
_average_ loss across all examples in the batch (i.e. use tf.reduce_mean,
not tf.reduce_sum).
You shouldn't include training or sampling functions here; you'll do
this in BuildTrainGraph and BuildSampleGraph below.
We give you some starter definitions for input_w_ and target_y_, as
well as a few other tensors that might help. We've also added dummy
values for initial_h_, logits_, and loss_ - you should re-define these
in your code as the appropriate tensors.
See the in-line comments for more detail.
"""
tensors = GraphReferences()
to_pass = GraphIntermediates()
#_, tensors.examples = util.read_examples(
#data_paths,
#batch_size,
#shuffle=is_training,
#num_epochs=None if is_training else 2)
# Input ids, with dynamic shape depending on input.
# Should be shape [batch_size, max_time] and contain integer word indices.
self.input_w_ = tf.placeholder(tf.int32, [None, None], name="w")
self.initial_h_ = None
self.final_h_ = None
# Overwrite this with an actual Tensor of shape
# [batch_size, max_time, V].
self.logits_ = None
#tf.placeholder(tf.int32, [self.batch_size_, self.max_time_, self.V], name="logits")
#tf.Variable(tf.random_normal([self.batch_size_, self.max_time_, self.V]), name="logits")
# Should be the same shape as inputs_w_
self.target_y_ = tf.placeholder(tf.int32, [None, None], name="y")
#tf.placeholder(tf.int32, [None, None], name="y")
# Replace this with an actual loss function
self.loss_ = None
#tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.labels_, logits=self.logits_),0)#don't forget last parameter
# Get dynamic shape info from inputs
with tf.name_scope("batch_size"):
self.batch_size_ = tf.shape(self.input_w_)[0]
with tf.name_scope("max_time"):
self.max_time_ = tf.shape(self.input_w_)[1]
#self.batch_size_ = batch_size
#self.max_time_ = max_time
#_, tensors.examples = util.read_examples(
#data_paths,
#batch_size=self.batch_size_,
#shuffle=is_training,
#num_epochs=None if is_training else 2)
# Get sequence length from input_w_.
# TL;DR: pass this to dynamic_rnn.
# This will be a vector with elements ns[i] = len(input_w_[i])
# You can override this in feed_dict if you want to have different-length
# sequences in the same batch, although you shouldn't need to for this
# assignment.
self.ns_ = tf.tile([self.max_time_], [
self.batch_size_,
], name="ns") #update this for project
with tf.name_scope("embedding_layer"):
self.W_in_ = tf.get_variable(
"W_in",
shape=[self.V, self.H],
initializer=tf.random_uniform_initializer(minval=-1.0,
maxval=1.0))
self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)
# Construct RNN/LSTM cell and recurrent layer.
with tf.name_scope("recurrent_layer"):
self.cell_ = MakeFancyRNNCell(self.H, self.dropout_keep_prob_,
self.num_layers)
self.initial_h_ = self.cell_.zero_state(self.batch_size_,
tf.float32)
self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(
self.cell_,
inputs=self.x_,
sequence_length=self.ns_,
initial_state=self.initial_h_,
dtype=tf.float32)
with tf.name_scope("softmax_output_layer"):
self.W_out_ = tf.get_variable(
"W_out",
shape=[self.H, self.V],
initializer=tf.random_uniform_initializer(minval=-1.0,
maxval=1.0))
self.b_out_ = tf.get_variable("b_out",
shape=[
self.V,
],
initializer=tf.zeros_initializer())
self.logits_ = tf.add(matmul3d(self.outputs_, self.W_out_),
self.b_out_,
name="logits")
## Loss computation (true loss, for prediction)
#with tf.name_scope("loss_computation"):
#per_example_loss_ = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.target_y_,
#logits=self.logits_,
#name="per_example_loss")
#self.loss_ = tf.reduce_mean(per_example_loss_, name="loss")
with tf.name_scope("loss_computation"):
per_example_loss_ = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=self.target_y_,
logits=self.logits_,
name="per_example_loss")
self.loss_ = tf.reduce_mean(per_example_loss_, name="loss")
# Add to the Graph the Ops that calculate and apply gradients.
# Replace this with an actual training op
self.train_step_ = None
# Replace this with an actual loss function
self.train_loss_ = None
with tf.name_scope("training_loss_function"):
per_example_train_loss_ = tf.nn.sampled_softmax_loss(
weights=tf.transpose(self.W_out_),
biases=self.b_out_,
labels=tf.reshape(self.target_y_,
[self.batch_size_ * self.max_time_, 1]),
inputs=tf.reshape(self.outputs_,
[self.batch_size_ * self.max_time_, self.H]),
num_sampled=self.softmax_ns,
num_classes=self.V,
name="per_example_sampled_softmax_loss")
#partition_strategy="div" ???
self.train_loss_ = tf.reduce_mean(per_example_train_loss_,
name="sampled_softmax_loss")
with tf.name_scope("optimizer_and_training_op"):
global_step = tf.Variable(0, name='global_step', trainable=False)
optimizer_ = tf.train.AdamOptimizer(
learning_rate=self.learning_rate_)
gradients, v = zip(*optimizer_.compute_gradients(self.train_loss_))
gradients, _ = tf.clip_by_global_norm(gradients,
self.max_grad_norm_)
self.train_step_ = optimizer_.apply_gradients(
zip(gradients, v), global_step=global_step)
self.pred_samples_ = None
with tf.name_scope("sampling_ops"):
self.pred_samples_ = tf.multinomial(tf.reshape(
self.logits_, [-1, self.logits_.get_shape()[-1]]),
1,
name="pred_samples")
self.pred_samples_ = tf.reshape(
self.pred_samples_, [self.batch_size_, self.max_time_, 1])
if is_training:
tensors.train = self.train_step_
tensors.global_step = global_step
loss_value = self.train_loss_
#use_dropout = True
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
loss_value = self.loss_
#use_dropout = False
#tensors.train = tf.no_op()
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
#accuracy_updates, accuracy_op = util.accuracy(self.logits_, parsed['labels'])
if not is_training:
# Remove this if once Tensorflow 0.12 is standard.
try:
#tf.contrib.deprecated.scalar_summary('accuracy', accuracy_op)
tf.contrib.deprecated.scalar_summary('loss', loss_op)
except AttributeError:
#tf.scalar_summary('accuracy', accuracy_op)
tf.scalar_summary('loss', loss_op)
#tensors.metric_updates = loss_updates + accuracy_updates
#tensors.metric_values = [loss_op, accuracy_op]
tensors.metric_updates = loss_updates
tensors.metric_values = [loss_op]
to_pass.loss = loss_value
to_pass.final_h = self.final_h_
to_pass.inital_h = self.initial_h_
return tensors, to_pass
def build_graph(self, data_paths, batch_size, graph_mod):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
is_training = graph_mod == GraphMod.TRAIN
if data_paths:
tensors.keys, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
else:
tensors.examples = tf.placeholder(tf.string, name='input', shape=(None,))
if graph_mod == GraphMod.PREDICT:
inception_input, inception_embeddings = self.build_inception_graph()
# Build the Inception graph. We later add final training layers
# to this graph. This is currently used only for prediction.
# For training, we use pre-processed data, so it is not needed.
embeddings = inception_embeddings
tensors.input_jpeg = inception_input
else:
# For training and evaluation we assume data is preprocessed, so the
# inputs are tf-examples.
# Generate placeholders for examples.
with tf.name_scope('inputs'):
feature_map = {
'image_uri':
tf.FixedLenFeature(
shape=[], dtype=tf.string, default_value=['']),
# Some images may have no labels. For those, we assume a default
# label. So the number of labels is label_count+1 for the default
# label.
'label':
tf.FixedLenFeature(
shape=[1], dtype=tf.int64,
default_value=[self.label_count]),
'embedding':
tf.FixedLenFeature(
shape=[BOTTLENECK_TENSOR_SIZE], dtype=tf.float32)
}
parsed = tf.parse_example(tensors.examples, features=feature_map)
labels = tf.squeeze(parsed['label'])
uris = tf.squeeze(parsed['image_uri'])
embeddings = parsed['embedding']
# We assume a default label, so the total number of labels is equal to
# label_count+1.
all_labels_count = self.label_count + 1
with tf.name_scope('final_ops'):
softmax, logits = self.add_final_training_ops(
embeddings,
all_labels_count,
BOTTLENECK_TENSOR_SIZE,
dropout_keep_prob=self.dropout if is_training else None)
# Prediction is the index of the label with the highest score. We are
# interested only in the top score.
prediction = tf.argmax(softmax, 1)
tensors.predictions = [prediction, softmax, embeddings]
if graph_mod == GraphMod.PREDICT:
return tensors
with tf.name_scope('evaluate'):
loss_value = loss(logits, labels)
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value)
else:
tensors.global_step = tf.Variable(0, name='global_step', trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, labels)
if not is_training:
tf.summary.scalar('accuracy', accuracy_op)
tf.summary.scalar('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
def build_graph(self, data_paths, batch_size, graph_mod):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
is_training = graph_mod == GraphMod.TRAIN
tf.keras.backend.set_learning_phase(1 if is_training else 0)
if data_paths:
tensors.keys, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
else:
tensors.examples = tf.placeholder(tf.string, name='input', shape=(None,))
if graph_mod == GraphMod.PREDICT:
inception_input, inception_embeddings = self.build_inception_graph()
image_embeddings = inception_embeddings
title_embeddings = tf.placeholder(tf.float32, shape=[None, TITLE_EMBEDDING_SIZE])
title_words_count = tf.placeholder(tf.int64, shape=[None])
content_embeddings = tf.placeholder(tf.float32, shape=[None, CONTENT_EMBEDDING_SIZE])
content_words_count = tf.placeholder(tf.int64, shape=[None])
title_word_chars = tf.placeholder(tf.string, shape=[None, TITLE_WORD_CHARS_SIZE])
content_word_chars = tf.placeholder(tf.string, shape=[None, CONTENT_WORD_CHARS_SIZE])
title_word_char_lengths = tf.placeholder(tf.int64, shape=[None, TITLE_WORD_SIZE])
content_word_char_lengths = tf.placeholder(tf.int64, shape=[None, CONTENT_WORD_SIZE])
category_ids = tf.placeholder(tf.int64, shape=[None])
price = tf.placeholder(tf.int64, shape=[None])
images_count = tf.placeholder(tf.int64, shape=[None])
recent_articles_count = tf.placeholder(tf.int64, shape=[None])
title_length = tf.placeholder(tf.int64, shape=[None])
content_length = tf.placeholder(tf.int64, shape=[None])
blocks_inline = tf.placeholder(tf.string, shape=[None])
username_chars = tf.placeholder(tf.string, shape=[None, USERNAME_CHAR_SIZE])
username_length = tf.placeholder(tf.int64, shape=[None])
created_at_ts = tf.placeholder(tf.int64, shape=[None])
offerable = tf.placeholder(tf.int64, shape=[None])
tensors.input_image = inception_input
tensors.input_title = title_embeddings
tensors.input_title_words_count = title_words_count
tensors.input_content = content_embeddings
tensors.input_content_words_count = content_words_count
tensors.input_category_id = category_ids
tensors.input_price = price
tensors.input_images_count = images_count
tensors.input_recent_articles_count = recent_articles_count
tensors.input_title_length = title_length
tensors.input_content_length = content_length
tensors.input_blocks_inline = blocks_inline
tensors.input_username_chars = username_chars
tensors.input_username_length = username_length
tensors.input_created_at_ts = created_at_ts
tensors.input_offerable = offerable
tensors.input_title_word_chars = title_word_chars
tensors.input_content_word_chars = content_word_chars
tensors.input_title_word_char_lengths = title_word_char_lengths
tensors.input_content_word_char_lengths = content_word_char_lengths
username_chars = tf.reshape(username_chars, [-1, USERNAME_CHAR_SIZE])
else:
# For training and evaluation we assume data is preprocessed, so the
# inputs are tf-examples.
# Generate placeholders for examples.
with tf.name_scope('inputs'):
feature_map = {
'id':
tf.FixedLenFeature(
shape=[], dtype=tf.string, default_value=['']),
# Some images may have no labels. For those, we assume a default
# label. So the number of labels is label_count+1 for the default
# label.
'label':
tf.FixedLenFeature(
shape=[1], dtype=tf.int64,
default_value=[self.label_count]),
'embedding':
tf.FixedLenFeature(
shape=[BOTTLENECK_TENSOR_SIZE], dtype=tf.float32),
'title_embedding':
tf.FixedLenFeature(
shape=[TITLE_EMBEDDING_SIZE], dtype=tf.float32),
'title_words_count':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'content_embedding':
tf.FixedLenFeature(
shape=[CONTENT_EMBEDDING_SIZE], dtype=tf.float32),
'content_words_count':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'category_id':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'price':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'images_count':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'recent_articles_count':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'title_length':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'content_length':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'blocks_inline':
tf.FixedLenFeature(shape=[], dtype=tf.string),
'username_chars':
tf.FixedLenFeature(shape=[USERNAME_CHAR_SIZE], dtype=tf.string),
'username_length':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'created_at_ts':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'offerable':
tf.FixedLenFeature(shape=[], dtype=tf.int64),
'title_word_chars':
tf.FixedLenFeature(shape=[TITLE_WORD_CHARS_SIZE], dtype=tf.string),
'content_word_chars':
tf.FixedLenFeature(shape=[CONTENT_WORD_CHARS_SIZE], dtype=tf.string),
'title_word_char_lengths':
tf.FixedLenFeature(shape=[TITLE_WORD_SIZE], dtype=tf.int64),
'content_word_char_lengths':
tf.FixedLenFeature(shape=[CONTENT_WORD_SIZE], dtype=tf.int64),
}
parsed = tf.parse_example(tensors.examples, features=feature_map)
labels = tf.squeeze(parsed['label'])
tensors.labels = labels
tensors.ids = tf.squeeze(parsed['id'])
image_embeddings = parsed['embedding']
title_embeddings = parsed['title_embedding']
title_words_count = parsed['title_words_count']
content_embeddings = parsed['content_embedding']
content_words_count = parsed['content_words_count']
category_ids = parsed['category_id']
price = parsed['price']
images_count = parsed['images_count']
recent_articles_count = parsed['recent_articles_count']
title_length = parsed['title_length']
content_length = parsed['content_length']
blocks_inline = parsed['blocks_inline']
username_chars = parsed['username_chars']
username_length = parsed['username_length']
created_at_ts = parsed['created_at_ts']
offerable = parsed['offerable']
title_word_chars = parsed['title_word_chars']
content_word_chars = parsed['content_word_chars']
title_word_char_lengths = parsed['title_word_char_lengths']
content_word_char_lengths = parsed['content_word_char_lengths']
dropout_keep_prob = self.dropout if is_training else None
if self.rnn_type == 'LSTM':
if tf.test.gpu_device_name():
base_cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell
else:
base_cell = tf.contrib.rnn.BasicLSTMCell
else:
if tf.test.gpu_device_name():
base_cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell
else:
base_cell = tf.contrib.rnn.GRUCell
def dropout(x, keep_prob):
if keep_prob:
return tf.nn.dropout(x, keep_prob)
return x
if self.args.l2_reg_scale > 0.:
regularizer = tf.contrib.layers.l2_regularizer(self.args.l2_reg_scale)
else:
regularizer = None
def dense(x, units):
for unit in units:
if self.activation == 'maxout':
x = layers.fully_connected(x, unit, activation_fn=None,
weights_regularizer=regularizer)
x = tf.contrib.layers.maxout(x, unit)
x = tf.reshape(x, [-1, unit])
elif self.activation == 'none':
x = layers.fully_connected(x, unit,
weights_regularizer=regularizer,
normalizer_fn=tf.contrib.layers.batch_norm,
normalizer_params={'is_training': is_training})
else:
x = layers.fully_connected(x, unit, weights_regularizer=regularizer)
x = dropout(x, dropout_keep_prob)
return x
def shallow_and_wide_cnn(inputs, filters, kernel_sizes):
outputs = []
for kernel_size in kernel_sizes:
conv = tf.layers.conv1d(inputs, filters, kernel_size, padding="same",
kernel_regularizer=regularizer)
conv = tf.layers.batch_normalization(conv, training=is_training)
conv = tf.nn.relu(conv)
conv = GlobalMaxPooling1D()(conv)
outputs.append(conv)
output = tf.concat(outputs, 1)
return dropout(output, dropout_keep_prob)
def get_word_chars(table, char_embedding, word_chars, char_lengths, word_size):
word_chars = tf.reshape(word_chars, [-1, word_size, WORD_CHAR_SIZE])
char_ids = table.lookup(word_chars)
x = char_embedding(char_ids)
mask = tf.sequence_mask(char_lengths, WORD_CHAR_SIZE, dtype=tf.float32)
mask = tf.expand_dims(mask, 3) # [batch, seq_len, char_dim, 1]
x = x * mask
x = tf.reshape(x, [-1, WORD_CHAR_SIZE, CHAR_DIM]) # [batch * word_size, word_char_size, char_dim]
if self.args.word_char_type == 'cnn':
filters = 16
output = shallow_and_wide_cnn(x, filters, [1,2,3])
last_states = output
else:
length = tf.reshape(char_lengths, [-1])
outputs, last_states = stack_bidirectional_dynamic_rnn(x, [CHAR_DIM],
length, dropout_keep_prob=dropout_keep_prob,
cell_wrapper=self.rnn_cell_wrapper,
variational_recurrent=self.variational_recurrent,
base_cell=base_cell,
is_training=is_training)
return tf.reshape(last_states, [-1, word_size, CHAR_DIM*2]) # [batch, word_size, char_dim*2]
if self.args.word_char_type != 'none':
with tf.variable_scope("word_chars", reuse=tf.AUTO_REUSE):
table = tf.contrib.lookup.index_table_from_tensor(
mapping=tf.constant(self.text_chars),
default_value=len(self.text_chars))
char_dict_size = len(self.text_chars) + 1 # add unknown char
char_embedding = Embedding(char_dict_size, CHAR_DIM)
title_word_chars = get_word_chars(table, char_embedding,
title_word_chars, title_word_char_lengths, TITLE_WORD_SIZE)
content_word_chars = get_word_chars(table, char_embedding,
content_word_chars, content_word_char_lengths, CONTENT_WORD_SIZE)
with tf.variable_scope("username"):
table = tf.contrib.lookup.index_table_from_tensor(
mapping=tf.constant(self.username_chars),
default_value=len(self.username_chars))
char_ids = table.lookup(username_chars)
char_dict_size = len(self.username_chars) + 1 # add unknown char
x = Embedding(char_dict_size, CHAR_DIM)(char_ids)
mask = tf.sequence_mask(username_length, USERNAME_CHAR_SIZE, dtype=tf.float32)
x = x * tf.expand_dims(mask, 2)
if self.username_type == 'dense':
username = tf.reshape(x, [-1, USERNAME_CHAR_SIZE * CHAR_DIM])
username = dense(username, [30, 30])
elif self.username_type == 'cnn':
def conv_username(x, filters):
k3 = tf.layers.conv1d(x, filters, 3)
k3 = tf.nn.relu(k3)
k3 = tf.layers.max_pooling1d(k3, 3, 3)
k3 = tf.layers.conv1d(k3, filters, 3)
k3 = tf.nn.relu(k3)
k2 = tf.layers.conv1d(x, filters, 2)
k2 = tf.nn.relu(k2)
k2 = tf.layers.max_pooling1d(k2, 2, 2)
k2 = tf.layers.conv1d(k2, filters, 2, strides=2)
k2 = tf.nn.relu(k2)
k2 = tf.layers.max_pooling1d(k2, 2, 2)
k1 = tf.layers.conv1d(x, filters, 1)
k1 = tf.nn.relu(k1)
k1 = tf.layers.max_pooling1d(k1, 3, 3)
k1 = tf.layers.conv1d(k1, filters, 2, strides=2)
k1 = tf.nn.relu(k1)
k1 = tf.layers.max_pooling1d(k1, 2, 2)
x = tf.concat([k1, k2, k3], 2)
x = tf.reshape(x, [-1, filters * 3])
return tf.layers.batch_normalization(x, training=is_training)
filters = 10
#username = shallow_and_wide_cnn(x, filters, [1,2,3])
username = conv_username(x, filters)
elif self.username_type == 'rnn':
outputs, last_states = stack_bidirectional_dynamic_rnn(x, [CHAR_DIM],
username_length, dropout_keep_prob=dropout_keep_prob,
cell_wrapper=self.rnn_cell_wrapper,
variational_recurrent=self.variational_recurrent,
base_cell=base_cell,
is_training=is_training)
username = last_states
elif self.username_type == 'none':
username = None
else:
raise Exception('Invaild username_type: %s' % self.username_type)
with tf.variable_scope("user"):
recent_articles_count = tf.minimum(recent_articles_count, 300)
recent_articles_count = tf.expand_dims(recent_articles_count, 1)
recent_articles_count = tf.to_int32(recent_articles_count)
blocks = blocks_inline_to_matrix(blocks_inline)
blocks = tf.minimum(blocks, 50)
user = tf.concat([recent_articles_count#, blocks
], 1)
user = tf.cast(user, tf.float32)
user = tf.layers.batch_normalization(user, training=is_training)
user = dropout(user, dropout_keep_prob)
with tf.variable_scope("category"):
category_ids = tf.minimum(category_ids - 1, TOTAL_CATEGORIES_COUNT - 1)
category = Embedding(TOTAL_CATEGORIES_COUNT, 10)(category_ids)
category = dropout(category, dropout_keep_prob)
with tf.variable_scope("continuous"):
price = tf.minimum(price, 1000000000)
title_length = tf.minimum(title_length, 100)
content_length = tf.minimum(content_length, 3000)
created_time = tf.mod(created_at_ts, DAY_TIME)
day = tf.mod(created_at_ts / DAY_TIME, 7)
continuous = tf.stack([price, images_count, title_length,
content_length#, offerable, created_time, day
], 1)
continuous = tf.cast(continuous, tf.float32)
continuous = tf.concat([continuous, tf.square(continuous)], 1)
continuous = tf.layers.batch_normalization(continuous, training=is_training)
continuous = dropout(continuous, dropout_keep_prob)
with tf.variable_scope("image"):
image_embeddings = dense(image_embeddings, [256])
with tf.variable_scope('bunch'):
bunch = tf.concat([image_embeddings, category, continuous, user], 1)
if self.username_type != 'none':
bunch = tf.concat([bunch, username], 1)
if self.args.word_char_type != 'none':
word_dim = CHAR_WORD_DIM
else:
word_dim = WORD_DIM
with tf.variable_scope('title'):
initial_state = dense(bunch, [word_dim*2])
layer_sizes = [word_dim * (2**i) for i in range(max(1, self.rnn_layers_count-1))]
title_embeddings = tf.reshape(title_embeddings, [-1, TITLE_WORD_SIZE, WORD_DIM])
if self.args.word_char_type != 'none':
title_embeddings = tf.concat([title_embeddings, title_word_chars], -1)
title_outputs, title_last_states = stack_bidirectional_dynamic_rnn(title_embeddings, layer_sizes,
title_words_count, initial_state=initial_state,
cell_wrapper=self.rnn_cell_wrapper, variational_recurrent=self.variational_recurrent,
base_cell=base_cell, dropout_keep_prob=dropout_keep_prob, is_training=is_training)
with tf.variable_scope('content'):
bunch = tf.concat([bunch, title_last_states], 1)
initial_state = dense(bunch, [192, word_dim*2])
layer_sizes = [word_dim * (2**i) for i in range(self.rnn_layers_count)]
content_embeddings = tf.reshape(content_embeddings, [-1, CONTENT_WORD_SIZE, WORD_DIM])
if self.args.word_char_type != 'none':
content_embeddings = tf.concat([content_embeddings, content_word_chars], -1)
content_outputs, content_last_states = stack_bidirectional_dynamic_rnn(content_embeddings, layer_sizes,
content_words_count, initial_state=initial_state,
cell_wrapper=self.rnn_cell_wrapper, variational_recurrent=self.variational_recurrent,
base_cell=base_cell, dropout_keep_prob=dropout_keep_prob, is_training=is_training)
with tf.variable_scope('final_ops'):
hidden = tf.concat([bunch, content_last_states], 1)
if self.final_layers_count > 0:
hidden = dense(hidden, [192] + [64] * (self.final_layers_count-1))
softmax, logits = self.add_final_training_ops(hidden, self.label_count)
# Prediction is the index of the label with the highest score. We are
# interested only in the top score.
prediction = tf.argmax(logits, 1)
tensors.predictions = [prediction, softmax]
if graph_mod == GraphMod.PREDICT:
return tensors
def is_l2_var_name(name):
for token in ['bias', 'table', 'BatchNorm']:
if token in name:
return False
return True
with tf.name_scope('evaluate'):
loss_value = loss(logits, labels)
#l2_loss = tf.add_n([ tf.nn.l2_loss(v) for v in tf.trainable_variables() if is_l2_var_name(v.name) ])
#loss_value += l2_loss * 0.001
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value)
else:
tensors.global_step = tf.Variable(0, name='global_step', trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, labels)
all_precision_op, all_precision_update = tf.metrics.precision(labels, prediction)
all_recall_op, all_recall_update = tf.metrics.recall(labels, prediction)
precision = {'ops': [], 'updates': []}
recall = {'ops': [], 'updates': []}
with tf.name_scope('metrics'):
for i in range(self.label_count):
op, update = tf.metrics.recall_at_k(labels, logits, 1, class_id=i)
recall['ops'].append(op)
recall['updates'].append(update)
op, update = tf.metrics.precision_at_k(labels, logits, 1, class_id=i)
precision['ops'].append(op)
precision['updates'].append(update)
if not is_training:
tf.summary.scalar('accuracy', accuracy_op, family='general')
tf.summary.scalar('loss', loss_op, family='general')
tf.summary.scalar('precision', all_precision_op, family='general')
tf.summary.scalar('recall', all_recall_op, family='general')
for i in range(self.label_count):
label_name = self.labels[i]
tf.summary.scalar('%s' % label_name, recall['ops'][i], family='recall')
tf.summary.scalar('%s' % label_name, precision['ops'][i], family='precision')
tensors.metric_updates = loss_updates + accuracy_updates + \
[all_precision_update, all_recall_update] + \
recall['updates'] + precision['updates']
tensors.metric_values = [loss_op, accuracy_op, all_precision_op, all_recall_op]
return tensors
def build_graph(self, data_paths, batch_size, graph_mod):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
is_training = graph_mod == GraphMod.TRAIN
if data_paths:
tensors.keys, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
else:
logging.info("No data path")
tensors.examples = tf.placeholder(tf.string,
name='input',
shape=(None, ))
if graph_mod == GraphMod.PREDICT:
pass
else:
# For training and evaluation we assume data is preprocessed, so the
# inputs are tf-examples.
# Generate placeholders for examples.
with tf.name_scope('inputs'):
feature_map = {
'image_uri':
tf.FixedLenFeature(shape=[],
dtype=tf.string,
default_value=['']),
'image_bytes':
tf.FixedLenFeature(shape=[],
dtype=tf.string,
default_value=['']),
'label':
tf.FixedLenFeature(shape=[1],
dtype=tf.int64,
default_value=[self.label_count])
}
#tensors.examples = tf.Print(tensors.examples, [tf.shape(tensors.examples)], message="Parsing examples: ")
parsed = tf.parse_example(tensors.examples,
features=feature_map)
labels = tf.squeeze(parsed['label'])
uris = tf.squeeze(parsed['image_uri'])
images_str_tensor = parsed['image_bytes']
def decode_and_resize(image_str_tensor):
"""Decodes jpeg string, resizes it and returns a uint8 tensor."""
image = tf.image.decode_jpeg(image_str_tensor, channels=1)
# Note resize expects a batch_size, but tf_map supresses that index,
# thus we have to expand then squeeze. Resize returns float32 in the
# range [0, uint8_max]
"""
image = tf.expand_dims(image, 0)
image = tf.image.resize_bilinear(
image, [height, width], align_corners=False)*/
image = tf.squeeze(image, squeeze_dims=[0])
"""
image = tf.cast(image, dtype=tf.uint8)
# convert_image_dtype, also scales [0, uint8_max] -> [0 ,1).
return tf.image.convert_image_dtype(image, dtype=tf.float32)
#images_str_tensor = tf.Print(images_str_tensor, [tf.shape(images_str_tensor)], message="Decoding images: ")
images = tf.map_fn(decode_and_resize,
images_str_tensor,
back_prop=False,
dtype=tf.float32)
# We assume a default label, so the total number of labels is equal to
# label_count+1.
all_labels_count = self.label_count + 1
with tf.name_scope('model'):
fc_padding = 'VALID'
with tf.variable_scope('model', 'vgg_16', [images]) as sc:
end_points_collection = sc.original_name_scope + '_end_points'
# Collect outputs for conv2d, fully_connected and max_pool2d.
with slim.arg_scope(
[slim.conv2d, slim.fully_connected, slim.max_pool2d],
outputs_collections=end_points_collection):
# images = tf.Print(images, [tf.shape(images)], message="Shape of input: ", summarize=4)
net = slim.repeat(images,
2,
slim.conv2d,
64, [3, 3],
scope='conv1')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='conv1')
net = slim.max_pool2d(net, [2, 2], scope='pool1')
net = slim.repeat(net,
2,
slim.conv2d,
128, [3, 3],
scope='conv2')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='conv2')
net = slim.max_pool2d(net, [2, 2], scope='pool2')
net = slim.repeat(net,
3,
slim.conv2d,
256, [3, 3],
scope='conv3')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='conv3')
net = slim.max_pool2d(net, [2, 2], scope='pool3')
net = slim.repeat(net,
3,
slim.conv2d,
512, [3, 3],
scope='conv4')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='conv4')
net = slim.max_pool2d(net, [2, 2], scope='pool4')
net = slim.repeat(net,
3,
slim.conv2d,
512, [3, 3],
scope='conv5')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='conv5')
net = slim.max_pool2d(net, [2, 2], scope='pool5')
# Use conv2d instead of fully_connected layers.
net = slim.conv2d(net,
4096, [7, 7],
padding=fc_padding,
scope='fc6')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='fc6')
net = slim.dropout(net,
0.5,
is_training=True,
scope='dropout6')
net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='fc7')
# Convert end_points_collection into a end_point dict.
end_points = slim.utils.convert_collection_to_dict(
end_points_collection)
net = slim.dropout(net,
0.5,
is_training=True,
scope='dropout7')
net = slim.conv2d(net,
all_labels_count, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope='fc8')
#net = tf.Print(net, [tf.shape(net)], summarize=4, message='fc8')
net = tf.squeeze(net, [1, 2], name='fc8/squeezed')
end_points[sc.name + '/fc8'] = net
logits = net
softmax = tf.nn.softmax(logits)
#softmax = tf.Print(softmax, [tf.shape(softmax)], summarize=4, message='softmax')
# Prediction is the index of the label with the highest score. We are
# interested only in the top score.
prediction = tf.argmax(softmax, 1)
tensors.predictions = [prediction, softmax, images]
if graph_mod == GraphMod.PREDICT:
return tensors
with tf.name_scope('evaluate'):
loss_value = loss(logits, labels)
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value)
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, labels)
if not is_training:
#accuracy_op = tf.Print(accuracy_op, [accuracy_op], message="Accuracy")
#loss_op = tf.Print(loss_op, [loss_op], message="Loss")
tf.summary.scalar('accuracy', accuracy_op)
tf.summary.scalar('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
def run_training():
'''train the Neural Network'''
# sanity check
assert (FLAGS.input_data_type == 'float' or FLAGS.input_data_type == 'int')
assert (FLAGS.output_data_type == 'float'
or FLAGS.output_data_type == 'int')
# import the dataset
data_sets = dataset.Datasets(FLAGS.data_dir, FLAGS.separate_file,
FLAGS.input_data_type, FLAGS.output_data_type)
#for hotspot training
'''
data_sets = dataset.Datasets(FLAGS.data_dir,
FLAGS.separate_file,
FLAGS.input_data_type, FLAGS.output_data_type,
FLAGS.tile_size, FLAGS.num_maps)
'''
with tf.Graph().as_default():
# placeholder
input_pl, golden_pl = util.generate_placeholder(
data_sets.num_in_neuron, data_sets.num_out_neuron,
FLAGS.batch_size, FLAGS.input_data_type, FLAGS.output_data_type)
# build graph
if FLAGS.hidden1 == 0:
assert (FLAGS.hidden2 == 0)
outputs = util.layer('output_layer', input_pl,
data_sets.num_in_neuron,
data_sets.num_out_neuron, None)
else:
hidden1 = util.layer('hidden1', input_pl, data_sets.num_in_neuron,
FLAGS.hidden1, util.fast_sigmoid)
if FLAGS.hidden2 == 0:
outputs = util.layer('output_layer', hidden1, FLAGS.hidden1,
data_sets.num_out_neuron, None)
else:
hidden2 = util.layer('hidden2', hidden1, FLAGS.hidden1,
FLAGS.hidden2, util.fast_sigmoid)
outputs = util.layer('output_layer', hidden2, FLAGS.hidden2,
data_sets.num_out_neuron, None)
# loss
#loss = bm.loss(outputs, golden_pl)
loss = util.loss(outputs, golden_pl, FLAGS.benchmark)
# train
#train_op = bm.training(loss, FLAGS.learning_rate)
train_op = util.training(loss, FLAGS.learning_rate)
# accumulated error for one batch of data
error = util.error(outputs, golden_pl, FLAGS.benchmark)
# summary - not necessary
summary = tf.merge_all_summaries()
# init
init = tf.initialize_all_variables()
# sess
sess = tf.Session()
# summary writer - not necessary
summary_writer = tf.train.SummaryWriter(FLAGS.log_dir, sess.graph)
# everything built, run init
sess.run(init)
# start training
#_, max_steps = data_sets.train.max_steps(FLAGS.batch_size)
for step in xrange(FLAGS.max_steps):
feed_dict = util.fill_feed_dict(data_sets.train, input_pl,
golden_pl, FLAGS.batch_size)
sess.run(train_op, feed_dict=feed_dict)
# print the loss every 100 steps
# write the summary
# evaluate the model
if not step % 100:
print('step %d: loss = %.2f' %
(step, sess.run(loss, feed_dict=feed_dict)))
summary_str = sess.run(summary, feed_dict=feed_dict)
summary_writer.add_summary(summary_str, step)
summary_writer.flush()
'''
print('training data evaluation')
util.do_eval(sess, error,
input_pl, golden_pl,
FLAGS.batch_size, data_sets.train)
'''
print('validation data evaluation')
util.do_eval(sess, error, input_pl, golden_pl,
FLAGS.batch_size, data_sets.validate)
# final accuracy
print('test data evaluation')
util.do_eval(sess, error, input_pl, golden_pl, FLAGS.batch_size,
data_sets.test)
# filename for saving
savefile = str(data_sets.num_in_neuron) + "_" + str(
FLAGS.hidden1) + "_" + str(FLAGS.hidden2) + "_" + str(
data_sets.num_out_neuron) + ".txt"
# save weights and biases
util.save_config(sess, NUM_LAYERS, FLAGS.config_dir, savefile)
# save trained output
#util.save_output(sess, data_sets.train, outputs, FLAGS.data_dir)
#need to fetch original input data
output_save = sess.run(outputs,
feed_dict={input_pl: data_sets.input_data})
np.savetxt(FLAGS.data_dir + "train_result/" + savefile,
output_save,
delimiter=" ")
def build_graph(self, data_paths, batch_size, graph_mod):
"""Builds generic graph for training or eval."""
tensors = GraphReferences()
is_training = graph_mod == GraphMod.TRAIN
if data_paths:
tensors.keys, tensors.examples = util.read_examples(
data_paths,
batch_size,
shuffle=is_training,
num_epochs=None if is_training else 2)
else:
tensors.examples = tf.placeholder(tf.string,
name='input',
shape=(None, ))
if graph_mod == GraphMod.PREDICT:
audio_input, audio_fingerprints = self.build_fingerprints_graph()
# Build the fingerprints graph. We later add final trained layers
# to this graph. This is currently used only for prediction.
# For training, we use pre-processed data, so it is not needed.
fingerprints = audio_fingerprints
tensors.input_audio = audio_input
else:
# For training and evaluation we assume data is preprocessed, so the
# inputs are tf-examples.
# Generate placeholders for examples.
with tf.name_scope('inputs'):
feature_map = {
'audio_uri':
tf.FixedLenFeature(shape=[],
dtype=tf.string,
default_value=['']),
'label':
tf.FixedLenFeature(shape=[1],
dtype=tf.int64,
default_value=[self.label_count]),
'fingerprint':
tf.FixedLenFeature(shape=[self.fingerprint_size],
dtype=tf.float32)
}
parsed = tf.parse_example(tensors.examples,
features=feature_map)
labels = tf.squeeze(parsed['label'])
uris = tf.squeeze(parsed['audio_uri'])
fingerprints = parsed['fingerprint']
all_labels_count = self.label_count
if self.model_architecture == "lowlatencyconv":
with tf.name_scope('lowlatencyconv'):
softmax, logits = self.add_low_latency_conv(
fingerprints,
all_labels_count,
is_training,
dropout_keep_prob=self.dropout if is_training else None)
elif self.model_architecture == "crnn":
with tf.name_scope('crnn'):
softmax, logits = self.add_crnn(
fingerprints,
all_labels_count,
is_training,
dropout_keep_prob=self.dropout if is_training else None)
elif self.model_architecture == "rcnn":
with tf.name_scope('rcnn'):
softmax, logits = self.add_rcnn(
fingerprints,
all_labels_count,
is_training,
dropout_keep_prob=self.dropout if is_training else None)
else:
with tf.name_scope('conv'):
softmax, logits = self.add_conv(
fingerprints,
all_labels_count,
is_training,
dropout_keep_prob=self.dropout if is_training else None)
# Prediction is the index of the label with the highest score. We are
# interested only in the top score.
prediction = tf.argmax(softmax, 1)
tensors.predictions = [prediction, softmax, fingerprints]
if graph_mod == GraphMod.PREDICT:
return tensors
with tf.name_scope('evaluate'):
loss_value = loss(logits, labels)
# Add to the Graph the Ops that calculate and apply gradients.
if is_training:
tensors.train, tensors.global_step = training(loss_value)
else:
tensors.global_step = tf.Variable(0,
name='global_step',
trainable=False)
# Add means across all batches.
loss_updates, loss_op = util.loss(loss_value)
accuracy_updates, accuracy_op = util.accuracy(logits, labels)
if not is_training:
tf.summary.scalar('accuracy', accuracy_op)
tf.summary.scalar('loss', loss_op)
tensors.metric_updates = loss_updates + accuracy_updates
tensors.metric_values = [loss_op, accuracy_op]
return tensors
