def main(_): valid_loader = TextLoader('valid', FLAGS.batch_size, 1, 1, 1) batch_queue_data = valid_loader.batch_data print("Loading data...") # Training # ================================================== with tf.variable_scope('SRLModel'): valid_cnn = SRLModel(batch_queue_data[0], batch_queue_data[1], batch_queue_data[2], batch_queue_data[3], labels=batch_queue_data[4], ori_inputs=batch_queue_data[-1], seq_length=batch_queue_data[5], num_classes=36, vocab_size=381057, embedding_size=FLAGS.embedding_dim, mark_embedding_size=FLAGS.mark_embedding_dim, batch_size=FLAGS.batch_size, cell_name=FLAGS.cell, hidden_size=FLAGS.hidden_size, num_layers=FLAGS.num_layers, dropout_keep_proba=1.0, LN_mode=True, dropout_mode=False, is_training=False) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True) sess = tf.Session(config=session_conf) sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) saver = tf.train.Saver() num_batches_valid = int(1115 / FLAGS.batch_size) check_point = os.path.join(FLAGS.train_dir, FLAGS.load_model) saver.restore(sess, check_point) global_step = check_point.split('/')[-1].split('-')[-1] global_step = int(global_step) print("load model from ", check_point) for step in range(num_batches_valid): inputs, scores, golds, lens, batch_loss = sess.run([ valid_cnn.ori_inputs, valid_cnn.scores, valid_cnn.labels, valid_cnn.seq_length, valid_cnn.loss ]) inputs, preds, golds = recover(inputs, scores, golds, lens) preds = convert(inputs, preds, False) golds = convert(inputs, golds, False) with codecs.open('data/cpbdev.txt', 'rb', encoding='utf-8') as f: with codecs.open('cpbdev1.txt', 'wb', encoding='utf-8') as writer: for line in f: line = line.strip() line = line.split() if not len(line): continue content = [] for labeled_word in line: labeled_word = labeled_word.split('/') content.append(labeled_word[0] + '/' + labeled_word[2]) writer.write(' '.join(content) + '\n') with codecs.open('cpbdev2.txt', 'wb', encoding='utf-8') as writer: for gold in golds: writer.write(' '.join(gold) + '\n') with codecs.open('cpbdev_answer2.txt', 'wb', encoding='utf-8') as writer: for pred in preds: writer.write(' '.join(pred) + '\n') writer = codecs.open('cpbdev_answer1.txt', 'wb', encoding='utf-8') final(preds, writer)
def main(_): valid_loader = TextLoader('test', FLAGS.batch_size, 1, 1, 1) batch_queue_data = valid_loader.batch_data print("Loading data...") # Training # ================================================== with tf.variable_scope('SRLModel'): valid_cnn = SRLModel(inputs=batch_queue_data[0], preds=batch_queue_data[1], contexts=batch_queue_data[2], marks=batch_queue_data[3], labels=batch_queue_data[4], ori_inputs=batch_queue_data[-1], seq_length=batch_queue_data[5], num_classes=36, vocab_size=381057, embedding_size=FLAGS.embedding_dim, mark_embedding_size=FLAGS.mark_embedding_dim, batch_size=FLAGS.batch_size, cell_name=FLAGS.cell, hidden_size=FLAGS.hidden_size, num_layers=FLAGS.num_layers, dropout_keep_proba=1.0, dropout_mode=False, is_training=False) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True) sess = tf.Session(config=session_conf) sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) saver = tf.train.Saver() num_batches_valid = int(2018 / FLAGS.batch_size) check_point = os.path.join(FLAGS.train_dir, FLAGS.load_model) saver.restore(sess, check_point) global_step = check_point.split('/')[-1].split('-')[-1] global_step = int(global_step) print("load model from ", check_point) for step in range(num_batches_valid): inputs, scores, golds, lens, batch_loss, matrix = sess.run([ valid_cnn.ori_inputs, valid_cnn.scores, valid_cnn.labels, valid_cnn.seq_length, valid_cnn.loss, valid_cnn.transition_params ]) inputs, preds, golds = recover(inputs, scores, golds, lens, matrix) preds = convert(inputs, preds, False) writer = codecs.open('cpbtest_answer1.txt', 'wb', encoding='utf-8') final(preds, writer) golds = [ gold.split() for gold in codecs.open('data/cpbtest.txt', 'r', encoding='utf-8'). read().strip().split('\n') ] preds = [ pred.split() for pred in codecs.open('cpbtest_answer1.txt', 'r', encoding='utf-8').read().strip().split('\n') ] writer = codecs.open('cpbtest_answer.txt', 'wb', encoding='utf-8') for gold, pred in zip(golds, preds): content = [] for item_gold, item_pred in zip(gold, pred): item_gold = item_gold.split('/') item_pred = item_pred.split('/') ct = [] ct.append(item_pred[0]) ct.append(item_gold[1]) ct.append(item_pred[1]) content.append('/'.join(ct)) writer.write(' '.join(content) + '\n')
def main(_): if not os.path.exists(FLAGS.train_dir): os.mkdir(FLAGS.train_dir) print('Created training directory', FLAGS.train_dir) train_loader = TextLoader('train', FLAGS.batch_size, 4, 1, None) batch_queue_data = train_loader.batch_data print("Loading data...") # Training # ================================================== '''define graph''' global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False) num_batches_train = int(17840 / (FLAGS.batch_size * FLAGS.num_gpus)) print('num_batches_train: %d' % num_batches_train) '''decay_steps = FLAGS.decay_steps lr = tf.train.exponential_decay(FLAGS.learning_rate, global_step, decay_steps, FLAGS.learning_rate_decay, staircase=True)''' opt = tf.train.AdamOptimizer(FLAGS.learning_rate) with tf.variable_scope('SRLModel'): train_cnn = SRLModel(batch_queue_data[0], batch_queue_data[1], batch_queue_data[2], batch_queue_data[3], labels=batch_queue_data[4], ori_inputs=batch_queue_data[-1], seq_length=batch_queue_data[5], num_classes=36, vocab_size=381057, embedding_size=FLAGS.embedding_dim, mark_embedding_size=FLAGS.mark_embedding_dim, batch_size=FLAGS.batch_size, cell_name=FLAGS.cell, hidden_size=FLAGS.hidden_size, num_layers=FLAGS.num_layers, dropout_keep_proba=FLAGS.dropout_keep_prob, LN_mode=FLAGS.LN_mode, dropout_mode=FLAGS.dropout_mode, is_training=True) gradient, tvar = zip(*opt.compute_gradients(train_cnn.loss)) gradient, _ = tf.clip_by_global_norm(gradient, FLAGS.max_grad_norm) grads = zip(gradient, tvar) apply_gradient_op = opt.apply_gradients(grads, global_step=global_step) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True) sess = tf.Session(config=session_conf) # Checkpoint directory. saver = tf.train.Saver(tf.global_variables(), max_to_keep=FLAGS.num_checkpoints) # Initialize all variables sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) pre_trained_embedding = np.load('data/embed.npy') print len(pre_trained_embedding) sess.run( train_cnn.embedding_init, feed_dict={train_cnn.embedding_placeholder: pre_trained_embedding}) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) loss_dict = {} for epoch in range(FLAGS.num_epochs): loss = 0.0 above = 0.0 below = 0.0 below_recall = 0.0 epoch_start_time = time.time() for step in range(num_batches_train): ori_inputs, scores, golds, lens, batch_loss, _, g_step = sess.run( [ train_cnn.ori_inputs, train_cnn.scores, train_cnn.labels, train_cnn.seq_length, train_cnn.loss, apply_gradient_op, global_step ]) loss += batch_loss avg_cur_loss = loss / (step + 1) inputs, preds, golds = recover(ori_inputs, scores, golds, lens) ab, ac, ad = eval(inputs, preds, golds, is_training=True) above += ab below += ac below_recall += ad if g_step % 20 == 0: if ac and ad: accuracy = float(ab) / ac recall = float(ab) / ad if accuracy and recall: F1 = 2.0 / (1.0 / accuracy + 1.0 / recall) print( '%d: [%d/%d], batch_train_loss =%.4f, acc = %.4f, rec = %.4f, F1 = %.4f ' % (epoch, step + 1, num_batches_train, batch_loss, accuracy, recall, F1)) else: print( '%d: [%d/%d], batch_train_loss =%.4f, acc = %.4f, rec = %.4f' % (epoch, step + 1, num_batches_train, batch_loss, accuracy, recall)) else: print( '%d: [%d/%d], batch_train_loss =%.4f, ab = %d, ac = %d, ad = %d ' % (epoch, step + 1, num_batches_train, batch_loss, ab, ac, ad)) if below and below_recall: accuracy = float(above) / below recall = float(above) / below_recall if accuracy and recall: F1 = 2.0 / (1.0 / accuracy + 1.0 / recall) print( 'avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' 'acc = %.4f, rec = %.4f, F1 = %.4f ' % (avg_cur_loss, above, below, below_recall, accuracy, recall, F1)) else: print( 'avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' 'acc = %.4f, rec = %.4f' % (avg_cur_loss, above, below, below_recall, accuracy, recall)) else: print( 'avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' % (avg_cur_loss, above, below, below_recall)) print("at the end of epoch:", epoch) print('Epoch training time:', time.time() - epoch_start_time) loss_dict[epoch] = avg_cur_loss if below and below_recall: accuracy = float(above) / below recall = float(above) / below_recall if accuracy and recall: F1 = 2.0 / (1.0 / accuracy + 1.0 / recall) print( '[%d/%d]: avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' 'acc = %.4f, rec = %.4f, F1 = %.4f ' % (epoch, FLAGS.num_epochs, avg_cur_loss, above, below, below_recall, accuracy, recall, F1)) else: print( '[%d/%d]: avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' 'acc = %.4f, rec = %.4f' % (epoch, FLAGS.num_epochs, avg_cur_loss, above, below, below_recall, accuracy, recall)) else: print( '[%d/%d]: avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' % (epoch, FLAGS.num_epochs, avg_cur_loss, above, below, below_recall)) checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=global_step) writer = codecs.open(FLAGS.loss_file, 'w', encoding='utf-8') sort_acc_dict = OrderedDict( sorted(loss_dict.items(), key=lambda d: d[0])) for k, v in sort_acc_dict.items(): writer.write(str(k) + ' : ' + str(v) + '\n')
def main(_): valid_loader = TextLoader('valid', FLAGS.batch_size, 1, 1, None) batch_queue_data = valid_loader.batch_data writer = codecs.open('output_6', 'w', encoding='utf-8') print("Loading data...") # Training # ================================================== ''' evaluate on dev dataset ''' with tf.variable_scope('SRLModel'): valid_cnn = SRLModel(batch_queue_data[0], batch_queue_data[1], batch_queue_data[2], batch_queue_data[3], labels=batch_queue_data[4], ori_inputs=batch_queue_data[-1], seq_length=batch_queue_data[5], num_classes=36, vocab_size=381057, embedding_size=FLAGS.embedding_dim, mark_embedding_size=FLAGS.mark_embedding_dim, batch_size=FLAGS.batch_size, cell_name=FLAGS.cell, hidden_size=FLAGS.hidden_size, num_layers=FLAGS.num_layers, dropout_keep_proba=1.0, dropout_mode=False, is_training=False) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True) sess = tf.Session(config=session_conf) sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) '''restore trained models''' saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(FLAGS.train_dir) if ckpt: files = os.listdir(FLAGS.train_dir) files = [os.path.join(FLAGS.train_dir, f) for f in files] check_point_files = [] for f in files: if '.index' in f: f = f[0:len(f) - 6] check_point_files.append(f) num_batches_valid = int(1115 / FLAGS.batch_size) best_loss = None best_model = None acc_dict = {} for check_point in check_point_files: saver.restore(sess, check_point) global_step = check_point.split('/')[-1].split('-')[-1] global_step = int(global_step) print("load model from ", check_point) loss = 0.0 above = 0.0 below = 0.0 below_recall = 0.0 for step in range(num_batches_valid): inputs, scores, golds, lens, batch_loss = sess.run([ valid_cnn.ori_inputs, valid_cnn.scores, valid_cnn.labels, valid_cnn.seq_length, valid_cnn.loss ]) loss += batch_loss avg_cur_loss = loss / (step + 1) inputs, preds, golds = recover(inputs, scores, golds, lens) ab, ac, ad = eval(inputs, preds, golds, is_training=False) above += ab below += ac below_recall += ad if (step + 1) % 5 == 0: if below and below_recall: accuracy = float(above) / below recall = float(above) / below_recall if accuracy and recall: F1 = 2.0 / (1.0 / accuracy + 1.0 / recall) print( '[%d/%d], avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' 'acc = %.4f, rec = %.4f, F1 = %.4f ' % (step + 1, num_batches_valid, avg_cur_loss, above, below, below_recall, accuracy, recall, F1)) else: print( '[%d/%d], avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' 'acc = %.4f, rec = %.4f' % (step + 1, num_batches_valid, avg_cur_loss, above, below, below_recall, accuracy, recall)) else: print( '[%d/%d], avg_train_loss =%.4f, above = %.4f, below = %.4f, below_recall = %.4f, ' % (step + 1, num_batches_valid, avg_cur_loss, above, below, below_recall)) accuracy = float(above) / below recall = float(above) / below_recall F1 = 2.0 / (1.0 / accuracy + 1.0 / recall) print('global_step =%d, acc = %.4f, rec = %.4f, F1 = %.4f, ' % (global_step, accuracy, recall, F1)) acc_dict[global_step] = F1 if best_loss is None or best_loss < F1: best_loss = F1 best_model = global_step sort_acc_dict = OrderedDict( sorted(acc_dict.items(), key=lambda d: d[0])) for k, v in sort_acc_dict.items(): writer.write(str(k) + ' : ' + str(v) + '\n') print('best_model from step %d, epoch:%d, F1: %f' % (best_model, best_model, best_loss))