Пример #1
0
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)
Пример #2
0
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)
Пример #3
0
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
Пример #4
0
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
Пример #5
0
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)
Пример #6
0
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))
Пример #7
0
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)
Пример #8
0
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))
Пример #9
0
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))
Пример #10
0
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)
Пример #11
0
    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)

    input = ""
    for i in sys.argv[1:]:
        input += i
        input += " "

    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={
                                            '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,
Пример #12
0
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)
Пример #13
0
    arg_length = len(sys.argv)

    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 sys.argv[1:]:
        input += i
        input += " "

    print(input)
    # 테스트셋 인코딩 / 디코딩 입력 / 디코딩 출력 만드는 부분이다.
    predic_input_enc, predic_input_enc_length = data.enc_processing([input],
                                                                    char2idx)
    predic_output_dec, predic_output_dec_length = 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,