def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
word2idx, idx2word, 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, word2idx)
train_input_dec, train_input_dec_length = data.dec_input_processing(train_label, word2idx)
train_target_dec = data.dec_target_processing(train_label, word2idx)
# 평가셋 인코딩 / 디코딩 입력 / 디코딩 출력 만드는 부분이다.
eval_input_enc, eval_input_enc_length = data.enc_processing(eval_input,word2idx)
eval_input_dec, eval_input_dec_length = data.dec_input_processing(eval_label, word2idx)
eval_target_dec = data.dec_target_processing(eval_label, word2idx)
# 현재 경로'./'에 현재 경로 하부에 체크 포인트를 저장한 디렉토리를 설정한다.
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
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, predic_input_enc_length = data.enc_processing(["가끔 궁금해"], word2idx)
predic_input_dec, predic_input_dec_length = data.dec_input_processing([""], word2idx)
predic_target_dec = data.dec_target_processing([""], word2idx)
# 예측 실행
predictions = classifier.predict(
input_fn=lambda:data.eval_input_fn(predic_input_enc, predic_input_dec, predic_target_dec, DEFINES.batch_size))
# 예측한 값을 텍스트로 변경하는 부분이다.
data.pred2string(predictions, idx2word)
def main(self):
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
word2idx, idxword, 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, word2idx)
train_input_dec, train_input_dec_length = data.dec_input_processing(
train_label, word2idx)
train_target_dec = data.dec_target_processing(train_label, word2idx)
eval_input_enc, eval_input_enc_length = data.enc_processing(
eval_input, word2idx)
eval_input_dec, eval_input_dec_length = data.dec_input_processing(
eval_label, word2idx)
eval_target_dec = data.dec_target_processing(eval_label, word2idx)
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
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, predic_input_enc_length = data.enc_processing(["가끔 궁금해"],
word2idx)
predic_input_dec, predic_input_decLength = data.dec_input_processing(
[""], word2idx)
predic_target_dec = data.dec_target_processing([""], word2idx)
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_input_dec, predic_target_dec, DEFINES.
batch_size))
data.pred2string(predictions, idx2word)
def predict(text):
word2idx, idx2word, vocab_len = data.load_vocabulary()
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,
'vocab_len': vocab_len,
'embedding_size':
DEFINES.embedding_size,
'embedding': DEFINES.embedding,
'multilayer': DEFINES.multilayer,
})
# 테스트셋 인코딩 / 디코딩 입력 / 디코딩 출력
predic_input_enc, predic_input_enc_length = data.enc_processing([text],
word2idx)
predic_input_dec, predic_input_dec_length = data.dec_input_processing(
[""], word2idx)
predic_target_dec = data.dec_target_processing([""], word2idx)
# 예측 실행
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_input_dec, predic_target_dec, DEFINES.
batch_size))
# 예측한 값을 텍스트로 변경하는 부분이다.
data.pred2string(predictions, idx2word)
def eval():
char2idx, idx2char, vocabulary_length = data.load_voc()
train_input, train_label, eval_input, eval_label = data.load_data()
# 평가셋 인코딩 만드는 부분이다.
eval_input_enc, eval_input_enc_length = data.enc_processing(eval_input, char2idx)
# 평가셋 디코딩 출력 부분 만드는 부분이다.
eval_target_dec, _ = data.dec_target_processing(eval_label, 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, # 학습율 설정한다.
'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 유무를 설정한다.
})
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_target_dec, DEFINES.batch_size))
print('\ntest set 정확도: {accuracy:0.3f}\n'.format(**eval_result))
def main(argv):
args = parser.parse_args(argv[1:])
# Fetch the data
(train_x, train_y), (test_x, test_y) = data.load_data()
# Feature columns describe how to use the input.
my_feature_columns = []
for key in train_x.keys():
my_feature_columns.append(tf.feature_column.numeric_column(key=key))
# Build 2 hidden layer DNN with 10, 10 units respectively.
classifier = tf.estimator.DNNClassifier(
feature_columns=my_feature_columns,
# Two hidden layers of 10 nodes each.
hidden_units=[10, 15, 15, 10],
# The model must choose between 9 classes.
n_classes=9,
optimizer=tf.train.AdamOptimizer())
# Train the Model.
classifier.train(input_fn=lambda: data.train_input_fn(
train_x, train_y, args.batch_size),
steps=args.train_steps)
# Evaluate the model.
eval_result = classifier.evaluate(
input_fn=lambda: data.eval_input_fn(test_x, test_y, args.batch_size))
print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
def main(argv):
args = parser.parse_args(argv[1:])
# Fetch the data
(train_x,
train_y), (test_x,
test_y), test_real = data.load_data(skip_test=args.skip_test)
# Feature columns describe how to use the input.
my_feature_columns = []
for key in train_x.keys():
my_feature_columns.append(tf.feature_column.numeric_column(key=key))
# Build 2 hidden layer DNN with 10, 10 units respectively.
classifier = tf.estimator.DNNClassifier(
feature_columns=my_feature_columns,
# Two hidden layers of 10 nodes each.
hidden_units=[10, 10, 10],
# The model must choose between 2 classes.
n_classes=2)
# Train the Model.
classifier.train(input_fn=lambda: data.train_input_fn(
train_x, train_y, args.batch_size),
steps=args.train_steps)
if not args.skip_test:
# Evaluate the model.
eval_result = classifier.evaluate(input_fn=lambda: data.eval_input_fn(
test_x, test_y, args.batch_size))
print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
# Generate predictions from the model
template = '\nPrediction is "{}" ({:.1f}%), id "{}"'
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
test_real, labels=None, batch_size=args.batch_size))
with open('submission.csv', 'w', newline='') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerow(['PassengerId', 'Survived'])
for pred_dict, realindex in zip(predictions, test_real.index):
class_id = pred_dict['class_ids'][0]
probability = pred_dict['probabilities'][class_id]
csvwriter.writerow([realindex, class_id])
print(
template.format(SURVIVED[class_id], 100 * probability,
realindex))
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(argv):
(train_x, train_y), (test_x, test_y) = data.load_data()
#feature_column = tf.feature_column.categorical_column_with_hash_bucket("url", 100)
feature_column = tf.feature_column.categorical_column_with_vocabulary_list(
"url", ["url"])
# feature_column = []
# for key in train_x.keys():
# feature_column.append(tf.feature_column.numeric_column(key=key))
classifier = tf.estimator.DNNClassifier(feature_columns=feature_column,
hidden_units=[10, 10],
n_classes=2)
classifier.train(
input_fn=lambda: data.train_input_fn(train_x, train_y, 100),
steps=1000)
eval_result = classifier.evaluate(
input_fn=lambda: data.eval_input_fn(test_x, test_y, 100))
print('\n打印结果: {eval_result:0.3f}\n'.format(**eval_result))
def train(self):
data_out_path = os.path.join(BASE_DIR, DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok=True)
# 데이터를 통한 사전 구성
word2idx, idx2word, vocab_len = data.load_vocabulary()
train_input, train_label, eval_input, eval_label = data.load_data()
# 훈련셋 인코딩 / 디코딩 입력 / 디코딩 출력
train_input_enc, train_input_enc_len = data.enc_processing(
train_input, word2idx)
train_input_dec, train_input_dec_len = data.dec_input_processing(
train_label, word2idx)
train_target_dec = data.dec_target_processing(train_label, word2idx)
# 평가셋 인코딩 / 디코딩 입력 / 디코딩 출력
eval_input_enc, eval_input_enc_len = data.enc_processing(
eval_input, word2idx)
eval_input_dec, eval_input_dec_len = data.dec_input_processing(
eval_label, word2idx)
eval_target_dec = data.dec_target_processing(eval_label, word2idx)
os.makedirs(DEFINES.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,
'vocab_len': vocab_len,
'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))
def main(argv):
global HIDDEN_UNITS, N_CLASSES, BATCH_SIZE, TRAIN_STEPS
# Fetch the data, train_x train_y test_x test_y are pandas frame
(train_x, train_y), (test_x, test_y) = data.load_data()
# Feature columns describe how to use the input.
my_feature_columns = []
for key in train_x.keys(
): # DataFrame.keys() get the column header, it's feature name
my_feature_columns.append(tf.feature_column.numeric_column(key=key))
# Build N_HIDDEN hidden layer DNN with HIDDENT_UNITS respectively.
classifier = tf.estimator.Estimator(
model_fn=my_model,
params={
'feature_columns': my_feature_columns,
# global constant HIDDEN_UNITS specify the node in network
'hidden_units': HIDDEN_UNITS,
# The model must choose between N_CLASSES classes.
'n_classes': N_CLASSES,
})
# Train the Model.
classifier.train(
input_fn=lambda: data.train_input_fn(train_x, train_y, BATCH_SIZE),
steps=TRAIN_STEPS)
# Evaluate the model.
eval_result = classifier.evaluate(
input_fn=lambda: data.eval_input_fn(test_x, test_y, BATCH_SIZE))
print('\nTest set accuracy: {}\n'.format(
eval_result['accuracy'])) # accuracy
print('\nTest set accuracy: {}\n'.format(
eval_result['accuracy'])) # accuracy
print('\nTest set accuracy: {}\n'.format(
eval_result['accuracy'])) # accuracy
print('\nTest set accuracy: {}\n'.format(
eval_result['accuracy'])) # accuracy
print('\nTest set accuracy: {}\n'.format(
eval_result['accuracy'])) # accuracy
"""
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(argv):
args = parser.parse_args(argv[1:])
(train_features, train_labels), (test_features, test_labels) = data.load()
feature_columns = data.get_feature_columns(train_features)
classifier = tf.estimator.DNNClassifier(
feature_columns=feature_columns,
hidden_units=[10, 10],
n_classes=3)
classifier.train(
input_fn=lambda:data.train_input_fn(train_features,
train_labels,
args.batch_size),
steps=args.train_steps)
evaluation = classifier.evaluate(
input_fn=lambda:data.eval_input_fn(test_features,
test_labels,
args.batch_size))
print(evaluation)
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)
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_target_dec, train_target_dec_length = data.dec_target_processing(train_label, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_input_enc, eval_input_enc_length = data.enc_processing(eval_input,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={ # 모델 쪽으로 파라메터 전달한다.
'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 유무를 설정한다.
})
# 학습 실행
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)
# 서빙 기능 유무에 따라 모델을 Save 한다.
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))
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()
# 훈련 데이터와 테스트 데이터를 가져온다.
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 train(step):
bot = telegram.Bot('auth')
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
data_out_candidate_path = os.path.join(os.getcwd(),
DATA_OUT_CANDIDATE_PATH)
os.makedirs(data_out_path, exist_ok=True)
os.makedirs(data_out_candidate_path, exist_ok=True)
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_vocabulary_for_train()
# 훈련 데이터와 테스트 데이터를 가져온다.
train_input, train_label, eval_input, eval_label = data.load_data_for_train(
)
# 훈련셋 인코딩 만드는 부분이다.
train_input_enc, train_input_enc_length = data.enc_processing(
train_input, char2idx)
# 훈련셋 디코딩 출력 부분 만드는 부분이다.
train_target_dec, train_target_dec_length = data.dec_target_processing(
train_label, char2idx)
# 평가셋 인코딩 만드는 부분이다.
eval_input_enc, eval_input_enc_length = data.enc_processing(
eval_input, 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)
check_point_candidate_path = os.path.join(
os.getcwd(), DEFINES.check_point_candidate_path)
save_model_candidate_path = os.path.join(os.getcwd(),
DEFINES.save_model_candidate_path)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(check_point_candidate_path, exist_ok=True)
os.makedirs(save_model_candidate_path, exist_ok=True)
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_candidate_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 유무를 설정한다.
})
earlystop = StopHook()
# 학습 실행
tf.estimator.train_and_evaluate(
classifier,
train_spec=tf.estimator.TrainSpec(input_fn=lambda: data.train_input_fn(
train_input_enc, train_target_dec_length, train_target_dec, DEFINES
.batch_size),
max_steps=step,
hooks=[earlystop]),
eval_spec=tf.estimator.EvalSpec(input_fn=lambda: data.eval_input_fn(
eval_input_enc, eval_target_dec, DEFINES.batch_size)))
# 서빙 기능 유무에 따라 모델을 Save 한다.
save_model_path = classifier.export_savedmodel(
export_dir_base=DEFINES.save_model_path,
serving_input_receiver_fn=serving_input_receiver_fn)
def input_data(chat):
tf.logging.set_verbosity(tf.logging.ERROR)
arg_length = len(chat)
if (arg_length < 2):
raise Exception("Don't call us. We'll call you")
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_vocabulary()
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
input = ""
for i in chat[1:]:
input += i
input += " "
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="./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
})
answer = data.pred2string(predictions, idx2char)
else:
# 예측을 하는 부분이다.
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_target_dec, DEFINES.batch_size))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
answer = data.pred2string(predictions, idx2char)
return 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)
tf.feature_column.numeric_column(key=key) for key in train_x.keys()
]
# make the classifier
classifier = tf.estimator.DNNClassifier(feature_columns=feature_columns,
hidden_units=[num_nodes] * num_layers,
n_classes=len(data.TYPES))
# train the classifier
classifier.train(
input_fn=lambda: data.train_input_fn(train_x, train_y, batch_size),
steps=train_steps)
# evaluate the classifier
evaluation = classifier.evaluate(
input_fn=lambda: data.eval_input_fn(test_x, test_y, batch_size))
# chekc out the accuracy
print('\naccuracy:', evaluation['accuracy'], '\n')
# hopefully this gets labeled as a ghost
predict_features = {
'bone_length': [0.0],
'rotting_flesh': [0.0],
'hair_length': [0.0],
'has_soul': [0.0],
'black': [0.0],
'blue': [0.0],
'clear': [1.0],
'white': [0.0],
'green': [0.0],
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': DEFINES.embedding_size, # 임베딩 사용 여부를 결정
'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.pre2string(predictions, idx2char)
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)
'''
print("[댓글]" + comments.attrib['text'])
if comments.attrib['is_mine'] == "1":
is_mine_comment = True
posvote = int(comments.attrib['posvote'])
comment_parent_id = comments.attrib['parent_id']
if bestcount <= posvote and comment_parent_id == "0":
best_comment = comments.attrib['text']
bestcount = posvote
predic_input_enc, predic_input_enc_length = data.enc_processing(
[post], 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))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
postfeel = 0
post = post.replace(",", " ")
best_comment = best_comment.replace(",", " ")
if "씨발" in post or "시발" in post or "ㅅㅂ" in post or "새끼" in post or "ㅅㄲ" in post or "ㅠ" in post or "찐따" in post or "ㅜ" in post:
postfeel = 1
if "파이팅" in post or "ㅎㅎ" in post or "ㅋㅋ" in post or "사랑" in post or "좋은" in post:
postfeel = 2
def main(self):
## DATA_OUT_PATH가 없으면 생성, 있으면 그대로 폴더 사용
data_out_path = os.path.join(os.getcwd(), DATA_OUT_PATH)
os.makedirs(data_out_path, exist_ok = True)
## 단어 사전 불러오기
word2idx, idx2word, 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, word2idx)
train_output_dec, train_input_dec_length = data.dec_input_processing(train_label, word2idx)
train_target_dec = data.dec_target_processing(train_label, word2idx)
## 인코더 입력, 디코더 입력, 디코더 타깃 검증 데이터로 만들기
eval_input_enc, eval_input_enc_length = data.enc_processing(eval_input, word2idx)
eval_output_dec, eval_input_dec_length = data.dec_input_processing(eval_label, word2idx)
eval_target_dec = data.dec_target_processing(eval_label, word2idx)
## 체크 포인트 설정
## data_out 폴더에 생성될 것
check_point_path = os.path.join(os.getcwd(), DEFINES.check_point_path)
os.makedirs(check_point_path, exist_ok = True)
# Estimator 객체 생성
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.embeddding_size,
'embedding': DEFINES.embedding,
'multilayer': DEFINES.multilayer,
})
# Estimator로 학습 진행
## 필요 인자: 입력 함수, 스텝
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, predic_input_enc_length = data.enc_processing(["Education is important"],
word2idx)
predic_input_dec, predic_input_dec_length = data.dec_input_processing([""], word2idx)
predic_target_dec = data.dec_target_processing([""], word2idx)
predictions = classifier.predict(
input_fn = lambda: data.eval_input_fn(predic_input_enc, predic_input_dec,
predic_target_dec, DEFINES.batch_size))
data.pred2string(predictions, idx2word)
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_target_dec, train_target_dec_length = data.dec_target_processing(
train_label, char2idx)
# 평가셋 인코딩을 만듦
eval_input_enc, eval_input_enc_length = data.enc_processing(
eval_input, 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={ # 모델 쪽으로 파라미터를 전달
'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 여부 설정
})
# 학습 실행
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)
# 서빙 기능 여부에 따라 모델을 save
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))
