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)