def main(unused_argv):
if not FLAGS.data_dir:
raise ValueError("--data_dir is required.")
if not FLAGS.model_config:
raise ValueError("--model_config is required.")
encoder = encoder_manager.EncoderManager()
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
if type(model_config) is dict:
model_config = [model_config]
for mdl_cfg in model_config:
model_config = configuration.model_config(mdl_cfg, mode="encode")
encoder.load_model(model_config)
if FLAGS.eval_task in ["MR", "CR", "SUBJ", "MPQA"]:
results = eval_classification.eval_nested_kfold(
encoder, FLAGS.eval_task, FLAGS.data_dir, use_nb=False)
scores = results[0]
print('Mean score', np.mean(scores))
elif FLAGS.eval_task == "SICK":
results = eval_sick.evaluate(encoder, evaltest=True, loc=FLAGS.data_dir)
elif FLAGS.eval_task == "MSRP":
results = eval_msrp.evaluate(
encoder, evalcv=True, evaltest=True, use_feats=False, loc=FLAGS.data_dir)
elif FLAGS.eval_task == "TREC":
eval_trec.evaluate(encoder, evalcv=True, evaltest=True, loc=FLAGS.data_dir)
else:
raise ValueError("Unrecognized eval_task: %s" % FLAGS.eval_task)
encoder.close()
def load_model(FLAGS):
if FLAGS.sr_model == 'IS':
#Load InferSent
MODEL_PATH = os.path.join(FLAGS.is_dir, 'encoder/infersent1.pkl')
params_model = {
'bsize': 64,
'word_emb_dim': 300,
'enc_lstm_dim': 2048,
'pool_type': 'max',
'dpout_model': 0.0,
'version': 1
}
model = InferSent(params_model)
model.load_state_dict(torch.load(MODEL_PATH))
W2V_PATH = os.path.join(FLAGS.is_dir,
'dataset/GloVe/glove.840B.300d.txt')
model.set_w2v_path(W2V_PATH)
elif FLAGS.sr_model == 'QT':
# Load Quick-Thought
model = encoder_manager.EncoderManager()
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
if type(model_config) is dict:
model_config = [model_config]
for mdl_cfg in model_config:
model_config = configuration.model_config(mdl_cfg, mode='encode')
model.load_model(model_config)
elif FLAGS.sr_model == 'USE':
model = hub.Module(
'https://tfhub.dev/google/universal-sentence-encoder-large/2')
return model
def main(_):
with tf.Graph().as_default() as single_gpu_graph:
model_config = configuration.model_config(
input_file_pattern=FLAGS.input_file_pattern,
batch_size=FLAGS.batch_size)
training_config = configuration.training_config()
model = skip_thoughts_model.SkipThoughtsModel(model_config,
mode="train")
model.build()
# Setup learning rate
if training_config.learning_rate_decay_factor > 0:
learning_rate = tf.train.exponential_decay(
learning_rate=float(training_config.learning_rate),
global_step=model.global_step,
decay_steps=training_config.learning_rate_decay_steps,
decay_rate=training_config.learning_rate_decay_factor,
staircase=False)
else:
learning_rate = tf.constant(training_config.learning_rate)
optimizer = tf.train.AdamOptimizer(learning_rate)
train_tensor = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
global_step=model.global_step,
clip_gradient_norm=training_config.clip_gradient_norm)
def run(sess, num_iters, tensor_or_op_name_to_replica_names, num_workers,
worker_id, num_replicas_per_worker):
fetches = {
'global_step':
tensor_or_op_name_to_replica_names[model.global_step.name][0],
'cost':
tensor_or_op_name_to_replica_names[model.total_loss.name][0],
'train_op':
tensor_or_op_name_to_replica_names[train_tensor.name][0],
}
start = time.time()
for i in range(num_iters):
results = sess.run(fetches)
if i % FLAGS.log_frequency == 0:
end = time.time()
throughput = float(FLAGS.log_frequency) / float(end - start)
parallax.log.info(
"global step: %d, loss: %f, throughput: %f steps/sec" %
(results['global_step'], results['cost'], throughput))
start = time.time()
parallax.parallel_run(single_gpu_graph,
run,
FLAGS.resource_info_file,
FLAGS.max_steps,
sync=FLAGS.sync,
parallax_config=parallax_config.build_config())
def main(unused_argv):
if not FLAGS.data_dir:
raise ValueError("--data_dir is required.")
encoder = encoder_manager.EncoderManager()
# Maybe load unidirectional encoder.
if FLAGS.uni_checkpoint_path:
print("Loading unidirectional model...")
uni_config = configuration.model_config()
encoder.load_model(uni_config, FLAGS.uni_vocab_file,
FLAGS.uni_embeddings_file,
FLAGS.uni_checkpoint_path)
# Maybe load bidirectional encoder.
if FLAGS.bi_checkpoint_path:
print("Loading bidirectional model...")
bi_config = configuration.model_config(bidirectional_encoder=True)
encoder.load_model(bi_config, FLAGS.bi_vocab_file,
FLAGS.bi_embeddings_file, FLAGS.bi_checkpoint_path)
if FLAGS.eval_task in ["MR", "CR", "SUBJ", "MPQA"]:
# we changed from skip-thoughts to ec.
ec.eval_nested_kfold(encoder,
FLAGS.eval_task,
FLAGS.data_dir,
use_nb=False)
elif FLAGS.eval_task == "SICK":
eval_sick.evaluate(encoder, evaltest=True, loc=FLAGS.data_dir)
elif FLAGS.eval_task == "MSRP":
eval_msrp.evaluate(encoder,
evalcv=True,
evaltest=True,
use_feats=True,
loc=FLAGS.data_dir)
elif FLAGS.eval_task == "TREC":
eval_trec.evaluate(encoder,
evalcv=True,
evaltest=True,
loc=FLAGS.data_dir)
else:
raise ValueError("Unrecognized eval_task: %s" % FLAGS.eval_task)
encoder.close()
def load_model(self, FLAGS):
tf.logging.set_verbosity(tf.logging.INFO)
model = encoder_manager.EncoderManager()
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
if type(model_config) is dict:
model_config = [model_config]
for mdl_cfg in model_config:
model_config = configuration.model_config(mdl_cfg, mode="encode")
model.load_model(model_config)
return model
def main(unused_argv):
if ((not FLAGS.input_file_pattern_word) |
(not FLAGS.input_file_pattern_POS)):
print("Hello")
raise ValueError("--input_file_pattern is required.")
if not FLAGS.train_dir:
raise ValueError("--train_dir is required.")
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
model_config = configuration.model_config(model_config, mode="train")
tf.logging.info("Building training graph.")
g = tf.Graph()
with g.as_default():
model = s2v_model.s2v(model_config, mode="train")
model.build()
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
train_tensor = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
clip_gradient_norm=FLAGS.clip_gradient_norm)
#global_step=model.global_step,
if FLAGS.max_ckpts != 5:
saver = tf.train.Saver(max_to_keep=FLAGS.max_ckpts)
else:
saver = tf.train.Saver()
load_words = model.init
if load_words:
def InitAssignFn(sess):
sess.run(load_words[0], {load_words[1]: load_words[2]})
nsteps = int(FLAGS.nepochs * (FLAGS.num_train_inst / FLAGS.batch_size))
tf.contrib.slim.learning.train(
train_op=train_tensor,
logdir=FLAGS.train_dir,
graph=g,
number_of_steps=nsteps,
save_summaries_secs=FLAGS.save_summaries_secs,
saver=saver,
save_interval_secs=FLAGS.save_model_secs,
init_fn=InitAssignFn if load_words else None)
def main(unused_argv):
if not FLAGS.input_file_pattern:
raise ValueError("--input_file_pattern is required.")
if not FLAGS.checkpoint_dir:
raise ValueError("--checkpoint_dir is required.")
if not FLAGS.eval_dir:
raise ValueError("--eval_dir is required.")
# Create the evaluation directory if it doesn't exist.
eval_dir = FLAGS.eval_dir
if not tf.gfile.IsDirectory(eval_dir):
tf.logging.info("Creating eval directory: %s", eval_dir)
tf.gfile.MakeDirs(eval_dir)
g = tf.Graph()
with g.as_default():
# Build the model for evaluation.
model_config = configuration.model_config(
input_file_pattern=FLAGS.input_file_pattern,
input_queue_capacity=FLAGS.num_eval_examples,
shuffle_input_data=False)
model = skip_thoughts_model.SkipThoughtsModel(model_config,
mode="eval")
model.build()
losses = tf.concat(model.target_cross_entropy_losses, 0)
weights = tf.concat(model.target_cross_entropy_loss_weights, 0)
# Create the Saver to restore model Variables.
saver = tf.train.Saver()
# Create the summary operation and the summary writer.
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(eval_dir)
g.finalize()
# Run a new evaluation run every eval_interval_secs.
while True:
start = time.time()
tf.logging.info(
"Starting evaluation at " +
time.strftime("%Y-%m-%d-%H:%M:%S", time.localtime()))
run_once(model, losses, weights, saver, summary_writer, summary_op)
time_to_next_eval = start + FLAGS.eval_interval_secs - time.time()
if time_to_next_eval > 0:
time.sleep(time_to_next_eval)
def main(unused_argv):
if not FLAGS.input_file_pattern:
raise ValueError("--input_file_pattern is required.")
if not FLAGS.train_dir:
raise ValueError("--train_dir is required.")
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
model_config = configuration.model_config(model_config, mode="train")
tf.logging.info("Building training graph.")
g = tf.Graph()
with g.as_default():
model = s2v_model.s2v(model_config, mode="train")
model.build()
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
train_tensor = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
clip_gradient_norm=FLAGS.clip_gradient_norm)
saver = tf.train.Saver(max_to_keep=FLAGS.max_ckpts)
checkpoint_path = model_config.checkpoint_path
variables_to_restore = slim.get_model_variables()
checkpoint_path = tf.train.latest_checkpoint(model_config.checkpoint_path)
init_assign_op, init_feed_dict = slim.assign_from_checkpoint(
checkpoint_path, variables_to_restore)
def InitAssignFn(sess):
sess.run(init_assign_op, init_feed_dict)
nsteps = int(FLAGS.nepochs * (FLAGS.num_train_inst / FLAGS.batch_size))
slim.learning.train(
train_op=train_tensor,
logdir=FLAGS.train_dir,
graph=g,
number_of_steps=nsteps,
save_summaries_secs=FLAGS.save_summaries_secs,
saver=saver,
save_interval_secs=FLAGS.save_model_secs,
init_fn=InitAssignFn
)
def main(unused_argv):
if not FLAGS.input_file_pattern:
raise ValueError("--input_file_pattern is required.")
if not FLAGS.train_dir:
raise ValueError("--train_dir is required.")
model_config = configuration.model_config(
input_file_pattern=FLAGS.input_file_pattern)
training_config = configuration.training_config()
tf.logging.info("Building training graph.")
g = tf.Graph()
with g.as_default():
model = skip_thoughts_model.SkipThoughtsModel(model_config,
mode="train")
model.build()
learning_rate = _setup_learning_rate(training_config,
model.global_step)
optimizer = tf.train.AdamOptimizer(learning_rate)
train_tensor = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
global_step=model.global_step,
clip_gradient_norm=training_config.clip_gradient_norm)
saver = tf.train.Saver()
tf.contrib.slim.learning.train(
train_op=train_tensor,
logdir=FLAGS.train_dir,
graph=g,
global_step=model.global_step,
number_of_steps=training_config.number_of_steps,
save_summaries_secs=training_config.save_summaries_secs,
saver=saver,
save_interval_secs=training_config.save_model_secs)
def main(unused_argv):
if not FLAGS.input_file_pattern:
raise ValueError("--input_file_pattern is required.")
if not FLAGS.checkpoint_dir:
raise ValueError("--checkpoint_dir is required.")
if not FLAGS.eval_dir:
raise ValueError("--eval_dir is required.")
eval_dir = FLAGS.eval_dir
if not tf.gfile.IsDirectory(eval_dir):
tf.logging.info("Creating eval directory: %s", eval_dir)
tf.gfile.MakeDirs(eval_dir)
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
model_config = configuration.model_config(model_config, mode="eval")
model = s2v_model.s2v(model_config, mode="eval")
model.build()
tf.summary.scalar("Loss", model.total_loss)
summary_op = tf.summary.merge_all()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
nsteps = int(FLAGS.num_eval_examples / FLAGS.batch_size)
tf.contrib.slim.evaluation.evaluation_loop(
master=FLAGS.master,
checkpoint_dir=FLAGS.checkpoint_dir,
logdir=FLAGS.eval_dir,
num_evals=nsteps,
eval_op=model.eval_op,
summary_op=summary_op,
eval_interval_secs=FLAGS.eval_interval_secs,
session_config=config)
def loadConfiguration(self):
with open(QuickThoughtSentenceEncoder.DEFAULT_CONFIGURATION
) as json_file:
confDictionary = json.load(json_file)
return model_config(confDictionary, 'fixed')
def main(unused_argv):
model_config = configuration.model_config(
lambda_rho=float(FLAGS.lambda_rho),
lambda_rho_f=float(FLAGS.lambda_rho_f),
lambda_ranking=float(FLAGS.lambda_ranking),
lambda_ranking_text=float(FLAGS.lambda_ranking_text),
lambda_ranking_text_f=float(FLAGS.lambda_ranking_text_f),
lambda_cap2cap=float(FLAGS.lambda_cap2cap),
lambda_infer=float(FLAGS.lambda_infer),
lambda_quick=float(FLAGS.lambda_quick),
lambda_Iinfer=float(FLAGS.lambda_Iinfer),
lambda_nn=float(FLAGS.lambda_nn),
hidden_dim=FLAGS.hidden_dim,
train_folder=train_dir,
distance=FLAGS.distance,
rank_distance=FLAGS.rank_distance,
nb_layer=FLAGS.nb_layer,
word_embedding_dim=FLAGS.word_embedding_dim,
SICK_trial=os.environ["SICK_TRIAL"],
bin_dir=os.environ["GROUNDSENT_BIN_DIR"],
mu_reg=FLAGS.mu_reg,
val_sim_pattern=val_sim_pattern,
sim_pattern=sim_pattern,
nn_pattern=nn_pattern,
val_nn_pattern=val_nn_pattern,
validation_pattern=validation_pattern,
bookcorpus_pattern=input_bookcorpus_pattern,
visual_pattern=input_visual_pattern,
encoder_dim=FLAGS.encoder_dim,
ST=FLAGS.ST,
video_embedding=FLAGS.video_embedding,
projected_image_dim=int(FLAGS.projected_im),
text_negative_number=int(FLAGS.neg_words),
visual_batch_size=int(FLAGS.v_batch),
lambda_text=float(FLAGS.lambda_text),
textual=FLAGS.textual,
visual_batch=int(FLAGS.v_batch),
bookcorpus_batch_size=batch)
training_config = configuration.training_config(
lr=lr, learning_rate_decay_factor=lr_decay)
tf.logging.info("Building training graph.")
g = tf.Graph()
with g.as_default():
model = skip_thoughts_model.SkipThoughtsModel(model_config,
mode="train")
model.build()
optimizer = tf.train.AdamOptimizer(
_setup_learning_rate(training_config, model.global_step, "total"))
ckpt = tf.train.get_checkpoint_state(train_dir)
train_total = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
global_step=model.global_step,
clip_gradient_norm=training_config.clip_gradient_norm,
variables_to_train=tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES))
if ckpt:
#ckpt_file = train_dir + "/model.ckpt-" + ckpt.model_checkpoint_path.split("-")[1]
ckpt_file = ckpt.model_checkpoint_path
variables_to_restore = optimistic_restore_vars(ckpt_file)
else:
variables_to_restore = None
saver = tf.train.Saver(var_list=variables_to_restore, max_to_keep=2)
if FLAGS.encoder_train == 0:
encoder_variables = [
v for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
if ("encoder" in v.name) or ("w_embedding" in v.name)
]
saver_encoder = tf.train.Saver(var_list=encoder_variables,
max_to_keep=2)
else:
encoder_variables = []
trainable_variables = [
v for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)
if v not in encoder_variables
]
train_total = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
global_step=model.global_step,
clip_gradient_norm=training_config.clip_gradient_norm,
variables_to_train=trainable_variables)
if ckpt:
var_to_init = []
for v in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES):
if v not in variables_to_restore:
if v not in encoder_variables:
var_to_init.append(v)
local_init_op = tf.variables_initializer(var_to_init)
else:
local_init_op = tf.global_variables_initializer()
#tf.logging.info("Variables to init")
#for v in var_to_init:
# print(v.name)
#tf.logging.info("Variables to restore")
#for v in variables_to_restore:
# print(v.name)
tf.logging.info("Variables to train")
for v in trainable_variables:
print(v.name)
if ckpt:
sess = tf.InteractiveSession()
saver.restore(sess, ckpt.model_checkpoint_path)
sess.run(local_init_op)
saver_2 = tf.train.Saver(max_to_keep=2)
saver_2.save(sess, ckpt.model_checkpoint_path)
current_step = sess.run(model.global_step)
sess.close()
else:
saver_2 = tf.train.Saver(max_to_keep=2)
session_config = tf.ConfigProto()
session_config.gpu_options.allow_growth = True
tf.contrib.slim.learning.train(
session_config=session_config,
train_op=train_total,
saver=saver_2,
local_init_op=local_init_op,
logdir=train_dir,
graph=g,
global_step=model.global_step,
number_of_steps=FLAGS.nb_steps,
save_summaries_secs=training_config.save_summaries_secs,
save_interval_secs=training_config.save_model_secs)
evaluation.evaluate(train_dir, FLAGS.encoder_dim, "T", FLAGS.textual, 0)
import configuration
import encoder_manager
import numpy as np
import document as doc
# Set paths to the model.
VOCAB_FILE = "./data/vocab.txt"
EMBEDDING_MATRIX_FILE = 'use_trained_model'
CHECKPOINT_PATH = "./model/train/model.ckpt-22638"
TEXT_FILE = "/home/shmuelfeld/Desktop/inputFiles_Heb/*.txt"
data = []
tfidf = TFIDF()
tfidf_dict = tfidf.get_tfidf_dic(TEXT_FILE)
encoder = encoder_manager.EncoderManager()
encoder.load_model(configuration.model_config(),
vocabulary_file=VOCAB_FILE,
embedding_matrix_file=EMBEDDING_MATRIX_FILE,
checkpoint_path=CHECKPOINT_PATH)
def sentence_to_vec(sentence):
sen = list()
sen.append(sentence)
return encoder.encode(sen)
def sens2vec(list_of_sentences, total_tfidf):
multed = []
for sent in list_of_sentences:
if total_tfidf == 0:
def main(unused_argv):
if not FLAGS.data_dir:
raise ValueError("--data_dir is required.")
if not FLAGS.model_config:
raise ValueError("--model_config is required.")
encoder = encoder_manager.EncoderManager()
with open(FLAGS.model_config) as json_config_file:
model_config = json.load(json_config_file)
if type(model_config) is dict:
model_config = [model_config]
sp = None
if FLAGS.sentencepiece_model_path:
print('Loading sentencepiece model', FLAGS.sentencepiece_model_path)
sp = spm.SentencePieceProcessor()
sp.Load(FLAGS.sentencepiece_model_path)
for mdl_cfg in model_config:
model_config = configuration.model_config(mdl_cfg, mode="encode")
encoder.load_model(model_config)
if FLAGS.eval_task in ["MR", "CR", "SUBJ", "MPQA"]:
results = eval_classification.eval_nested_kfold(encoder,
FLAGS.eval_task,
FLAGS.data_dir,
use_nb=False)
scores = results[0]
print('Mean score', np.mean(scores))
elif FLAGS.eval_task == "SICK":
results = eval_sick.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
sp=sp)
elif FLAGS.eval_task == "MSRP":
results = eval_msrp.evaluate(encoder,
evalcv=True,
evaltest=True,
use_feats=False,
loc=FLAGS.data_dir)
elif FLAGS.eval_task == "TREC":
eval_trec.evaluate(encoder,
evalcv=True,
evaltest=True,
loc=FLAGS.data_dir)
elif FLAGS.eval_task == 'SNLI-MT-TR':
file_meta_data = {
'file_names': {
'train': 'snli_train_translation.jsonl',
'dev': 'snli_dev_translation.jsonl',
'test': 'snli_test_translation.jsonl'
},
'sentence_keys': {
'sentence1': 'translate-sentence1',
'sentence2': 'translate-sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral']
}
eval_nli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'SNLI':
file_meta_data = {
'file_names': {
'train': 'snli_1.0_train.jsonl',
'dev': 'snli_1.0_dev.jsonl',
'test': 'snli_1.0_test.jsonl'
},
'sentence_keys': {
'sentence1': 'sentence1',
'sentence2': 'sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral']
}
eval_nli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'MULTINLI-MT-TR-MATCHED':
file_meta_data = {
'file_names': {
'train':
'multinli_train_translation.jsonl',
'dev':
'multinli_dev_matched_translation.jsonl',
'test':
'multinli_0.9_test_matched_translation_unlabeled.jsonl',
'test_output':
'multinli_0.9_test_matched_translation_unlabeled_output.csv'
},
'sentence_keys': {
'sentence1': 'translate-sentence1',
'sentence2': 'translate-sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral']
}
eval_multinli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'MULTINLI-MATCHED':
file_meta_data = {
'file_names': {
'train': 'multinli_1.0_train.jsonl',
'dev': 'multinli_1.0_dev_matched.jsonl',
'test': 'multinli_0.9_test_matched_unlabeled.jsonl',
'test_output': 'multinli_0.9_test_matched_unlabeled_output.csv'
},
'sentence_keys': {
'sentence1': 'sentence1',
'sentence2': 'sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral']
}
eval_multinli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'MULTINLI-MT-TR-MISMATCHED':
file_meta_data = {
'file_names': {
'train':
'multinli_train_translation.jsonl',
'dev':
'multinli_dev_mismatched_translation.jsonl',
'test':
'multinli_0.9_test_mismatched_translation_unlabeled.jsonl',
'test_output':
'multinli_0.9_test_mismatched_translation_unlabeled_output.csv',
},
'sentence_keys': {
'sentence1': 'translate-sentence1',
'sentence2': 'translate-sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral']
}
eval_multinli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'MULTINLI-MISMATCHED':
file_meta_data = {
'file_names': {
'train': 'multinli_1.0_train.jsonl',
'dev': 'multinli_1.0_dev_mismatched.jsonl',
'test': 'multinli_0.9_test_mismatched_unlabeled.jsonl',
'test_output':
'multinli_0.9_test_mismatched_unlabeled_output.csv'
},
'sentence_keys': {
'sentence1': 'sentence1',
'sentence2': 'sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral']
}
eval_multinli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'XNLI-MT-TR':
file_meta_data = {
'file_names': {
'train': 'multinli_train_translation.jsonl',
'dev': 'xnli_dev_translation.jsonl',
'test': 'xnli_test_translation.jsonl'
},
'sentence_keys': {
'sentence1': 'translate-sentence1',
'sentence2': 'translate-sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral'],
'language': 'any'
}
eval_xnli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
elif FLAGS.eval_task == 'XNLI':
file_meta_data = {
'file_names': {
'train': 'multinli_1.0_train.jsonl',
'dev': 'xnli.dev.jsonl',
'test': 'xnli.test.jsonl'
},
'sentence_keys': {
'sentence1': 'sentence1',
'sentence2': 'sentence2'
},
'label_classes': ['contradiction', 'entailment', 'neutral'],
'language': 'en'
}
eval_xnli.evaluate(encoder,
evaltest=True,
loc=FLAGS.data_dir,
file_meta_data=file_meta_data,
sp=sp)
else:
raise ValueError("Unrecognized eval_task: %s" % FLAGS.eval_task)
encoder.close()
def main(input_file_pattern,
train_dir,
model_config,
word2vec_path,
learning_rate=0.005,
clip_gradient_norm=5.0,
uniform_init_scale=0.1,
shuffle_input_data=False,
input_queue_capacity=640000,
num_input_reader_threads=1,
dropout=False,
dropout_rate=0.3,
context_size=1,
num_train_inst=800000,
batch_size=128,
nepochs=1,
max_ckpts=5,
save_summaries_secs=600,
save_model_secs=600):
start = time.time()
if not input_file_pattern:
raise ValueError("--input_file_pattern is required.")
if not train_dir:
raise ValueError("--train_dir is required.")
with open(model_config) as json_config_file:
model_config = json.load(json_config_file)
model_config = configuration.model_config(model_config,
mode="train",
word2vec_path=word2vec_path)
tf.logging.info("Building training graph.")
g = tf.Graph()
with g.as_default():
model = s2v_model.s2v(model_config,
uniform_init_scale,
input_file_pattern,
shuffle_input_data,
input_queue_capacity,
num_input_reader_threads,
batch_size,
dropout,
dropout_rate,
context_size,
mode="train")
model.build()
optimizer = tf.train.AdamOptimizer(learning_rate)
train_tensor = tf.contrib.slim.learning.create_train_op(
total_loss=model.total_loss,
optimizer=optimizer,
clip_gradient_norm=clip_gradient_norm)
if max_ckpts != 5:
saver = tf.train.Saver(max_to_keep=max_ckpts)
else:
saver = tf.train.Saver()
load_words = model.init # ????????初始化的【encode，encode】，如果fixed
# print("load_words",load_words)
if load_words:
def InitAssignFn(sess):
sess.run(load_words[0], {load_words[1]: load_words[2]})
nsteps = int(nepochs * (num_train_inst / batch_size))
tf.contrib.slim.learning.train(
train_op=train_tensor,
logdir=train_dir,
graph=g,
number_of_steps=nsteps,
save_summaries_secs=save_summaries_secs,
saver=saver,
save_interval_secs=save_model_secs,
init_fn=InitAssignFn if load_words else None)
end = time.time()
cost_time = end - start
tf.logging.info("the cost time of training is %f ! ", cost_time)
import encoder_manager
import os
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
# Set paths to the model.
#
VOCAB_FILE = "pretrained/uni/vocab.txt"
EMBEDDING_MATRIX_FILE = "pretrained/uni/embeddings.npy"
CHECKPOINT_PATH = "pretrained/uni/model.ckpt-501424"
# Set up the encoder. Here we are using a single unidirectional model.
# To use a bidirectional model as well, call load_model() again with
# configuration.model_config(bidirectional_encoder=True) and paths to the
# bidirectional model's files. The encoder will use the concatenation of
# all loaded models.
encoder = encoder_manager.EncoderManager()
encoder.load_model(configuration.model_config(),
vocabulary_file=VOCAB_FILE,
embedding_matrix_file=EMBEDDING_MATRIX_FILE,
checkpoint_path=CHECKPOINT_PATH)
VOCAB_FILE = "pretrained/bi/vocab.txt"
EMBEDDING_MATRIX_FILE = "pretrained/bi/embeddings.npy"
CHECKPOINT_PATH = "pretrained/bi/model.ckpt-500008"
encoder.load_model(configuration.model_config(bidirectional_encoder=True),
vocabulary_file=VOCAB_FILE,
embedding_matrix_file=EMBEDDING_MATRIX_FILE,
checkpoint_path=CHECKPOINT_PATH)
five_events = ['ch', 'fg', 'gc', 'ow', 'ss']
stat = {}
stat['ch'] = (74, 93)