def main(_):
tf_logging.info("TripleBertMasking")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_cppnc_triple(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
def override_prediction_fn(predictions, model):
for key, value in model.get_predictions().items():
predictions[key] = value
return predictions
if FLAGS.modeling == "TripleBertMasking":
model_class = TripleBertMasking
elif FLAGS.modeling == "TripleBertWeighted":
model_class = TripleBertWeighted
else:
assert False
model_fn = model_fn_classification(config, train_config, model_class,
special_flags, override_prediction_fn)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
input_files = get_input_files_from_flags(FLAGS)
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
model_fn = model_fn_classification(
config,
train_config,
BertModel,
special_flags
)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
is_training = FLAGS.do_train
if FLAGS.do_train or FLAGS.do_eval:
input_fn = input_fn_builder_classification(input_files, FLAGS.max_seq_length, is_training, FLAGS,
num_cpu_threads=4,
repeat_for_eval=False)
else:
input_fn = input_fn_builder_classification_w_data_id2(
input_files,
FLAGS.max_seq_length,
FLAGS,
is_training,
num_cpu_threads=4)
result = run_estimator(model_fn, input_fn)
return result
def main(_):
input_files = get_input_files_from_flags(FLAGS)
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
is_training = FLAGS.do_train
if FLAGS.do_train or FLAGS.do_eval:
model_fn = model_fn_with_loss(
config,
train_config,
MES_hinge,
)
input_fn = input_fn_builder_pairwise(FLAGS.max_d_seq_length, FLAGS)
else:
model_fn = model_fn_with_loss(
config,
train_config,
MES_pred,
)
input_fn = input_fn_builder_classification_w_data_id2(
input_files,
FLAGS.max_seq_length,
FLAGS,
is_training,
num_cpu_threads=4)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
result = run_estimator(model_fn, input_fn)
return result
def main(_):
tf_logging.info("Classification with alt loss")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_from_flags(input_fn_builder_classification, FLAGS)
model_fn = model_fn_classification_with_alt_loss(config, train_config, BertModel)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("Classification with confidence")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_two_inputs_w_data_id(FLAGS)
model_fn = model_fn_classification_with_confidence(config, train_config)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("Regression with weigth")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_regression(get_input_files_from_flags(FLAGS),
FLAGS, FLAGS.do_train)
model_fn = model_fn_regression(config, train_config)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("Manual combiner")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_two_inputs_w_data_id(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_classification_manual_combiner(config, train_config)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("Multi-evidence for QK")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_vector_ck(FLAGS, config)
special_flags = []
model_fn = vector_combining_model(config, train_config, special_flags)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("QCK with ME7")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_cppnc_multi_evidence(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_classification(config, train_config, ME7,
special_flags)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("QCK with rel")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_two_inputs_w_rel(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_classification(config, train_config,
DualBertTwoInputWRel, special_flags)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("DualBertTwoInputWithDoubleInputLength")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_dual_bert_double_length_input(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_classification(config, train_config,
DualBertTwoInputWithDoubleInputLength,
special_flags)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def run_classification_w_second_input():
input_files = get_input_files_from_flags(FLAGS)
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_classification(config, train_config, ME5_2,
special_flags)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
input_fn = input_fn_builder_cppnc_multi_evidence(FLAGS)
result = run_estimator(model_fn, input_fn)
return result
def run_classification_w_second_input():
input_files = get_input_files_from_flags(FLAGS)
bert_config = BertConfig.from_json_file(FLAGS.bert_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
model_fn = model_fn_classification(
bert_config,
train_config,
)
input_fn = input_fn_builder_use_second_input(FLAGS)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
result = run_estimator(model_fn, input_fn)
return result
def main(_):
tf_logging.info("Token scoring")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_files = get_input_files_from_flags(FLAGS)
show_input_files(input_files)
input_fn = input_fn_token_scoring2(input_files, FLAGS, FLAGS.do_train)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_token_scoring(config, train_config)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
input_files = get_input_files_from_flags(FLAGS)
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
model_fn = model_fn_classification_with_ada(
config,
train_config,
)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
input_fn = input_fn_builder_ada(input_files, FLAGS, FLAGS.do_train)
result = run_estimator(model_fn, input_fn)
return result
def main(_):
input_files = get_input_files_from_flags(FLAGS)
bert_config = BertConfig.from_json_file(FLAGS.bert_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
model_fn = model_fn_sensitivity(
bert_config=bert_config,
train_config=train_config,
model_class=BertModel,
special_flags=special_flags,
)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
input_fn = input_fn_builder_use_second_input(FLAGS)
result = run_estimator(model_fn, input_fn)
return result
def main(_):
input_files = get_input_files_from_flags(FLAGS)
show_input_files(input_files)
if FLAGS.do_predict:
model_fn = model_fn_rank_pred(FLAGS)
input_fn = input_fn_builder_prediction_w_data_id(
input_files=input_files, max_seq_length=FLAGS.max_seq_length)
else:
assert False
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
result = run_estimator(model_fn, input_fn)
return result
def run_w_data_id():
input_files = get_input_files_from_flags(FLAGS)
bert_config = BertConfig.from_json_file(FLAGS.bert_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
model_fn = model_fn_classification(
bert_config=bert_config,
train_config=train_config,
model_class=BertModel,
special_flags=special_flags,
)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
input_fn = input_fn_builder_classification_w_data_id(
input_files=input_files, flags=FLAGS, is_training=FLAGS.do_train)
result = run_estimator(model_fn, input_fn)
return result
def main(_):
tf_logging.info("DualBertTwoInputModel Two learning rate")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_two_inputs_w_data_id(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
def lr_group_b(name):
return dual_model_prefix1 in name
lr_factor = 1 / 50
model_fn = model_fn_classification(config, train_config,
DualBertTwoInputModel, special_flags,
lr_group_b, lr_factor)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("Multi-evidence with Dot Product (CK version)")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
total_doc_length = config.max_doc_length * config.num_docs
input_fn = input_fn_builder_dot_product_ck(FLAGS, config.max_sent_length, total_doc_length)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
modeling = FLAGS.modeling
if modeling is None:
model_class = BertModel
elif modeling == "pmp":
model_class = ProjectedMaxPooling
else:
assert False
model_fn = model_fn_pointwise_ranking(config, train_config, model_class, special_flags)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
tf_logging.info("DualBertTwoInputModel simple prediction")
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
input_fn = input_fn_builder_two_inputs_w_data_id(FLAGS)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
def override_prediction_fn(predictions, model):
predictions.pop('input_ids', None)
try:
predictions.pop('input_ids2', None)
except KeyError:
pass
return predictions
model_fn = model_fn_classification(config, train_config,
DualBertTwoInputModel, special_flags,
override_prediction_fn)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
return run_estimator(model_fn, input_fn)
def main(_):
input_files = get_input_files_from_flags(FLAGS)
config = JsonConfig.from_json_file(FLAGS.model_config_file)
train_config = TrainConfigEx.from_flags(FLAGS)
show_input_files(input_files)
special_flags = FLAGS.special_flags.split(",")
special_flags.append("feed_features")
is_training = FLAGS.do_train
model_fn = model_fn_binary_classification_loss(
config,
train_config,
MES_const_0_handle,
)
input_fn = input_fn_builder_classification(input_files,
FLAGS.max_d_seq_length,
is_training,
FLAGS,
num_cpu_threads=4,
repeat_for_eval=False)
if FLAGS.do_predict:
tf_logging.addFilter(MuteEnqueueFilter())
result = run_estimator(model_fn, input_fn)
return result
