def Dev(epoch_num):
pathname = "./model/ATT_GRU_model-"
print('reading validation data')
if Flags.data_mode_setting != 'LAS_Coarse':
dev_data = pkl.load(open('./tmp_data/fine_dev.pkl', 'rb'))
else:
dev_data = pkl.load(open('./tmp_data/coarse_dev.pkl', 'rb'))
print('validation discourse numbers: ', len(dev_data))
with tf.Graph().as_default():
# config GPU mode of TensorFlow
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
with sess.as_default():
initializer = tf.truncated_normal_initializer(
mean=0.0, stddev=Flags.stddev_setting)
print('build model begin')
with tf.variable_scope("model",
reuse=None,
initializer=initializer):
if Flags.neural_model_setting == 'Basic_model':
m = Basic_model(is_training=False, word_embedding=None)
elif Flags.neural_model_setting == 'Basic_model_ex':
m = Basic_model_ex(is_training=False, word_embedding=None)
else:
m = Refine_mem_model(is_training=False,
word_embedding=None)
print('build model over')
global_step = tf.Variable(0, name="global_step", trainable=False)
# set learning rate
# restore model
names_to_vars = {v.op.name: v for v in tf.global_variables()}
saver = tf.train.Saver(names_to_vars)
saver.restore(sess, pathname + str(epoch_num))
# sess.run(tf.global_variables_initializer())
arc_eager_parser = Parser.Arc_Eager_Parser()
all_arcs, uas_correct, las_correct = 0.0, 0.0, 0.0
time_str = datetime.datetime.now().isoformat()
print(str(time_str) + ':dev epoch ' + str(epoch_num))
temp_order = list(range(len(dev_data)))
discourse_count = 0
for discourse_index in temp_order:
dev_discourse = dev_data[discourse_index]
print('dev: deal with discourse ' + str(discourse_count))
discourse_count += 1
arcs = set(arc_eager_parser.test(dev_discourse, sess, m))
# write the dev predict into the result file
Write_devOut(dev_discourse, arcs, epoch_num)
# calculate uas and las info
gold_arcs = set([(dev_discourse[i][2], i, dev_discourse[i][3])
for i in range(len(dev_discourse))])
gold_arcs = sorted(gold_arcs, key=lambda x: x[1])
temp_arcs = sorted(arcs, key=lambda x: x[1])
for iter_i in range(len(gold_arcs)):
if (temp_arcs[iter_i][0] == gold_arcs[iter_i][0]):
uas_correct += 1
if (temp_arcs[iter_i][0] == gold_arcs[iter_i][0]
and temp_arcs[iter_i][2] == gold_arcs[iter_i][2]):
las_correct += 1
all_arcs += len(gold_arcs)
print(
'uas accuracy %d/%d = %f' %
(uas_correct, all_arcs, float(uas_correct) / float(all_arcs)))
print(
'las accuracy %d/%d = %f' %
(las_correct, all_arcs, float(las_correct) / float(all_arcs)))
# Print_result_dev()
outfile = open("right_ratio.txt", 'a+')
outfile.write("dev: in the iteration " + str(epoch_num) +
" the dev uas right ratio is: " +
str(float(uas_correct) / float(all_arcs)) +
' correct_arcs:' + str(uas_correct) + ' all_arcs:' +
str(all_arcs) + '\n')
outfile.write("dev: in the iteration " + str(epoch_num) +
" the dev las right ratio is: " +
str(float(las_correct) / float(all_arcs)) +
' correct_las:' + str(las_correct) + ' all_arcs:' +
str(all_arcs) + '\n')
outfile.close()
return float(uas_correct) / float(all_arcs)
def Train():
print('reading word embedding from ./data/vec.npy')
word_embedding = np.load('./tmp_data/vec.npy')
print('reading training data')
if Flags.data_mode_setting != 'LAS_Coarse':
train_data = pkl.load(open('./tmp_data/fine_train.pkl', 'rb'))
else:
train_data = pkl.load(open('./tmp_data/coarse_train.pkl', 'rb'))
print('train discourse numbers: ', len(train_data))
with tf.Graph().as_default():
# config GPU mode of TensorFlow
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
with sess.as_default():
initializer = tf.truncated_normal_initializer(
mean=0.0, stddev=Flags.stddev_setting)
print('build model begin')
with tf.variable_scope("model",
reuse=None,
initializer=initializer):
if Flags.neural_model_setting == 'Basic_model':
m = Basic_model(is_training=True,
word_embedding=word_embedding)
elif Flags.neural_model_setting == 'Basic_model_ex':
m = Basic_model_ex(is_training=True,
word_embedding=word_embedding)
else:
m = Refine_mem_model(is_training=True,
word_embedding=word_embedding)
print('build model over')
global_step = tf.Variable(0, name="global_step", trainable=False)
# set learning rate
learning_rate = Flags.learning_rate
# TODO try other Optimizer
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(m.en_loss, global_step=global_step)
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(max_to_keep=10)
arc_eager_parser = Parser.Arc_Eager_Parser()
for one_epoch in range(Flags.epoch_nums):
correct_num, all_num = 0.0, 0.0
time_str = datetime.datetime.now().isoformat()
print(str(time_str) + ': epoch ' + str(one_epoch) + ' starts')
temp_order = list(range(len(train_data)))
random.shuffle(temp_order)
discourse_count = 0
for discourse_index in temp_order:
train_discourse = train_data[discourse_index]
print('deal with discourse ' + str(discourse_count))
discourse_count += 1
correct, all = arc_eager_parser.train(
train_discourse, sess, m, train_op)
correct_num += correct
all_num += all
print('acc', correct_num / all_num)
print('##################saving model#######################')
path = saver.save(
sess,
Flags.model_save_path + 'ATT_GRU_model-' + str(one_epoch))
time_str = datetime.datetime.now().isoformat()
tempstr = "{}: have saved model to ".format(time_str) + path
print(tempstr)
Dev(one_epoch)
Test(one_epoch)
