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))