def predict(input):
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_voc()
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
print(input)
predic_input_enc = data.enc_processing([input], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_input_dec = data.dec_input_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'embedding_size': DEFINES.embedding_size,
'hidden_size': DEFINES.hidden_size, # 가중치 크기 설정한다.
'ffn_hidden_size': DEFINES.ffn_hidden_size,
'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'embedding':DEFINES.embedding,
'max_sequence_length': DEFINES.max_sequence_length,
'xavier_initializer': DEFINES.xavier_initializer,
'multilayer': DEFINES.multilayer,
})
#TODO
for i in range(DEFINES.max_sequence_length):
if i > 0:
predic_input_dec = data.dec_input_processing([answer], char2idx)
predic_target_dec = data.dec_target_processing([answer], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_input_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
if finished:
break
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
return answer
def predict(input_data):
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_voc()
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
input = input_data
predic_input_enc, predic_input_enc_length = data.enc_processing([input], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec, _ = data.dec_target_processing([""], char2idx)
if DEFINES.serving == True:
# 모델이 저장된 위치를 넣어 준다. export_dir
predictor_fn = tf.contrib.predictor.from_saved_model(
export_dir="/home/evo_mind/DeepLearning/NLP/Work/ChatBot2_Final/data_out/model/1541575161"
)
else:
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'hidden_size': DEFINES.hidden_size, # 가중치 크기 설정한다.
'layer_size': DEFINES.layer_size, # 멀티 레이어 층 개수를 설정한다.
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'teacher_forcing_rate': DEFINES.teacher_forcing_rate, # 학습시 디코더 인풋 정답 지원율 설정
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'embedding': DEFINES.embedding, # 임베딩 사용 유무를 설정한다.
'multilayer': DEFINES.multilayer, # 멀티 레이어 사용 유무를 설정한다.
'attention': DEFINES.attention, # 어텐션 지원 유무를 설정한다.
'teacher_forcing': DEFINES.teacher_forcing, # 학습시 디코더 인풋 정답 지원 유무 설정한다.
'loss_mask': DEFINES.loss_mask, # PAD에 대한 마스크를 통한 loss를 제한 한다.
'serving': DEFINES.serving # 모델 저장 및 serving 유무를 설정한다.
})
if DEFINES.serving == True:
predictions = predictor_fn({'input': predic_input_enc, 'output': predic_target_dec})
# data.pred2string(predictions, idx2char)
else:
# 예측을 하는 부분이다.
predictions = classifier.predict(
input_fn=lambda: data.eval_input_fn(predic_input_enc, predic_target_dec, DEFINES.batch_size))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
# data.pred2string(predictions, idx2char)
return data.pred_next_string(predictions, idx2char)
def predict(question):
tf.logging.set_verbosity(tf.logging.ERROR)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_voc()
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
input = question
predic_input_enc = data.enc_processing([input], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_output_dec = data.dec_input_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'hidden_size': DEFINES.hidden_size, # 가중치 크기 설정한다.
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'max_sequence_length': DEFINES.max_sequence_length
})
# 예측을 하는 부분이다.
answer = ""
for i in range(DEFINES.max_sequence_length):
# print(answer)
if i > 0:
predic_output_dec = data.dec_input_processing([answer], char2idx)
predic_target_dec = data.dec_target_processing([answer], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_output_dec, predic_target_dec, 1))
temp = data.pred_next_string(predictions, idx2char)
if temp != answer:
answer = temp
else:
break
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
return answer
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_vocabulary()
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'embedding_size': DEFINES.embedding_size,
'model_hidden_size': DEFINES.model_hidden_size, # 가중치 크기 설정한다.
'ffn_hidden_size': DEFINES.ffn_hidden_size,
'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'xavier_initializer': DEFINES.xavier_initializer
})
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
predic_input_enc, predic_input_enc_length = data.enc_processing([a],
char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_output_dec, predic_output_decLength = data.dec_output_processing(
[""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
def predict(channel, text):
tf.logging.set_verbosity(tf.logging.ERROR)
char2idx, idx2char, vocabulary_length = data.load_voc()
predic_input_enc = data.enc_processing([text], char2idx)
predic_input_dec = data.dec_input_processing([""], char2idx)
predic_target_dec = data.dec_target_processing([""], char2idx)
classifier = tf.estimator.Estimator(model_fn=ml.Model,
model_dir=DEFINES.check_point_path,
params={
'hidden_size': DEFINES.hidden_size,
'layer_size': DEFINES.layer_size,
'learning_rate':
DEFINES.learning_rate,
'vocabulary_length':
vocabulary_length,
'embedding_size':
DEFINES.embedding_size,
'embedding': DEFINES.embedding,
'multilayer': DEFINES.multilayer,
})
for i in range(DEFINES.max_sequence_length):
if i > 0:
predic_input_dec = data.dec_input_processing([answer], char2idx)
predic_target_dec = data.dec_target_processing([answer], char2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_input_dec, predic_target_dec, 1))
answer = data.pred_next_string(predictions, idx2char)
slack_web_client.chat_postMessage(channel=channel, text=answer)
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 훈련 데이터와 테스트 데이터를 가져온다.
train_q, train_a, test_q, test_a = data.load_data()
# 데이터 토큰화
token_train_q = data.tokenizing_data(train_q)
token_train_a = data.tokenizing_data(train_a)
token_test_q = data.tokenizing_data(test_q)
token_test_a = data.tokenizing_data(test_a)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_voc(
token_train_q, token_train_a)
# 훈련셋 인코딩 만드는 부분
train_input_enc = data.enc_processing(token_train_q, char2idx)
# 훈련셋 디코딩 입력 부분
train_input_dec = data.dec_input_processing(token_train_a, char2idx)
# 훈련셋 디코딩 출력 부분
train_target_dec = data.dec_target_processing(token_train_a, char2idx)
# 평가셋 인코딩 만드는 부분
eval_input_enc = data.enc_processing(token_test_q, char2idx)
# 평가셋 인코딩 만드는 부분
eval_input_dec = data.dec_input_processing(token_test_a, char2idx)
# 평가셋 인코딩 만드는 부분
eval_target_dec = data.dec_target_processing(token_test_a, char2idx)
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정한다.
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_path, exist_ok=True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.model, # 모델 등록한다.
model_dir=DEFINES.check_point_path,
params={
'hidden_size': DEFINES.hidden_size,
'layer_size': DEFINES.layer_size,
'learning_rate': DEFINES.learning_rate,
'vocabulary_length': vocabulary_length,
'embedding_size': DEFINES.embedding_size,
'embedding': DEFINES.embedding,
'multilayer': DEFINES.multilayer,
})
# 학습 실행
classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_input_dec, train_target_dec, DEFINES.batch_size
),
steps=DEFINES.train_steps)
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_input_dec, eval_target_dec, DEFINES.batch_size))
print('\nEVAL set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다. 테스트용으로 ["가끔 궁금해"] 값을 넣어 형성된 대답과 비교를 한다.
predic_input_enc = data.enc_processing(data.tokenizing_data(["가끔 궁금해"]),
char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_input_dec = data.dec_input_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_input_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
print("Bleu score: ", bleu_compute("그 사람도 그럴 거예요.", answer))
print("Rouge score: ", rouge_compute("그 사람도 그럴 거예요.", answer))
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_vocabulary()
# 훈련 데이터와 테스트 데이터를 가져온다.
train_input, train_label, eval_input, eval_label = data.load_data()
# 훈련셋 인코딩 만드는 부분이다.
train_input_enc, train_input_enc_length = data.enc_processing(
train_input, char2idx)
# 훈련셋 디코딩 입력 부분 만드는 부분이다.
train_output_dec, train_output_dec_length = data.dec_output_processing(
train_label, char2idx)
# 훈련셋 디코딩 출력 부분 만드는 부분이다.
train_target_dec = data.dec_target_processing(train_label, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_input_enc, eval_input_enc_length = data.enc_processing(
eval_input, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_output_dec, eval_output_dec_length = data.dec_output_processing(
eval_label, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_target_dec = data.dec_target_processing(eval_label, char2idx)
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정한다.
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_path, exist_ok=True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'model_hidden_size': DEFINES.model_hidden_size, # 가중치 크기 설정한다.
'ffn_hidden_size': DEFINES.ffn_hidden_size,
'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'xavier_initializer': DEFINES.xavier_initializer
})
# 학습 실행
classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_output_dec, train_target_dec, DEFINES.batch_size
),
steps=DEFINES.train_steps)
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_output_dec, eval_target_dec, DEFINES.batch_size))
print('\nEVAL set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
predic_input_enc, predic_input_enc_length = data.enc_processing(["가끔 궁금해"],
char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_output_dec, predic_output_decLength = data.dec_output_processing(
[""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_voc()
# 훈련 데이터와 테스트 데이터를 가져온다.
train_q, train_a, test_q, test_a = data.load_data()
# 훈련셋 인코딩 만드는 부분
train_input_enc, train_input_enc_length = data.enc_processing(
train_q, char2idx)
# 훈련셋 디코딩 입력 부분
train_input_dec, train_input_dec_length = data.dec_input_processing(
train_a, char2idx)
# 훈련셋 디코딩 출력 부분
train_target_dec, train_target_dec_length = data.dec_target_processing(
train_a, char2idx)
# 평가셋 인코딩 만드는 부분
eval_input_enc, eval_input_enc_length = data.enc_processing(
test_q, char2idx)
# 평가셋 인코딩 만드는 부분
eval_input_dec, eval_input_dec_length = data.dec_input_processing(
test_a, char2idx)
# 평가셋 인코딩 만드는 부분
eval_target_dec, eval_target_dec_length = data.dec_target_processing(
test_a, char2idx)
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정한다.
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
save_model_path = os.path.join(os.getcwd(), DEFINES.save_model_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_path, exist_ok=True)
os.makedirs(save_model_path, exist_ok=True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'hidden_size': DEFINES.hidden_size, # 가중치 크기 설정한다.
'layer_size': DEFINES.layer_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'teacher_forcing_rate': DEFINES.teacher_forcing_rate,
'embedding': DEFINES.embedding,
'multilayer': DEFINES.multilayer,
'attention': DEFINES.attention,
'teacher_forcing': DEFINES.teacher_forcing,
'loss_mask': DEFINES.loss_mask,
'serving': DEFINES.serving
})
# 학습 실행
classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_target_dec_length, train_target_dec, DEFINES.
batch_size),
steps=DEFINES.train_steps)
if DEFINES.serving == True:
save_model_path = classifier.export_savedmodel(
export_dir_base=DEFINES.save_model_path,
serving_input_receiver_fn=serving_input_receiver_fn)
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_target_dec, DEFINES.batch_size))
print('\nEVAL set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다. 테스트용으로 ["가끔 궁금해"] 값을 넣어 형성된 대답과 비교를 한다.
input = "가끔 궁금해"
for i in sys.argv[1:]:
input += i
input += " "
predic_input_enc, predic_input_enc_length = data.enc_processing([input],
char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_input_dec, _ = data.dec_input_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec, _ = data.dec_target_processing([""], char2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_target_dec, DEFINES.batch_size))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
answer = data.pred_next_string(predictions, idx2char)
print(answer)
print("Bleu score: ", bleu_compute("그 사람도 그럴 거예요", answer))
print("Rouge score: ", rouge_compute("그 사람도 그럴 거예요", answer))
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 사전 데이터 불러오기 (인덱싱된 단어, 단어 자체, 단어 길이)
char2idx, idx2char, vocabulary_length = data.load_vocabulary()
# 훈련, 테스트용으로 input과 label을 가져온다
train_input, train_label, eval_input, eval_label = data.load_data()
# 훈련 인코딩 입력
train_input_enc, train_input_enc_length = data.enc_processing(
train_input, char2idx)
# 훈련 디코딩 입력
train_output_dec, train_output_dec_length = data.dec_output_processing(
train_label, char2idx)
# 훈련 디코딩 출력
train_target_dec = data.dec_target_processing(train_label, char2idx)
# 평가 인코딩 입력
eval_input_enc, eval_input_enc_length = data.enc_processing(
eval_input, char2idx)
# 평가 디코딩 입력
eval_output_dec, eval_output_dec_length = data.dec_output_processing(
eval_label, char2idx)
# 평가 디코딩 출력
eval_target_dec = data.dec_target_processing(eval_label, char2idx)
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
# save_model_path = os.path.join(os.getcwd(), DEFINES.save_model_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_path, exist_ok=True)
# os.makedirs(save_model_path, exist_ok = True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'embedding_size': DEFINES.embedding_size,
'model_hidden_size': DEFINES.model_hidden_size, # 가중치 크기 설정한다.
'ffn_hidden_size': DEFINES.ffn_hidden_size,
'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'xavier_initializer': DEFINES.xavier_initializer
})
# 학습 실행
classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_output_dec, train_target_dec, DEFINES.batch_size
),
steps=DEFINES.train_steps)
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_output_dec, eval_target_dec, DEFINES.batch_size))
print('\nEVAL set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
predic_input_enc, predic_input_enc_length = data.enc_processing([
"Many people have pointed out that personal responsibility can often be lost in groups. Consider how often you’ve passed someone who is pulled over on the side of the road with car trouble. It is easy to justify your failure to help by telling yourself someone else will stop. Corporations add another layer of complication to the story of reduced personalresponsibility in group settings because corporations are set up to assign legal responsibility to the corporation itself instead of to its members. There are other complex organizations in which the individual members are often not sure of their impact or power to bring about change. In this kind of culture,“someone else will do it” is a common excuse."
], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_output_dec, predic_output_decLength = data.dec_output_processing(
[""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
for i in range(DEFINES.max_sequence_length):
if i > 0:
predic_output_dec, predic_output_decLength = data.dec_output_processing(
[answer], char2idx)
predic_target_dec = data.dec_target_processing([answer], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
if finished:
break
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'xavier_initializer': DEFINES.xavier_initializer
})
# for i in range(DEFINES.max_sequence_length):
# if i > 0:
# predic_output_dec, predic_output_decLength = data.dec_output_processing([answer], char2idx)
# predic_target_dec = data.dec_target_processing([answer], char2idx)
# # 예측을 하는 부분이다.
# predictions = classifier.predict(
# input_fn=lambda: data.eval_input_fn(predic_input_enc, predic_output_dec, predic_target_dec, 1))
#
# answer, finished = data.pred_next_string(predictions, idx2char)
# print(answer)
# if finished:
# break
# predic_output_dec, predic_output_dec_length = data.dec_output_processing([""], char2idx)
# predic_target_dec = data.dec_target_processing([""], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_output_dec, predic_output_dec_length = data.dec_output_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'hidden_size': DEFINES.hidden_size, # 가중치 크기 설정한다.
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'max_sequence_length': DEFINES.max_sequence_length,
})
for i in range(DEFINES.max_sequence_length):
if i > 0:
predic_output_dec, predic_output_decLength = data.dec_output_processing([answer], char2idx)
predic_target_dec = data.dec_target_processing([answer], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer = data.pred_next_string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
char2idx, idx2char, vocabulary_length = data.load_voc()
train_q, train_a, test_q, test_a = data.load_data()
train_input_enc, _ = data.enc_processing(train_q, char2idx)
train_output_dec, _ = data.dec_output_processing(train_a, char2idx)
train_target_dec = data.dec_target_processing(train_a, char2idx)
eval_input_enc, _ = data.enc_processing(test_q, char2idx)
eval_output_dec, _ = data.dec_output_processing(test_a, char2idx)
eval_target_dec = data.dec_target_processing(test_a, char2idx)
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
save_model_path = os.path.join(os.getcwd(), DEFINES.save_model_path)
os.makedirs(check_point_path, exist_ok=True)
os.makedirs(save_model_path, exist_ok=True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'model_hidden_size': DEFINES.model_hidden_size, # 가중치 크기 설정한다.
'ffn_hidden_size': DEFINES.ffn_hidden_size,
'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'tokenize_as_morph': DEFINES.tokenize_as_morph,
'serving': DEFINES.serving # 모델 저장 및 serving 유무를 설정한다.
})
# 학습 실행
classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_output_dec, train_target_dec, DEFINES.batch_size
),
steps=DEFINES.train_steps)
# 모델 저장
if DEFINES.serving == True:
classifier.export_saved_model(
export_dir_base=DEFINES.save_model_path,
serving_input_receiver_fn=serving_input_receiver_fn)
# 평가 실행
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_output_dec, eval_target_dec, DEFINES.batch_size))
print('\nEVAL set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# 테스트
predic_input_enc, _ = data.enc_processing(["가끔 궁금해"], char2idx)
predic_output_dec, _ = data.dec_output_processing([""], char2idx)
predic_target_dec = data.dec_target_processing([""], char2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer, _ = data.pred_next_string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
print("Bleu score: ", bleu_compute("그 사람도 그럴 거예요.", answer))
print("Rouge score: ", rouge_compute("그 사람도 그럴 거예요.", answer))
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_vocabulary()
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정한다.
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_path, exist_ok=True)
# ----------------------------------
tf.keras.backend.clear_session()
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
# ---------------------------------
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'embedding_size': DEFINES.embedding_size,
'model_hidden_size': DEFINES.model_hidden_size, # 가중치 크기 설정한다.
'ffn_hidden_size': DEFINES.ffn_hidden_size,
'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'xavier_initializer': DEFINES.xavier_initializer
})
if args.train:
# 훈련 데이터와 테스트 데이터를 가져온다.
train_input, train_label, eval_input, eval_label = data.load_data()
# 훈련셋 인코딩 만드는 부분이다.
train_input_enc, train_input_enc_length = data.enc_processing(train_input, char2idx)
# 훈련셋 디코딩 입력 부분 만드는 부분이다.
train_output_dec, train_output_dec_length = data.dec_output_processing(train_label, char2idx)
# 훈련셋 디코딩 출력 부분 만드는 부분이다.
train_target_dec = data.dec_target_processing(train_label, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_input_enc, eval_input_enc_length = data.enc_processing(eval_input, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_output_dec, eval_output_dec_length = data.dec_output_processing(eval_label, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_target_dec = data.dec_target_processing(eval_label, char2idx)
# 학습 실행
classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_output_dec, train_target_dec, args.batch_size), steps=args.train_steps)
# test 부분
if args.test:
q_sent = input('Review sentence > ').strip()
predic_input_enc, predic_input_enc_length = data.enc_processing([q_sent], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_output_dec, predic_output_decLength = data.dec_output_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
for i in range(DEFINES.max_sequence_length):
if i > 0:
predic_output_dec, predic_output_decLength = data.dec_output_processing([answer], char2idx)
predic_target_dec = data.dec_target_processing([answer], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(
input_fn=lambda: data.eval_input_fn(predic_input_enc, predic_output_dec, predic_target_dec, 1))
answer, finished = data.pred_next_string(predictions, idx2char)
if finished:
break
print("summary: ", answer)
'''
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_voc()
# 훈련 데이터와 테스트 데이터를 가져온다.
train_q, train_a, test_q, test_a = data.load_data()
# print('train_q', train_q)
# print('train_a', train_a)
# print('test_q', test_q)
# print('test_a', test_a)
# 훈련셋 인코딩 만드는 부분
train_input_enc = data.enc_processing(train_q, char2idx)
# print('train_input_enc', train_input_enc)
# 훈련셋 디코딩 입력 부분
train_input_dec = data.dec_input_processing(train_a, char2idx)
# print('train_input_dec', train_input_dec)
# 훈련셋 디코딩 출력 부분
train_target_dec = data.dec_target_processing(train_a, char2idx)
print('train_target_dec', train_target_dec)
# 평가셋 인코딩 만드는 부분
eval_input_enc = data.enc_processing(test_q, char2idx)
# 평가셋 인코딩 만드는 부분
eval_input_dec = data.dec_input_processing(test_a, char2idx)
# 평가셋 인코딩 만드는 부분
eval_target_dec = data.dec_target_processing(test_a, char2idx)
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정한다.
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_path, exist_ok=True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.model, # 모델 등록한다.
model_dir=DEFINES.check_point_path, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'embedding': DEFINES.embedding,
'hidden_size': DEFINES.hidden_size, # 가중치 크기 설정한다.
# 'ffn_hidden_size': DEFINES.ffn_hidden_size,
# 'attention_head_size': DEFINES.attention_head_size,
'learning_rate': DEFINES.learning_rate, # 학습율 설정한다.
'vocabulary_length': vocabulary_length, # 딕셔너리 크기를 설정한다.
'embedding_size': DEFINES.embedding_size, # 임베딩 크기를 설정한다.
'layer_size': DEFINES.layer_size,
'max_sequence_length': DEFINES.max_sequence_length,
'multilayer': DEFINES.multilayer, # 멀티 레이어 사용 유무를 설정한다.
# 'xavier_initializer': DEFINES.xavier_initializer
})
# 학습 실행
a = classifier.train(input_fn=lambda: data.train_input_fn(
train_input_enc, train_input_dec, train_target_dec, DEFINES.batch_size
),
steps=DEFINES.train_steps)
print('a', a)
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_input_dec, eval_target_dec, DEFINES.batch_size))
print('\nEVAL set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# 모델 저장
# with open("model.clf", "wb") as f:
# pickle.dump(classifier, f)
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다. 테스트용으로 ["가끔 궁금해"] 값을 넣어 형성된 대답과 비교를 한다.
predic_input_enc = data.enc_processing(["안녕"], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_input_dec = data.dec_input_processing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
predic_target_dec = data.dec_target_processing([""], char2idx)
print('predic_input_enc', predic_input_enc)
print('predic_input_dec', predic_input_dec)
print('predic_target_dec', predic_target_dec)
with open("model.clf", "rb") as f:
classifier = pickle.load(f)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_input_dec, predic_target_dec, 1))
# print('predictions', predictions)
answer, finished = data.pred_next_string(predictions, idx2char)
# print('answer, finished', answer, finished)k
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
