def evaluate():
tf.set_random_seed(0) # for reproducibility
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
distill_names, distill_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.distill_names, FLAGS.distill_sizes)
if FLAGS.frame_features:
reader1 = readers.YT8MFrameFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
else:
reader1 = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
reader2 = readers.YT8MAggregatedFeatureReader(
feature_names=distill_names, feature_sizes=distill_sizes)
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
if FLAGS.eval_data_pattern is "":
raise IOError("'eval_data_pattern' was not specified. " +
"Nothing to evaluate.")
build_graph(reader1=reader1,
reader2=reader2,
model=model,
eval_data_pattern=FLAGS.eval_data_pattern,
distill_data_pattern=FLAGS.distill_data_pattern,
label_loss_fn=label_loss_fn,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_batch = tf.get_collection("video_id_batch")[0]
unused_id_batch = tf.get_collection("unused_id_batch")[0]
prediction_batch = tf.get_collection("predictions")[0]
label_batch = tf.get_collection("labels")[0]
loss = tf.get_collection("loss")[0]
summary_op = tf.get_collection("summary_op")[0]
saver = tf.train.Saver(tf.global_variables())
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=tf.get_default_graph())
evl_metrics = eval_util.EvaluationMetrics(reader1.num_classes,
FLAGS.top_k)
last_global_step_val = -1
while True:
last_global_step_val = evaluation_loop(
video_id_batch, unused_id_batch, prediction_batch, label_batch,
loss, summary_op, saver, summary_writer, evl_metrics,
last_global_step_val)
if FLAGS.run_once:
break
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
distill_names, distill_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.distill_names, FLAGS.distill_sizes)
if FLAGS.frame_features:
reader1 = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader1 = readers.YT8MAggregatedFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
reader2 = readers.YT8MAggregatedFeatureReader(
feature_names=distill_names, feature_sizes=distill_sizes)
if FLAGS.output_dir is "":
raise ValueError("'output_dir' was not specified. "
"Unable to continue with inference.")
if FLAGS.input_data_pattern is "":
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
if FLAGS.input_data_pattern is "":
raise IOError("'input_data_pattern' was not specified. " +
"Nothing to evaluate.")
build_graph(
reader1=reader1,
reader2=reader2,
model=model,
eval_data_pattern=FLAGS.input_data_pattern,
distill_data_pattern=FLAGS.distill_data_pattern,
label_loss_fn=label_loss_fn,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_batch = tf.get_collection("video_id_batch")[0]
prediction_batch = tf.get_collection("predictions")[0]
label_batch = tf.get_collection("labels")[0]
saver = tf.train.Saver(tf.global_variables())
inference(video_id_batch, prediction_batch, label_batch, saver, FLAGS.output_dir)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
if FLAGS.input_model_tgz:
if FLAGS.train_dir:
raise ValueError("You cannot supply --train_dir if supplying "
"--input_model_tgz")
# Untar.
if not os.path.exists(FLAGS.untar_model_dir):
os.makedirs(FLAGS.untar_model_dir)
tarfile.open(FLAGS.input_model_tgz).extractall(FLAGS.untar_model_dir)
FLAGS.train_dir = FLAGS.untar_model_dir
flags_dict_file = os.path.join(FLAGS.train_dir, "model_flags.json")
if not file_io.file_exists(flags_dict_file):
raise IOError("Cannot find %s. Did you run eval.py?" % flags_dict_file)
flags_dict = json.loads(file_io.FileIO(flags_dict_file, "r").read())
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"])
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
"""
if not FLAGS.output_file:
raise ValueError("'output_file' was not specified. "
"Unable to continue with inference.")
"""
if not FLAGS.input_data_pattern:
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
#################################################################################
if FLAGS.distill_data_pattern is not None:
distill_reader = readers.YT8MAggregatedFeatureReader(
feature_names=["predictions"], feature_sizes=[4716])
else:
distill_reader = None
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
transformer_fn = find_class_by_name(FLAGS.feature_transformer,
[feature_transform])
build_graph(reader,
model,
input_data_pattern=FLAGS.input_data_pattern,
batch_size=FLAGS.batch_size,
distill_reader=distill_reader) ##
saver = tf.train.Saver(max_to_keep=3,
keep_checkpoint_every_n_hours=10000000000)
#################################################################################
inference(saver, FLAGS.train_dir, FLAGS.input_data_pattern,
FLAGS.output_dir, FLAGS.batch_size, FLAGS.top_k)
def evaluate():
tf.set_random_seed(0) # for reproducibility
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
random_selection = 0
if FLAGS.select_randomly: random_selection = 1
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes,
random_selection = random_selection)
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
if FLAGS.eval_data_pattern is "":
raise IOError("'eval_data_pattern' was not specified. " +
"Nothing to evaluate.")
build_graph(
reader=reader,
model=model,
eval_data_pattern=FLAGS.eval_data_pattern,
label_loss_fn=label_loss_fn,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_batch = tf.get_collection("video_id_batch")[0]
prediction_batch = tf.get_collection("predictions")[0]
label_batch = tf.get_collection("labels")[0]
loss = tf.get_collection("loss")[0]
summary_op = tf.get_collection("summary_op")[0]
if (FLAGS.model == "DidacModel") | (FLAGS.model == "EmbeddingModel"):
hidden_layer_batch = tf.get_collection("hidden_layer_activations")[0]
saver = tf.train.Saver(tf.global_variables())
if FLAGS.board_dir is "":
board_dir = FLAGS.train_dir
else:
board_dir = FLAGS.board_dir
summary_writer = tf.summary.FileWriter(board_dir, graph=tf.get_default_graph())
evl_metrics = eval_util.EvaluationMetrics(reader.num_classes, FLAGS.top_k)
last_global_step_val = -1
while True:
last_global_step_val, video_id_batch_val\
= evaluation_loop(video_id_batch, prediction_batch,
label_batch, loss, summary_op,
saver, summary_writer, evl_metrics,
last_global_step_val, hidden_layer_batch)
video_id_batch_array = np.asarray(video_id_batch_val)
logging.info("Size video_id: " + str(video_id_batch_array.shape))
logging.info(video_id_batch_val[0])
if FLAGS.run_once:
break
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.slice_features:
reader = readers.AIMAggregatedFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
height=FLAGS.height,
width=FLAGS.width if FLAGS.stride == -1 else FLAGS.Bwidth,
slices=FLAGS.slices,
num_classes=FLAGS.vocabulary_size,
stride=FLAGS.stride,
input_chanels=FLAGS.input_chanels)
else:
raise NotImplementedError()
if FLAGS.input_data_pattern is "":
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
inference(reader, FLAGS.train_dir, FLAGS.input_data_pattern,
FLAGS.batch_size)
def evaluate():
tf.set_random_seed(0) # for reproducibility
# Write json of flags
model_flags_path = os.path.join(FLAGS.train_dir, "model_flags.json")
if not os.path.exists(model_flags_path):
raise IOError(("Cannot find file %s. Did you run train.py on the same "
"--train_dir?") % model_flags_path)
flags_dict = json.loads(open(model_flags_path).read())
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"])
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
model = find_class_by_name(flags_dict["model"],
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(flags_dict["label_loss"],
[losses])()
if FLAGS.eval_data_pattern is "":
raise IOError("'eval_data_pattern' was not specified. " +
"Nothing to evaluate.")
build_graph(reader=reader,
model=model,
eval_data_pattern=FLAGS.eval_data_pattern,
label_loss_fn=label_loss_fn,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_batch = tf.get_collection("video_id_batch")[0]
prediction_batch = tf.get_collection("predictions")[0]
label_batch = tf.get_collection("labels")[0]
loss = tf.get_collection("loss")[0]
summary_op = tf.get_collection("summary_op")[0]
saver = tf.train.Saver(tf.global_variables())
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=tf.get_default_graph())
evl_metrics = eval_util.EvaluationMetrics(reader.num_classes,
FLAGS.top_k)
last_global_step_val = -1
with tf.device("/gpu:0"):
while True:
last_global_step_val = evaluation_loop(
video_id_batch, prediction_batch, label_batch, loss,
summary_op, saver, summary_writer, evl_metrics,
last_global_step_val)
if FLAGS.run_once:
break
def evaluate():
tf.set_random_seed(0) # for reproducibility
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
# prepare a reader for each single model prediction result
all_readers = []
all_patterns = FLAGS.eval_data_patterns
all_patterns = map(lambda x: x.strip(),
all_patterns.strip().strip(",").split(","))
for i in xrange(len(all_patterns)):
reader = readers.EnsembleReader(feature_names=feature_names,
feature_sizes=feature_sizes)
all_readers.append(reader)
input_reader = None
input_data_pattern = None
if FLAGS.input_data_pattern is not None:
input_reader = readers.EnsembleReader(feature_names=["input"],
feature_sizes=[1024 + 128])
input_data_pattern = FLAGS.input_data_pattern
# find the model
model = find_class_by_name(FLAGS.model, [ensemble_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
if FLAGS.eval_data_patterns is "":
raise IOError("'eval_data_patterns' was not specified. " +
"Nothing to evaluate.")
build_graph(all_readers=all_readers,
input_reader=input_reader,
all_eval_data_patterns=all_patterns,
input_data_pattern=input_data_pattern,
model=model,
label_loss_fn=label_loss_fn,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_batch = tf.get_collection("video_id_batch")[0]
prediction_batch = tf.get_collection("predictions")[0]
label_batch = tf.get_collection("labels")[0]
loss = tf.get_collection("loss")[0]
summary_op = tf.get_collection("summary_op")[0]
saver = tf.train.Saver(tf.global_variables())
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,
graph=tf.get_default_graph())
evl_metrics = eval_util.EvaluationMetrics(FLAGS.num_classes,
FLAGS.top_k)
last_global_step_val = -1
last_global_step_val = evaluation_loop(video_id_batch,
prediction_batch, label_batch,
loss, summary_op, saver,
summary_writer, evl_metrics,
last_global_step_val)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
if FLAGS.output_file is "":
raise ValueError("'output_file' was not specified. "
"Unable to continue with inference.")
if FLAGS.input_data_pattern is "":
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
inference(reader, FLAGS.checkpoint_file, FLAGS.train_dir,
FLAGS.input_data_pattern, FLAGS.output_file, FLAGS.batch_size,
FLAGS.top_k)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
print("tensorflow version: %s" % tf.__version__)
is_chief = (FLAGS.task == 0)
# Recover session
saver = None
latest_checkpoint = tf.train.latest_checkpoint(FLAGS.train_dir)
if FLAGS.start_new_model:
logging.info(
"'start_new_model' flag is set. Removing existing train dir.")
try:
gfile.DeleteRecursively(FLAGS.train_dir)
except:
logging.error(
"Failed to delete directory " + FLAGS.train_dir +
" when starting a new model. Please delete it manually and" +
" try again.")
elif not latest_checkpoint:
logging.info("No checkpoint file found. Building a new model.")
else:
meta_filename = latest_checkpoint + ".meta"
if not gfile.Exists(meta_filename):
logging.info("No meta graph file found. Building a new model.")
else:
logging.info("Restoring from meta graph file %s", meta_filename)
saver = tf.train.import_meta_graph(meta_filename)
if not saver:
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
optimizer_class = find_class_by_name(FLAGS.optimizer, [tf.train])
build_graph(reader=reader,
model=model,
optimizer_class=optimizer_class,
train_data_pattern=FLAGS.train_data_pattern,
label_loss_fn=label_loss_fn,
base_learning_rate=FLAGS.base_learning_rate,
regularization_penalty=FLAGS.regularization_penalty,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size)
logging.info("built graph")
saver = tf.train.Saver()
train_loop(is_chief=is_chief,
train_dir=FLAGS.train_dir,
saver=saver,
master=FLAGS.master)
def infer(train_dir,
input_data_pattern,
output_file,
top_k=20,
batch_size=8192,
num_readers=1):
logging.set_verbosity(tf.logging.INFO)
flags_dict_file = os.path.join(train_dir, "model_flags.json")
if not os.path.exists(flags_dict_file):
raise IOError("Cannot find %s. Did you run eval.py?" % flags_dict_file)
flags_dict = json.loads(open(flags_dict_file).read())
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"])
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
if output_file is "":
raise ValueError("'output_file' was not specified. "
"Unable to continue with inference.")
if input_data_pattern is "":
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
inference(reader, train_dir, input_data_pattern, output_file, batch_size,
top_k)
def build_model(self):
"""Find the model and build the graph."""
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
distill_names, distill_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.distill_names, FLAGS.distill_sizes)
if FLAGS.frame_features:
reader1 = readers.YT8MFrameFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
else:
reader1 = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
reader2 = readers.YT8MAggregatedFeatureReader(
feature_names=distill_names, feature_sizes=distill_sizes)
# Find the model.
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
optimizer_class = find_class_by_name(FLAGS.optimizer, [tf.train])
build_graph(
reader1=reader1,
reader2=reader2,
model=model,
optimizer_class=optimizer_class,
clip_gradient_norm=FLAGS.clip_gradient_norm,
train_data_pattern=FLAGS.train_data_pattern,
distill_data_pattern=FLAGS.distill_data_pattern,
label_loss_fn=label_loss_fn,
base_learning_rate=FLAGS.base_learning_rate,
learning_rate_decay=FLAGS.learning_rate_decay,
learning_rate_decay_examples=FLAGS.learning_rate_decay_examples,
regularization_penalty=FLAGS.regularization_penalty,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size,
num_epochs=FLAGS.num_epochs)
logging.info("%s: Built graph.", task_as_string(self.task))
return tf.train.Saver(max_to_keep=2, keep_checkpoint_every_n_hours=1)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
if FLAGS.input_data_pattern is "":
raise IOError("'input_data_pattern' was not specified. " +
"Nothing to evaluate.")
if FLAGS.prediction_data_pattern is "":
raise IOError("'prediction_data_pattern' was not specified. " +
"Nothing to evaluate.")
# convert feature_names and feature_sizes to lists of values
input_feature_names, input_feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.input_feature_names, FLAGS.input_feature_sizes)
input_reader = readers.EnsembleFrameReader(
feature_names=input_feature_names,
feature_sizes=input_feature_sizes)
prediction_feature_names, prediction_feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.prediction_feature_names, FLAGS.prediction_feature_sizes)
prediction_reader = readers.EnsembleReader(
feature_names=prediction_feature_names,
feature_sizes=prediction_feature_sizes)
build_graph(input_reader=input_reader,
prediction_reader=prediction_reader,
input_data_pattern=FLAGS.input_data_pattern,
prediction_data_pattern=FLAGS.prediction_data_pattern,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_ids_batch = tf.get_collection("video_ids_batch")[0]
labels_batch = tf.get_collection("labels_batch")[0]
rgbs_batch = tf.get_collection("rgbs_batch")[0]
audios_batch = tf.get_collection("audios_batch")[0]
predictions_batch = tf.get_collection("predictions_batch")[0]
num_frames_batch = tf.get_collection("num_frames_batch")[0]
inference_loop(video_ids_batch, labels_batch, rgbs_batch, audios_batch,
predictions_batch, num_frames_batch, FLAGS.output_dir,
FLAGS.batch_size)
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
return reader
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
raise NotImplementedError("Frame level features are not supported yet")
else:
reader = readers.NumpyY8MAggFeaturesReader(feature_names=feature_names,
feature_sizes=feature_sizes)
return reader
def lstm(self,
model_input,
vocab_size,
num_frames,
sub_scope="",
feature_names=None,
feature_sizes=None,
**unused_params):
number_of_layers = FLAGS.lstm_layers
lstm_sizes = map(int, FLAGS.lstm_cells.split(","))
if feature_names is None:
feature_names = FLAGS.feature_names
if feature_sizes is None:
feature_sizes = FLAGS.feature_sizes
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
feature_names, feature_sizes)
sub_inputs = [
tf.nn.l2_normalize(x, dim=2)
for x in tf.split(model_input, feature_sizes, axis=2)
]
print model_input
assert len(lstm_sizes) == len(feature_sizes), \
"length of lstm_sizes (={}) != length of feature_sizes (={})".format( \
len(lstm_sizes), len(feature_sizes))
states = []
outputs = []
for i in xrange(len(feature_sizes)):
with tf.variable_scope(sub_scope + "RNN%d" % i):
print sub_scope + "RNN%d" % i, lstm_sizes
print sub_inputs
sub_input = sub_inputs[i]
lstm_size = lstm_sizes[i]
## Batch normalize the input
stacked_lstm = tf.contrib.rnn.MultiRNNCell([
tf.contrib.rnn.BasicLSTMCell(
lstm_size, forget_bias=1.0, state_is_tuple=True)
for _ in range(number_of_layers)
],
state_is_tuple=True)
output, state = tf.nn.dynamic_rnn(
stacked_lstm,
sub_input,
sequence_length=num_frames,
swap_memory=FLAGS.rnn_swap_memory,
dtype=tf.float32)
states.extend(map(lambda x: x.c, state))
outputs.append(output)
final_state = tf.concat(states, axis=1)
final_output = tf.concat(outputs, axis=2)
return final_state, final_output
def build_model(self):
"""Find the model and build the graph."""
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
# prepare a reader for each single model prediction result
all_readers = []
all_patterns = FLAGS.train_data_patterns
all_patterns = map(lambda x: x.strip(),
all_patterns.strip().strip(",").split(","))
for i in xrange(len(all_patterns)):
all_readers.append(
readers.EnsembleReader(feature_names=feature_names,
feature_sizes=feature_sizes))
input_reader = None
input_data_pattern = None
if FLAGS.input_data_pattern is not None:
input_reader = readers.EnsembleReader(feature_names=["input"],
feature_sizes=[1024 + 128])
input_data_pattern = FLAGS.input_data_pattern
# Find the model.
model = find_class_by_name(FLAGS.model, [ensemble_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
optimizer_class = find_class_by_name(FLAGS.optimizer, [tf.train])
build_graph(
all_readers=all_readers,
all_train_data_patterns=all_patterns,
input_reader=input_reader,
input_data_pattern=input_data_pattern,
model=model,
optimizer_class=optimizer_class,
clip_gradient_norm=FLAGS.clip_gradient_norm,
label_loss_fn=label_loss_fn,
base_learning_rate=FLAGS.base_learning_rate,
learning_rate_decay=FLAGS.learning_rate_decay,
learning_rate_decay_examples=FLAGS.learning_rate_decay_examples,
regularization_penalty=FLAGS.regularization_penalty,
batch_size=FLAGS.batch_size,
num_epochs=FLAGS.num_epochs)
logging.info("%s: Built graph.", task_as_string(self.task))
return tf.train.Saver(
max_to_keep=3,
keep_checkpoint_every_n_hours=FLAGS.keep_checkpoint_every_n_hours)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
if FLAGS.output_dir is "":
raise ValueError("'output_dir' was not specified. "
"Unable to continue with inference.")
if FLAGS.input_data_pattern is "":
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
if FLAGS.distill_data_pattern is not None:
predictions_patterns = FLAGS.distill_data_pattern.strip().split(",")
predictions_readers = []
for pattern in predictions_patterns:
predictions_readers.append(
readers.YT8MAggregatedFeatureReader(
feature_names=["predictions"], feature_sizes=[4716]))
else:
predictions_patterns = None
predictions_readers = None
model = find_class_by_name(FLAGS.model,
[frame_level_models, video_level_models])()
transformer_fn = find_class_by_name(FLAGS.feature_transformer,
[feature_transform])
build_graph(reader=reader,
input_data_pattern=FLAGS.input_data_pattern,
model=model,
distill_readers=predictions_readers,
distill_data_patterns=predictions_patterns,
batch_size=FLAGS.batch_size,
transformer_class=transformer_fn)
saver = tf.train.Saver(max_to_keep=3,
keep_checkpoint_every_n_hours=10000000000)
inference(saver, FLAGS.model_checkpoint_path, FLAGS.output_dir,
FLAGS.batch_size, FLAGS.top_k)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
if FLAGS.input_model_tgz:
if FLAGS.train_dir:
raise ValueError(
"You cannot supply --train_dir if supplying " "--input_model_tgz"
)
# Untar.
if not os.path.exists(FLAGS.untar_model_dir):
os.makedirs(FLAGS.untar_model_dir)
tarfile.open(FLAGS.input_model_tgz).extractall(FLAGS.untar_model_dir)
FLAGS.train_dir = FLAGS.untar_model_dir
flags_dict_file = os.path.join(FLAGS.train_dir, "model_flags.json")
if not file_io.file_exists(flags_dict_file):
raise IOError("Cannot find %s. Did you run eval.py?" % flags_dict_file)
flags_dict = json.loads(file_io.FileIO(flags_dict_file, "r").read())
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"]
)
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes
)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes
)
if FLAGS.output_file is "":
raise ValueError(
"'output_file' was not specified. " "Unable to continue with inference."
)
if FLAGS.input_data_pattern is "":
raise ValueError(
"'input_data_pattern' was not specified. "
"Unable to continue with inference."
)
inference(
reader,
FLAGS.train_dir,
FLAGS.input_data_pattern,
FLAGS.output_file,
FLAGS.batch_size,
FLAGS.top_k,
)
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
# prepare a reader for each single model prediction result
all_readers = []
all_patterns = FLAGS.input_data_patterns
all_patterns = map(lambda x: x.strip(), all_patterns.strip().strip(",").split(","))
for i in xrange(len(all_patterns)):
reader = readers.EnsembleReader(
feature_names=feature_names, feature_sizes=feature_sizes)
all_readers.append(reader)
input_reader = None
input_data_pattern = None
if FLAGS.input_data_pattern is not None:
input_reader = readers.EnsembleReader(
feature_names=["input"], feature_sizes=[1024+128])
input_data_pattern = FLAGS.input_data_pattern
model = find_class_by_name(FLAGS.model, [ensemble_level_models])()
label_loss_fn = find_class_by_name(FLAGS.label_loss, [losses])()
if FLAGS.input_data_patterns is "":
raise IOError("'input_data_patterns' was not specified. " +
"Nothing to evaluate.")
build_graph(
all_readers=all_readers,
input_reader=input_reader,
all_data_patterns=all_patterns,
input_data_pattern=input_data_pattern,
model=model,
label_loss_fn=label_loss_fn,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_batch = tf.get_collection("video_id_batch")[0]
prediction_batch = tf.get_collection("predictions")[0]
label_batch = tf.get_collection("labels")[0]
saver = tf.train.Saver(tf.global_variables())
inference_loop(video_id_batch, prediction_batch,
label_batch, saver,
FLAGS.output_dir, FLAGS.batch_size)
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
random_selection = 0
if FLAGS.select_randomly: random_selection = 2
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes, random_selection=random_selection,
negative_sampling=FLAGS.negative_sampling, percentage_negative=FLAGS.percentage_negative)
return reader
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
if FLAGS.input_model_tgz:
if FLAGS.train_dir:
raise ValueError("You cannot supply --train_dir if supplying "
"--input_model_tgz")
# Untar.
if not os.path.exists(FLAGS.untar_model_dir):
os.makedirs(FLAGS.untar_model_dir)
tarfile.open(FLAGS.input_model_tgz).extractall(FLAGS.untar_model_dir)
FLAGS.train_dir = FLAGS.untar_model_dir
flags_dict_file = os.path.join(FLAGS.train_dir, "model_flags.json")
if not os.path.exists(flags_dict_file):
raise IOError("Cannot find %s. Did you run eval.py?" % flags_dict_file)
flags_dict = json.loads(open(flags_dict_file).read())
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"])
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
all_data_patterns = []
with open(FLAGS.data_config) as f:
all_data_patterns = f.read().splitlines()
all_readers = []
for i in xrange(len(all_data_patterns)):
reader = readers.EnsembleReader(feature_names=["predictions"],
feature_sizes=["3862"])
all_readers.append(reader)
# if FLAGS.output_file is "":
# raise ValueError("'output_file' was not specified. "
# "Unable to continue with inference.")
# if FLAGS.input_data_pattern is "":
# raise ValueError("'input_data_pattern' was not specified. "
# "Unable to continue with inference.")
inference(all_readers, FLAGS.train_dir, all_data_patterns,
FLAGS.output_file, FLAGS.batch_size, FLAGS.top_k)
def evaluate():
"""Starts main evaluation loop."""
tf.compat.v1.set_random_seed(0) # for reproducibility
# Write json of flags
model_flags_path = os.path.join(FLAGS.train_dir, "model_flags.json")
if not file_io.file_exists(model_flags_path):
raise IOError(("Cannot find file %s. Did you run train.py on the same "
"--train_dir?") % model_flags_path)
flags_dict = json.loads(file_io.FileIO(model_flags_path, mode="r").read())
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"])
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
segment_labels=FLAGS.segment_labels)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
model = find_class_by_name(flags_dict["model"],
[frame_level_models, video_level_models])()
label_loss_fn = find_class_by_name(flags_dict["label_loss"],
[losses])()
if not FLAGS.input_data_pattern:
raise IOError("'input_data_pattern' was not specified. Nothing to "
"evaluate.")
build_graph(reader=reader,
model=model,
input_data_pattern=FLAGS.input_data_pattern,
label_loss_fn=label_loss_fn,
num_readers=FLAGS.num_readers,
batch_size=FLAGS.batch_size)
logging.info("built inference graph")
# A dict of tensors to be run in Session.
saver = tf.compat.v1.train.Saver(tf.compat.v1.global_variables())
inference(saver, reader, FLAGS.train_dir, FLAGS.output_dir,
FLAGS.batch_size, FLAGS.top_k)
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
is_training=True,
data_augmentation=FLAGS.data_augmentation)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
return reader
def get_params(flags_dict):
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
flags_dict["feature_names"], flags_dict["feature_sizes"])
if flags_dict["frame_features"]:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
model = find_class_by_name(flags_dict["model"],
[frame_level_models, video_level_models])()
# a model instance is created
label_loss_fn = find_class_by_name(flags_dict["label_loss"], [losses])()
return model, label_loss_fn, reader
def main(unused_argv):
logging.set_verbosity(tf.logging.INFO)
print("START FLAGS===========================")
print("train_dir: " + str(FLAGS.train_dir))
print("output_file: " + str(FLAGS.output_file))
print("input_data_pattern: " + str(FLAGS.input_data_pattern))
print("frame_features: " + str(FLAGS.frame_features))
print("batch_size: " + str(FLAGS.batch_size))
print("feature_names: " + str(FLAGS.feature_names))
print("feature_sizes: " + str(FLAGS.feature_sizes))
print("c_vars: " + str(FLAGS.c_vars))
print("num_readers: " + str(FLAGS.num_readers))
print("top_k: " + str(FLAGS.top_k))
print("layers_keep_probs: " + str(FLAGS.layers_keep_probs))
print("gpu_only: " + str(FLAGS.gpu_only))
print("END FLAGS ============================")
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
num_classes=FLAGS.truncated_num_classes,
decode_zlib=FLAGS.decode_zlib)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
feature_calcs=FLAGS.c_vars,
feature_remove=FLAGS.r_vars,
num_classes=FLAGS.truncated_num_classes,
decode_zlib=FLAGS.decode_zlib)
if FLAGS.output_file is "":
raise ValueError("'output_file' was not specified. "
"Unable to continue with inference.")
if FLAGS.input_data_pattern is "":
raise ValueError("'input_data_pattern' was not specified. "
"Unable to continue with inference.")
inference(reader, FLAGS.train_dir, FLAGS.input_data_pattern,
FLAGS.output_file, FLAGS.batch_size, FLAGS.top_k)
def check_video_id():
tf.set_random_seed(0) # for reproducibility
with tf.Graph().as_default():
# convert feature_names and feature_sizes to lists of values
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
# prepare a reader for each single model prediction result
all_readers = []
all_patterns = FLAGS.eval_data_patterns
all_patterns = map(lambda x: x.strip(),
all_patterns.strip().strip(",").split(","))
for i in xrange(len(all_patterns)):
reader = readers.EnsembleReader(feature_names=feature_names,
feature_sizes=feature_sizes)
all_readers.append(reader)
input_reader = None
input_data_pattern = None
if FLAGS.input_data_pattern is not None:
input_reader = readers.EnsembleReader(
feature_names=["mean_rgb", "mean_audio"],
feature_sizes=[1024, 128])
# input_reader = readers.EnsembleReader(
# feature_names=["input"], feature_sizes=[1024+128])
input_data_pattern = FLAGS.input_data_pattern
if FLAGS.eval_data_patterns is "":
raise IOError("'eval_data_patterns' was not specified. " +
"Nothing to evaluate.")
build_graph(all_readers=all_readers,
input_reader=input_reader,
input_data_pattern=input_data_pattern,
all_eval_data_patterns=all_patterns,
batch_size=FLAGS.batch_size)
logging.info("built evaluation graph")
video_id_mismatch = tf.get_collection("video_id_mismatch")[0]
input_distance = tf.get_collection("input_distance")[0]
actual_batch_size = tf.get_collection("actual_batch_size")[0]
check_loop(video_id_mismatch, input_distance, actual_batch_size,
all_patterns)
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.slice_features:
reader = readers.AIMAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes,
height=FLAGS.height,
width=FLAGS.width if FLAGS.stride == -1 else FLAGS.Bwidth,
slices=FLAGS.slices,
num_classes = FLAGS.vocabulary_size,
stride = FLAGS.stride,
input_chanels=FLAGS.input_chanels)
else:
raise NotImplementedError()
return reader
def get_reader(mapping_2017):
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(feature_names=feature_names,
feature_sizes=feature_sizes,
num_classes=4716,
mapping_mat=mapping_2017)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
num_classes=4716,
mapping_mat=mapping_2017)
return reader
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
#print('FEATURE NAMES',feature_names,'\n\n\n\n\n')
#print('FEATURES SIZE',feature_sizes,'\n\n\n\n\n')
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(
feature_names=feature_names,
feature_sizes=feature_sizes,
segment_labels=FLAGS.segment_labels)
else:
reader = readers.YT8MAggregatedFeatureReader(
feature_names=feature_names, feature_sizes=feature_sizes)
print(reader)
return reader
def get_reader():
# Convert feature_names and feature_sizes to lists of values.
feature_names, feature_sizes = utils.GetListOfFeatureNamesAndSizes(
FLAGS.feature_names, FLAGS.feature_sizes)
if FLAGS.frame_features:
reader = readers.YT8MFrameFeatureReader(
num_classes=FLAGS.truncated_num_classes,
decode_zlib=FLAGS.decode_zlib,
feature_names=feature_names,
feature_sizes=feature_sizes)
else:
reader = readers.YT8MAggregatedFeatureReader(
num_classes=FLAGS.truncated_num_classes,
decode_zlib=FLAGS.decode_zlib,
feature_names=feature_names,
feature_sizes=feature_sizes)
return reader
