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