# Training
if parameter["mode"] == "train":
train_data = data_loader(parameter["input_dir"])
train_loader.make_input_data(train_data)
test_data = data_loader(parameter["input_dir"])
test_loader.make_input_data(test_data)
for epoch in range(parameter["epochs"]):
# Training
avg_cost, avg_correct, precision_count, recall_count, e_avg_correct, e_precision_count, e_recall_count = iteration_model(models, train_loader, parameter)
# Individual and ensemble model's accuracy score
for i in range(parameter["num_ensemble"]):
print(str(i) + '_[Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(epoch + 1, avg_cost[i], avg_correct[i]))
print('Ensemble [Epoch: {:>4}] Accuracy = {:>.6}'.format(epoch + 1, e_avg_correct))
f1Measure, precision, recall = calculation_measure(parameter["num_ensemble"], precision_count, recall_count)
# Individual and ensemble model's f1, precision and recall
e_f1Measure, e_precision, e_recall = calculation_measure_ensemble(e_precision_count, e_recall_count)
for i in range(parameter["num_ensemble"]):
print(str(i) + '_[Train] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'.format(f1Measure[i], precision[i], recall[i]))
print('Ensemble [Train] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'.format(e_f1Measure, e_precision, e_recall))
print('='*100)
# Inference validation / test set
avg_cost, avg_correct, precision_count, recall_count, e_avg_correct, e_precision_count, e_recall_count = iteration_model(models, test_loader, parameter, False)
# Individual and ensemble model's accuracy score on validation or test dataset
for i in range(parameter["num_ensemble"]):
print(str(i) + '_Val : [Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(epoch + 1, avg_cost[i], avg_correct[i]))
print('Ensemble [Epoch: {:>4}] Accuracy = {:>.6}'.format(epoch + 1, e_avg_correct))
f1Measure, precision, recall = calculation_measure(parameter["num_ensemble"], precision_count, recall_count)
# dataset.make_input_data(train_extern_data)
dev_dataset.make_input_data(dev_extern_data) # For Dev set
best_dev_f1 = 0
cur_patience = 0
# use_lr_decay = False
for epoch in range(parameter["epochs"]):
random.shuffle(train_extern_data) # 항상 train set shuffle 시켜주자
dataset.make_input_data(train_extern_data)
avg_cost, avg_correct, precision_count, recall_count = iteration_model(
model, dataset, parameter)
print('[Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(
epoch + 1, avg_cost, avg_correct))
f1Measure, precision, recall = calculation_measure(
precision_count, recall_count)
print(
'[Train] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'
.format(f1Measure, precision, recall))
# Check for dev set
de_avg_cost, de_avg_correct, de_precision_count, de_recall_count = iteration_model(
model, dev_dataset, parameter, train=False)
print('[Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(
epoch + 1, de_avg_cost, de_avg_correct))
de_f1Measure, de_precision, de_recall = calculation_measure(
de_precision_count, de_recall_count)
print(
'[Dev] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'.
format(de_f1Measure, de_precision, de_recall))
bind_model(sess)
if parameter["pause"] == 1:
nsml.paused(scope=locals())
# 학습
if parameter["mode"] == "train":
extern_data = data_loader(DATASET_PATH)
dataset.make_input_data(extern_data)
for epoch in range(parameter["epochs"]):
[tr_avg_cost, tr_acc, tr_precision_cnt, tr_recall_cnt, tr_step], \
[te_avg_cost, te_acc, te_precision_cnt, te_recall_cnt, te_step] = iteration_model(model, dataset, parameter)
print('[Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(
epoch + 1, tr_avg_cost, tr_acc))
tr_f1Measure, tr_precision, tr_recall = calculation_measure(
tr_precision_cnt, tr_recall_cnt)
print(
'[Train] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'
.format(tr_f1Measure, tr_precision, tr_recall))
te_f1Measure, te_precision, te_recall = calculation_measure(
te_precision_cnt, te_recall_cnt)
print(
'[Valid] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'
.format(te_f1Measure, te_precision, te_recall))
nsml.report(summary=True,
scope=locals(),
tr__loss=tr_avg_cost,
tr__f1=tr_f1Measure,
te__f1=te_f1Measure,
model.build_model()
# tensorflow session 생성 및 초기화
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# DO NOT CHANGE
bind_model(sess)
if parameter["pause"] == 1:
nsml.paused(scope=locals())
# 학습
if parameter["mode"] == "train":
extern_data = data_loader(DATASET_PATH) # extern_data
dataset.make_input_data(extern_data)
for epoch in range(parameter["epochs"]):
avg_cost, avg_correct, precision_count, recall_count = iteration_model(
model, dataset, parameter)
print('[Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(
epoch + 1, avg_cost, avg_correct))
f1Measure, precision, recall = calculation_measure(
precision_count, recall_count)
print(
'[Train] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'
.format(f1Measure, precision, recall))
nsml.report(summary=True,
scope=locals(),
train__loss=avg_cost,
step=epoch)
nsml.save(epoch)
def NER_test():
tf.reset_default_graph()
config = Config()
parser = argparse.ArgumentParser(description=sys.argv[0] + " description")
parser = config.parse_arg(parser)
print("[NER_test...]")
try:
parameter = vars(parser.parse_args())
except:
parser.print_help()
sys.exit(0)
parameter["mode"] = "test"
# data_loader를 이용해서 전체 데이터셋 가져옴
DATASET_PATH = './data' #test data path
extern_data = []
if parameter["mode"] == "test":
extern_data = test_data_loader(DATASET_PATH)
# 가져온 문장별 데이터셋을 이용해서 각종 정보 및 학습셋 구성
dataset = Dataset(parameter, extern_data)
# dev_dataset = Dataset(parameter, extern_data)
# # Model 불러오기
# # if parameter["use_conv_model"]:
# # model = ConvModel(dataset.parameter)
# # print("[Use Conv with lstm...]")
# # else:
# # model = Model(dataset.parameter)
# # print("[Use original lstm...]")
# # #
# # # model.build_model_test()
dev_size = config.dev_size
#train_extern_data, dev_extern_data = extern_data[:-dev_size], extern_data[-dev_size:]
# dataset.make_input_data(train_extern_data)
#dev_dataset.make_input_data(extern_data) # For Test set
best_dev_f1 = 0
cur_patience = 0
# use_lr_decay = False
with tf.Session() as sess:
saver = tf.train.import_meta_graph('./saved/testmodel.meta')
saver.restore(sess, tf.train.latest_checkpoint('./saved/'))
graph = tf.get_default_graph()
# print all tensors in checkpoint file
#chkp.print_tensors_in_checkpoint_file("./saved/checkpoint.ckpt", tensor_name='', all_tensors=True)
# placeholder
param = {}
param["morph"] = graph.get_tensor_by_name('morph')
param["ne_dict"] = graph.get_tensor_by_name('ne_dict')
param["character"] = graph.get_tensor_by_name('character')
param["dropout_rate"] = graph.get_tensor_by_name('dropout_rate')
param["weight_dropout_keep_prob"] = graph.get_tensor_by_name(
'weight_dropout_keep_prob')
param["lstm_dropout"] = graph.get_tensor_by_name('lstm_dropout')
param["label"] = graph.get_tensor_by_name('label')
param["sequence"] = graph.get_tensor_by_name('sequence')
param["character_len"] = graph.get_tensor_by_name('character_len')
param["global_step"] = graph.get_tensor_by_name('global_step')
param["emb_dropout_keep_prob"] = graph.get_tensor_by_name(
'emb_dropout_keep_prob')
param["dense_dropout_keep_prob"] = graph.get_tensor_by_name(
'dense_dropout_keep_prob')
param["learning_rate"] = graph.get_tensor_by_name('learning_rate')
#tensor model.cost, model.viterbi_sequence, model.train_op
param["cost"] = graph.get_tensor_by_name('cost')
param["viterbi_sequence"] = graph.get_tensor_by_name(
'viterbi_sequence')
param["train_op"] = graph.get_tensor_by_name('train_op')
#for epoch in range(parameter["epochs"]):
#random.shuffle(extern_data) # 항상 train set shuffle 시켜주자
dataset.make_input_data(extern_data)
# Check for test set
de_avg_cost, de_avg_correct, de_precision_count, de_recall_count = iteration_model_Test(
dataset, parameter, param, train=False)
print('[Epoch: {:>4}] cost = {:>.6} Accuracy = {:>.6}'.format(
epoch + 1, de_avg_cost, de_avg_correct))
de_f1Measure, de_precision, de_recall = calculation_measure(
de_precision_count, de_recall_count)
print('[Test] F1Measure : {:.6f} Precision : {:.6f} Recall : {:.6f}'.
format(de_f1Measure, de_precision, de_recall))
