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)