def main(unused_argv):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
hyper_params = create_hparams()
model_fn = model.create_model_fn(hyper_params,
model_impl=dual_encoder_model)
estimator = tf.contrib.learn.Estimator(
model_fn=model_fn,
model_dir=MODEL_DIR,
config=tf.contrib.learn.RunConfig(session_config=config))
input_fn_train = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.TRAIN,
input_files=[TRAIN_FILE],
batch_size=hyper_params.batch_size,
num_epochs=FLAGS.num_epochs)
input_fn_eval = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[VALIDATION_FILE],
batch_size=hyper_params.eval_batch_size,
num_epochs=1)
eval_metrics = metrics.create_evaluation_metrics()
eval_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_eval,
every_n_steps=FLAGS.eval_every,
metrics=eval_metrics)
estimator.fit(input_fn=input_fn_train, steps=None, monitors=[eval_monitor])
def main(unused_arg):
hparams = hp.create_hparams()
model_fn = model.create_model_fn(hparams)
estimator = tf.contrib.learn.Estimator(
model_fn=model_fn,
config=tf.contrib.learn.RunConfig(
save_checkpoints_steps=FLAGS.eval_every,
save_summary_steps=10000,
log_step_count_steps=10000,
model_dir=MODEL_DIR))
input_fn_train = input.create_input_fn(
input_files=[TRAIN_FILE_PATH],
batch_size=hparams.batch_size,
mode=tf.contrib.learn.ModeKeys.TRAIN,
num_epochs=hparams.num_epochs)
monitors_list = []
input_fn_validation = input.create_input_fn([VALIDATION_FILE_PATH],
tf.contrib.learn.ModeKeys.EVAL,
hparams.eval_batch_size, 1)
validation_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_validation,
every_n_steps=FLAGS.eval_every,
metrics=metrics.create_evaluation_metrics('validation'))
monitors_list.append(validation_monitor)
input_fn_test = input.create_input_fn([TEST_FILE_PATH],
tf.contrib.learn.ModeKeys.EVAL,
hparams.eval_batch_size, 1)
test_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_test,
every_n_steps=FLAGS.eval_every,
metrics=metrics.create_evaluation_metrics('test'))
monitors_list.append(test_monitor)
if FLAGS.debug:
debuger = tf_debug.LocalCLIDebugHook()
monitors_list.append(debuger)
input_fn_train_eval = input.create_input_fn([TRAIN_FILE_PATH],
tf.contrib.learn.ModeKeys.EVAL,
hparams.batch_size, 1)
train_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_train_eval,
every_n_steps=FLAGS.train_eval_every,
metrics={
'train_accuracy':
metrics.create_metric_spec(tf.contrib.metrics.streaming_accuracy,
'predictions', None)
})
monitors_list.append(train_monitor)
estimator.fit(input_fn=input_fn_train, steps=None, monitors=monitors_list)
hp.write_hparams_to_file(hparams, MODEL_DIR)
def main(unused_arg):
model_fn = model.create_model_fn(hp.create_hparams())
estimator = tf.contrib.learn.Estimator(model_fn=model_fn,
model_dir=FLAGS.model_dir,
config=tf.contrib.learn.RunConfig())
input_fn = input.create_input_fn([TEST_FILE_PATH],
tf.crontrib.learn.ModeKeys.EVAL,
FLAGS.test_batch_size, 1)
eval_metrics = metrics.create_evaluation_metrics()
estimator.evaluate(input_fn=input_fn,
batch_size=FLAGS.test_batch_size,
metrics=eval_metrics,
steps=None)
def _assert_outputs_for_train_eval(self, configs, mode, class_agnostic=False):
model_config = configs['model']
train_config = configs['train_config']
with tf.Graph().as_default():
if mode == tf.estimator.ModeKeys.TRAIN:
features, labels = inputs.create_train_input_fn(
configs['train_config'],
configs['train_input_config'],
configs['model'])()
batch_size = train_config.batch_size
else:
features, labels = inputs.create_eval_input_fn(
configs['eval_config'],
configs['eval_input_config'],
configs['model'])()
batch_size = 1
detection_model_fn = functools.partial(
model_builder.build, model_config=model_config, is_training=True)
hparams = model_hparams.create_hparams(
hparams_overrides='load_pretrained=false')
model_fn = model.create_model_fn(detection_model_fn, configs, hparams)
estimator_spec = model_fn(features, labels, mode)
self.assertIsNotNone(estimator_spec.loss)
self.assertIsNotNone(estimator_spec.predictions)
if class_agnostic:
self.assertNotIn('detection_classes', estimator_spec.predictions)
else:
detection_classes = estimator_spec.predictions['detection_classes']
self.assertEqual(batch_size, detection_classes.shape.as_list()[0])
self.assertEqual(tf.float32, detection_classes.dtype)
detection_boxes = estimator_spec.predictions['detection_boxes']
detection_scores = estimator_spec.predictions['detection_scores']
num_detections = estimator_spec.predictions['num_detections']
self.assertEqual(batch_size, detection_boxes.shape.as_list()[0])
self.assertEqual(tf.float32, detection_boxes.dtype)
self.assertEqual(batch_size, detection_scores.shape.as_list()[0])
self.assertEqual(tf.float32, detection_scores.dtype)
self.assertEqual(tf.float32, num_detections.dtype)
if mode == tf.estimator.ModeKeys.TRAIN:
self.assertIsNotNone(estimator_spec.train_op)
return estimator_spec
def main(unused_argv):
flags.mark_flag_as_required('model_dir')
flags.mark_flag_as_required('label_map_path')
flags.mark_flag_as_required('train_file_pattern')
flags.mark_flag_as_required('eval_file_pattern')
config = tf.estimator.RunConfig(model_dir=FLAGS.model_dir)
run_config = {"label_map_path": FLAGS.label_map_path,
"num_classes": FLAGS.num_classes}
if FLAGS.finetune_ckpt:
run_config["finetune_ckpt"] = FLAGS.finetune_ckpt
model_fn = create_model_fn(run_config)
estimator = tf.estimator.Estimator(model_fn=model_fn, config=config)
train_input_fn = create_input_fn(FLAGS.train_file_pattern, True, FLAGS.image_size, FLAGS.batch_size)
eval_input_fn = create_input_fn(FLAGS.eval_file_pattern, False, FLAGS.image_size)
prediction_fn = create_prediction_input_fn()
train_spec, eval_spec = create_train_and_eval_specs(train_input_fn, eval_input_fn, prediction_fn, FLAGS.num_train_steps)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
def main(_):
"""Launch training"""
# Load hyperparameters
params = config.create_config()
# Prepare function that will be used for loading context/utterance
model_fn = model.create_model_fn(params, model_impl=selected_model)
# Prepare estimator
estimator = tf.contrib.learn.Estimator(model_fn=model_fn,
model_dir=MODEL_DIR,
config=tf.contrib.learn.RunConfig(
gpu_memory_fraction=0.25,
save_checkpoints_secs=60 * 2,
keep_checkpoint_max=1,
log_device_placement=False))
# Prepare input training examples
input_fn_train = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.TRAIN,
input_files=[TRAIN_FILE],
batch_size=params.batch_size,
num_epochs=FLAGS.num_epochs,
params=params)
# Prepare input validation examples
input_fn_eval = inputs.create_input_fn(mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[VALIDATION_FILE],
batch_size=params.eval_batch_size,
num_epochs=1,
params=params)
# Load recall metrics for validation
eval_metrics = metrics.create_evaluation_metrics()
# Prepare monitor for validation
eval_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_eval,
every_n_steps=FLAGS.eval_every,
metrics=eval_metrics)
# Lauch training
estimator.fit(input_fn=input_fn_train, steps=None, monitors=[eval_monitor])
def main(unused_argv):
# Replace MODEL_DIR with the folder current run to resume training from a set of hyperparameters
# MODEL_DIR = '/Users/eduardolitonjua/Desktop/Retrieval-System/runs/1472130056'
hparams = hyperparameters.create_hparams()
model_fn = model.create_model_fn(
hparams,
model_impl=dual_encoder_model)
estimator = tf.contrib.learn.Estimator(
model_fn=model_fn,
model_dir=MODEL_DIR,
config=tf.contrib.learn.RunConfig())
input_fn_train = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.TRAIN,
input_files=[TRAIN_FILE],
batch_size=hparams.batch_size,
num_epochs=FLAGS.num_epochs)
input_fn_eval = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[VALIDATION_FILE],
batch_size=hparams.eval_batch_size,
num_epochs=1)
eval_metrics = metrics.create_evaluation_metrics()
class EvaluationMonitor(tf.contrib.learn.monitors.EveryN):
def every_n_step_end(self, step, outputs):
self._estimator.evaluate(
input_fn=input_fn_eval,
metrics=eval_metrics,
steps=None)
eval_monitor = EvaluationMonitor(every_n_steps=FLAGS.eval_every, first_n_steps=-1)
estimator.fit(input_fn=input_fn_train, steps=None, monitors=[eval_monitor])
def main(unused_argv):
hparams = new_hparams.create_hparams()
model_fn = model.create_model_fn(
hparams, model_impl=model.birnn_att_model)
estimator = tf.contrib.learn.Estimator(
model_fn=model_fn,
model_dir=MODEL_DIR,
config=tf.contrib.learn.RunConfig())
input_fn_train = read_data.create_input_fn(
mode=tf.contrib.learn.ModeKeys.TRAIN,
input_files=[TRAIN_FILE],
batch_size=hparams.batch_size,
num_epochs=FLAGS.num_epochs)
# features, target= input_fn_train()
#
# # TODO
# probs, loss, train_op = model_fn()
input_fn_eval = read_data.create_input_fn(
mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[VALIDATION_FILE],
batch_size=hparams.eval_batch_size,
num_epochs=1)
eval_metrics = create_evaluation_metrics()
eval_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_eval,
every_n_steps=FLAGS.eval_every,
metrics=eval_metrics)
# TODO: add eval_monitor metrics
estimator.fit(
input_fn=input_fn_train,
steps=None,
monitors=None)
def _assert_outputs_for_predict(self, configs):
model_config = configs['model']
with tf.Graph().as_default():
features, _ = inputs.create_eval_input_fn(
configs['eval_config'],
configs['eval_input_config'],
configs['model'])()
detection_model_fn = functools.partial(
model_builder.build, model_config=model_config, is_training=False)
hparams = model_hparams.create_hparams(
hparams_overrides='load_pretrained=false')
model_fn = model.create_model_fn(detection_model_fn, configs, hparams)
estimator_spec = model_fn(features, None, tf.estimator.ModeKeys.PREDICT)
self.assertIsNone(estimator_spec.loss)
self.assertIsNone(estimator_spec.train_op)
self.assertIsNotNone(estimator_spec.predictions)
self.assertIsNotNone(estimator_spec.export_outputs)
self.assertIn(tf.saved_model.signature_constants.PREDICT_METHOD_NAME,
estimator_spec.export_outputs)
def main():
hparams = network_params.create_hparams()
if hparams.eval_batch_size % 10:
raise ArithmeticError(
'EVAL BATCH have to be a multiple of 10 to maintain the utterance-distractors ratio'
)
model_fn = model.create_model_fn( # create the model
hparams, model_impl=dual_encoder_model)
estimator = tf.contrib.learn.Estimator( # creation of the estimator for our model_fn functions
model_fn=model_fn, # model function
model_dir=FLAGS.
model_dir, # directory to save the model paramters, graphs, etc.
config=tf.contrib.learn.RunConfig(
gpu_memory_fraction=FLAGS.memory_fraction, save_summary_steps=50)
) # specify the ammount of memory to use for the GPU
input_fn_train = IO_data.create_input_fn( # ensure that the model receive the data in the correct format for training
input_files=[TRAIN_FILE],
batch_size=hparams.batch_size,
num_epochs=FLAGS.num_epochs
) # Integer specifying the number of times to read through the dataset.
input_fn_eval = IO_data.create_input_fn( # ensure that the model receive the data in the correct format for evaluation
input_files=[VALIDATION_FILE],
batch_size=hparams.eval_batch_size,
num_epochs=1)
eval_metrics = create_evaluation_metrics()
eval_monitor = tf.contrib.learn.monitors.ValidationMonitor( # creation of the monitor which evaluate the model every eval_every step during training
input_fn=input_fn_eval,
every_n_steps=FLAGS.eval_every,
metrics=eval_metrics)
estimator.fit(input_fn=input_fn_train, steps=None, monitors=[eval_monitor])
def main(unused_arg):
hyper_parameters = hparam.create_hparam()
train_config = tf.contrib.learn.RunConfig(
gpu_memory_fraction=1,
save_summary_steps=hyper_parameters.eval_step,
save_checkpoints_steps=hyper_parameters.eval_step,
log_step_count_steps=1000)
estimator = tf.estimator.Estimator(model_fn=model.create_model_fn(),
model_dir=MODEL_DIR,
config=train_config,
params=hyper_parameters)
monitors_list = []
if FLAGS.debug:
debuger = tf_debug.LocalCLIDebugHook()
monitors_list.append(debuger)
valid_input_fn = input.create_input_fn(tf.estimator.ModeKeys.EVAL,
[VALID_FILE],
hyper_parameters.eval_batch_size, 1,
False)
valid_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=valid_input_fn, every_n_steps=hyper_parameters.eval_step)
monitors_list.append(valid_monitor)
hooks = tf.contrib.learn.monitors.replace_monitors_with_hooks(
monitors_list, estimator)
train_input_fn = input.create_input_fn(tf.estimator.ModeKeys.TRAIN,
[TRAIN_FILE],
hyper_parameters.batch_size,
hyper_parameters.num_epochs,
hyper_parameters.shuffle_batch)
estimator.train(input_fn=train_input_fn, hooks=hooks)
hparam.write_hparams_to_file(hyper_parameters, MODEL_DIR)
def main(unused_arg):
eval_model_fn = model.create_model_fn()
if not FLAGS.model_dir:
raise KeyError()
else:
MODEL_DIR = FLAGS.model_dir
hyper_parameters = hparam.create_hparam()
estimator = tf.estimator.Estimator(eval_model_fn, model_dir=MODEL_DIR, params=hyper_parameters)
EVAL_FILE = './data/validation.tfrecords'
eval_input_fn = input.create_input_fn(tf.estimator.ModeKeys.EVAL,[EVAL_FILE],hyper_parameters.eval_batch_size,1,False)
monitors_list = []
if FLAGS.debug:
debuger = tf_debug.LocalCLIDebugHook()
monitors_list.append(debuger)
hooks = tf.contrib.learn.monitors.replace_monitors_with_hooks(monitors_list, estimator)
eval_result = estimator.evaluate(input_fn=eval_input_fn,hooks=hooks)
print('precision: {}'.format(eval_result['precision']))
print('recall: {}'.format(eval_result['recall']))
tf.flags.DEFINE_string("test_file", "./data/test.tfrecords",
"Path of test data in TFRecords format")
tf.flags.DEFINE_string("model_dir", None,
"Directory to load model checkpoints from")
tf.flags.DEFINE_integer("loglevel", 20, "Tensorflow log level")
tf.flags.DEFINE_integer("test_batch_size", 16, "Batch size for testing")
FLAGS = tf.flags.FLAGS
if not FLAGS.model_dir:
print("You must specify a model directory")
sys.exit(1)
tf.logging.set_verbosity(FLAGS.loglevel)
if __name__ == "__main__":
hparams = hparams.create_hparams()
model_fn = model.create_model_fn(hparams, model_impl=dual_encoder_model)
estimator = tf.contrib.learn.Estimator(model_fn=model_fn,
model_dir=FLAGS.model_dir,
config=tf.contrib.learn.RunConfig())
input_fn_test = inputs.create_input_fn(mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[FLAGS.test_file],
batch_size=FLAGS.test_batch_size,
num_epochs=1)
eval_metrics = metrics.create_evaluation_metrics()
estimator.evaluate(input_fn=input_fn_test,
steps=None,
metrics=eval_metrics)
if FLAGS.network == "LSTM":
selected_model = lstm
elif FLAGS.network == "DSSM":
selected_model = dssm
else:
selected_model = mn
tf.logging.set_verbosity(tf.logging.INFO)
if __name__ == "__main__":
# Load hyperparameters
hparams = config.create_config()
# Prepare function that will be used for loading context/utterance
model_fn = model.create_model_fn(hparams, model_impl=selected_model)
# Prepare estimator
estimator = tf.contrib.learn.Estimator(
model_fn=model_fn,
model_dir=FLAGS.model_dir,
config=tf.contrib.learn.RunConfig(gpu_memory_fraction=0.25))
# Prepare input testing examples
input_fn_test = inputs.create_input_fn(mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[FLAGS.test_file],
batch_size=FLAGS.test_batch_size,
num_epochs=1,
params=hparams)
eval_metrics = metrics.create_evaluation_metrics()
def main(unused_argv):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
hyper_params = create_hparams()
print("\n\nModel hyperparameters", hyper_params)
model_fn = model.create_model_fn(hyper_params,
model_impl=dual_encoder_model)
estimator = tf.contrib.learn.Estimator(
model_fn=model_fn,
model_dir=MODEL_DIR,
config=tf.contrib.learn.RunConfig(session_config=config))
# Training mode
if not FLAGS.infer_mode:
input_fn_train = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.TRAIN,
input_files=[TRAIN_FILE],
batch_size=hyper_params.batch_size,
num_epochs=FLAGS.num_epochs,
has_dssm=hyper_params.dssm,
has_lcs=hyper_params.lcs,
)
input_fn_eval = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.EVAL,
input_files=[VALIDATION_FILE],
batch_size=hyper_params.eval_batch_size,
num_epochs=1,
has_dssm=hyper_params.dssm,
has_lcs=hyper_params.lcs,
)
eval_metrics = metrics.create_evaluation_metrics()
eval_monitor = tf.contrib.learn.monitors.ValidationMonitor(
input_fn=input_fn_eval,
every_n_steps=FLAGS.eval_every,
metrics=eval_metrics,
)
estimator.fit(input_fn=input_fn_train,
steps=None,
monitors=[eval_monitor])
# Testing mode
else:
input_fn_infer = inputs.create_input_fn(
mode=tf.contrib.learn.ModeKeys.INFER,
input_files=[TEST_FILE],
batch_size=hyper_params.eval_batch_size,
num_epochs=1,
has_dssm=hyper_params.dssm,
has_lcs=hyper_params.lcs,
randomize=False)
preds = estimator.predict(input_fn=input_fn_infer)
i = 0
with open(FLAGS.test_out, 'w') as f:
for pred in preds:
i += 1
output_string = ",".join([("%.15f" % indi) for indi in pred])
f.write(output_string + "\n")
print(i)