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 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)
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):
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabularyLength = data.loadVocabulary()
# 훈련 데이터와 테스트 데이터를 가져온다.
xTrain, yTrain, xTest, yTest = data.loadData()
# 훈련셋 인코딩 만드는 부분이다.
inputTrainEnc, inputTrainEncLength = data.encProcessing(xTrain, char2idx)
# 훈련셋 디코딩 입력 부분 만드는 부분이다.
outputTrainDec, outputTrainDecLength = data.decOutputProcessing(yTrain, char2idx)
# 훈련셋 디코딩 출력 부분 만드는 부분이다.
targetTrainDec = data.decTargetProcessing(yTrain, char2idx)
inputTestEnc, inputTestEncLength = data.encProcessing(xTest,char2idx)
outputTestDec, outputTestDecLength = data.decOutputProcessing(yTest, char2idx)
targetTestDec = data.decTargetProcessing(yTest, char2idx)
# 현재 경로'./'에 현재 경로 하부에
# 체크 포인트를 저장한 디렉토리를 설정한다.
checkPointPath = os.path.join(os.getcwd(), DEFINES.checkPointPath)
# 디렉토리를 만드는 함수이며 두번째 인자 exist_ok가
# True이면 디렉토리가 이미 존재해도 OSError가
# 발생하지 않는다.
# exist_ok가 False이면 이미 존재하면
# OSError가 발생한다.
os.makedirs(checkPointPath, exist_ok=True)
# 에스티메이터 구성한다.
classifier = tf.estimator.Estimator(
model_fn=ml.Model, # 모델 등록한다.
model_dir=DEFINES.checkPointPath, # 체크포인트 위치 등록한다.
params={ # 모델 쪽으로 파라메터 전달한다.
'hiddenSize': DEFINES.hiddenSize, # 가중치 크기 설정한다.
'layerSize': DEFINES.layerSize, # 멀티 레이어 층 개수를 설정한다.
'learningRate': DEFINES.learningRate, # 학습율 설정한다.
'vocabularyLength': vocabularyLength, # 딕셔너리 크기를 설정한다.
'embeddingSize': DEFINES.embeddingSize, # 임베딩 크기를 설정한다.
'embedding': DEFINES.embedding, # 임베딩 사용 유무를 설정한다.
'multilayer': DEFINES.multilayer, # 멀티 레이어 사용 유무를 설정한다.
})
# 학습 실행
print(inputTrainEnc.shape, outputTrainDec.shape, targetTrainDec.shape)
classifier.train(input_fn=lambda:data.trainInputFn(
inputTrainEnc, outputTrainDec, targetTrainDec, DEFINES.batchSize), steps=DEFINES.trainSteps)
evalResult = classifier.evaluate(input_fn=lambda:data.evalInputFn(
inputTestEnc, outputTestDec, targetTestDec, DEFINES.batchSize))
print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**evalResult))
# 테스트용 데이터 만드는 부분이다.
# 인코딩 부분 만든다.
inputPredicEnc, inputPredicEncLength = data.encProcessing(["가끔 궁금해"], char2idx)
# 학습 과정이 아니므로 디코딩 입력은
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
outputPredicDec, outputPredicDecLength = data.decOutputProcessing([""], char2idx)
# 학습 과정이 아니므로 디코딩 출력 부분도
# 존재하지 않는다.(구조를 맞추기 위해 넣는다.)
targetPredicDec = data.decTargetProcessing([""], char2idx)
# 예측을 하는 부분이다.
predictions = classifier.predict(
input_fn=lambda:data.evalInputFn(inputPredicEnc, outputPredicDec, targetPredicDec, DEFINES.batchSize))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
data.pred2string(predictions, idx2char)
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 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
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))
predic_input_enc, predic_input_enc_length = data.enc_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.pred2string(predictions, idx2char)
print("Bleu score: ", bleu_compute("그 사람도 그럴 거예요.", answer))
print("Rouge score: ", rouge_compute("그 사람도 그럴 거예요.", answer))
def main():
"""Run the bot."""
global update_id
# Telegram Bot Authorization Token
bot = telegram.Bot('auth')
URL = "https://unopenedbox.com/develop/square/api.php"
last_message = ""
bootcount = 0
lcount = 0
readingold = False
readingold_lastcount = 0
now = datetime.datetime.now()
# get the first pending update_id, this is so we can skip over it in case
# we get an "Unauthorized" exception.
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = 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, # 학습율 설정한다.
'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 유무를 설정한다.
})
while 1:
sleep(3)
now = datetime.datetime.now()
bootcount = bootcount + 1
lcount = lcount + 1
try:
#data = {'a': 'penta_check', 'auth': 'a1s2d3f4g5h6j7k8l9', 'start_num' : '0', 'number' : '15'}
#res = requests.post(URL, data=data)
#answer = "[보고]" + res.json()[0]['description'];
answer = ""
if bootcount == 1:
#answer = "다시 시작했습니다. Penta 버전 1.0.625 밀린 채팅을 읽는 중 입니다..."
readingold = True
readingold_lastcount = bootcount
if readingold_lastcount < bootcount and readingold is True:
readingold = False
#bot.send_message(chat_id = -116418298, text="이전글 읽기 완료.")
if last_message != answer and answer != "":
bot.send_message(chat_id=-116418298, text=answer)
last_message = answer
if last_message == answer:
tlm = ""
last_user = 0
last_talk = ""
updates = bot.get_updates(offset=update_id)
for i in updates:
if i.message:
if last_user != i.message.from_user.id:
last_talk = tlm
tlm = ""
last_user = i.message.from_user.id
# with open("./data_in/ChatBotData.csv", "a") as myfile:
# myfile.write("\n")
if i.message.text is not None and tlm != "":
tlm = tlm + " " + i.message.text
# with open("./data_in/ChatBotData.csv", "a") as myfile:
# myfile.write(" " + i.message.text)
if i.message.text is not None and tlm == "":
tlm = i.message.text
# with open("./data_in/ChatBotData.csv", "a") as myfile:
# myfile.write(i.message.text)
update_id = i.update_id + 1
now_last_id = updates[-1].update_id
if tlm != "" and tlm is not None and now_last_id + 1 <= update_id:
readingold_lastcount = readingold_lastcount + 1
lcount = 0
if not readingold:
predic_input_enc, predic_input_enc_length = data.enc_processing(
[tlm], 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))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
aimessage = data.pred2string(
predictions, idx2char)
if aimessage != "":
bot.send_message(chat_id=-116418298,
text=aimessage)
except IndexError:
update_id = None
except:
if last_message != traceback.format_exc(
) and "Message text is empty" not in traceback.format_exc():
bot.send_message(chat_id=-11641828,
text="[오류] 오류가 발생했습니다. 점검이 필요합니다. \n" +
traceback.format_exc())
last_message = traceback.format_exc()
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
def predict(sentence):
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
arg_length = len(sys.argv)
# if (arg_length < 2):
# raise Exception("문장을 입력해주세요")
# 데이터를 통한 사전 구성 한다.
char2idx, idx2char, vocabulary_length = data.load_vocabulary()
# 테스트용 데이터 만드는 부분이다.
# 테스트로 넣은 문장이 들어온다 인코딩 부분 만든다.
# input = ""
# for i in sys.argv[1:]:
# input += i
# input += " "
print('question:' + sentence)
predic_input_enc, predic_input_enc_length = data.enc_processing([sentence],
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, # 가중치 크기 설정한다.
'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 유무를 설정한다.
})
# 예측을 하는 부분
predictions = classifier.predict(input_fn=lambda: data.eval_input_fn(
predic_input_enc, predic_target_dec, DEFINES.batch_size))
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
answer = data.pred2string(predictions, idx2char)
# 예측한 값을 인지 할 수 있도록
# 텍스트로 변경하는 부분이다.
print("answer: ", answer)
return answer
