인공지능 작사가만들기

문장의 정의

• 생각이나 감정을 말과 글로 표현할 떄 완결된 내용을 나타내는 최소의 단위

핵심

• 인공지능이 문장을 이해하는 방식
• 작문을 가르치는 법

시퀀스

파이썬 프로그래밍 시퀀스 자료형

list1 = list()          # 빈 리스트를 생성
list2 = list('ABCD')    # list(iterable object)
                        # ['A','B','C','D']
list3 = list(range(10)) # [0,1,2,3,4,5,6,7,8,9]

def even_generator() :
    for i in range(10) :
        if i % 2 == 0 :
            yield i

list4 = list(even_generator()) # [0, 2, 4, 6, 8]

list5 = list((i for i in range(10) if i % 2 == 0))
list6 = list( i for i in range(10) if i % 2 == 0 ) # ()가 없어도 됨

print('리스트1 ', list1)
print('리스트2 ', list2)
print('리스트3 ', list3)
print('리스트4 ', list4)
print('리스트5 ', list5)
print('리스트6 ', list6)


    

리스트1  []
리스트2  ['A', 'B', 'C', 'D']
리스트3  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
리스트4  [0, 2, 4, 6, 8]
리스트5  [0, 2, 4, 6, 8]
리스트6  [0, 2, 4, 6, 8]

RNN

단어를 적재적소에 활용하는 능력을 발달(문법적인 원리 X)

sentence = " 나는 밥을 먹었다 "

source_sentence = "<start>" + sentence
target_sentence = sentence + "<end>"

print("Source 문장:", source_sentence)
print("Target 문장:", target_sentence)

Source 문장: <start> 나는 밥을 먹었다 
Target 문장:  나는 밥을 먹었다 <end>

• 일반적으로 '나는 밥을 ()'에서 ()에 들어갈 말은 먹는다.
• 가장 첫 시작인 나는 을 만들기 위해서
• \ 라는 특수한 토큰을 추가
• \ 토큰을 받은 순환신경망은 다음으로 나는 을 생성하고, 생성한 단어를 다시 입력으로 사용
• 순차적으로 생성하고나면, 끝냈다는 \ 토큰을 생성
  
• \가 문장의 시작에 더해진 입력데이터 - 문제
• \가 문장 끝에 더해진 출력 데이터 - 답안지

언어모델

• n−1개의 단어 시퀀스 $w_1, ... w_{n-1}$가 주어졌을 때, n번째 단어 $w_n$으로 무엇이 올지를 예측하는 확률 모델 에서 파라미터 $\theta$로 모델링하는 언어 모델

$ P({w_n|w_1, ..., w{n-1}}; \theta) $

$n−1$번째까지의 단어 시퀀스가 x_train이 되고 $n$번째 단어가 y_train이 되는 데이터셋

데이터 다듬기

데이터 다운로드

import os, re 
import numpy as np
import tensorflow as tf

# 파일을 읽기모드로 열고
# 라인 단위로 끊어서 list 형태로 읽어옵니다.
file_path = './lyricist/data/shakespeare.txt'
with open(file_path, "r") as f:
    raw_corpus = f.read().splitlines()

# 앞에서부터 10라인만 화면에 출력해 볼까요?
print(raw_corpus[:9])

['First Citizen:', 'Before we proceed any further, hear me speak.', '', 'All:', 'Speak, speak.', '', 'First Citizen:', 'You are all resolved rather to die than to famish?', '']

• 원치 않는 문장은 화자가 표기된 문장(0, 3, 6), 그리고 공백인 문장(2, 5, 9)
• 화자가 표기된 문장은 문장의 끝이 :로 끝
• : 를 기준으로 문장을 제외
• 공백인 문장은 길이를 검사하여 길이가 0이라면 제외

for idx, sentence in enumerate(raw_corpus):
    if len(sentence) == 0: continue   # 길이가 0인 문장은 건너뜁니다.
    if sentence[-1] == ":": continue  # 문장의 끝이 : 인 문장은 건너뜁니다.

    if idx > 9: break   # 일단 문장 10개만 확인해 볼 겁니다.
        
    print(sentence)

The first words that come out
And I can see this song will be about you
I can't believe that I can breathe without you
But all I need to do is carry on
The next line I write down
And there's a tear that falls between the pages
I know that pain's supposed to heal in stages
But it depends which one I'm standing on I write lines down, then rip them up
Describing love can't be this tough I could set this song on fire, send it up in smoke
I could throw it in the river and watch it sink in slowly

토큰화(Tokenize)

1. Hi, my name is John. *("Hi," "my", ..., "john." 으로 분리됨) - 문장부호
   → 문장 부호 양쪽에 공백을 추가
2. First, open the first chapter. *(First와 first를 다른 단어로 인식) - 대소문자
   → 모든 문자들을 소문자로 변환
3. He is a ten-year-old boy. *(ten-year-old를 한 단어로 인식) - 특수문자
   → 특수문자들은 모두 제거

정규표현식(Regex)을 이용한 필터링이 유용하게 사용

# 입력된 문장을
#     1. 소문자로 바꾸고, 양쪽 공백을 지웁니다
#     2. 특수문자 양쪽에 공백을 넣고
#     3. 여러개의 공백은 하나의 공백으로 바꿉니다
#     4. a-zA-Z?.!,¿가 아닌 모든 문자를 하나의 공백으로 바꿉니다
#     5. 다시 양쪽 공백을 지웁니다
#     6. 문장 시작에는 <start>, 끝에는 <end>를 추가합니다
# 이 순서로 처리해주면 문제가 되는 상황을 방지할 수 있겠네요!
def preprocess_sentence(sentence):
    sentence = sentence.lower().strip() # 1
    sentence = re.sub(r"([?.!,¿])", r" \1 ", sentence) # 2
    sentence = re.sub(r'[" "]+', " ", sentence) # 3
    sentence = re.sub(r"[^a-zA-Z?.!,¿]+", " ", sentence) # 4
    sentence = sentence.strip() # 5
    sentence = '<start> ' + sentence + ' <end>' # 6
    return sentence

# 이 문장이 어떻게 필터링되는지 확인해 보세요.
print(preprocess_sentence("This @_is ;;;sample        sentence."))

<start> this is sample sentence . <end>

지저분한 문장을 넣어도 예쁘게 변환해 주는 정제 함수가 완성

• \ \ 도 추가

• 자연어처리 분야에서 모델의 입력이 되는 문장을 소스 문장(Source Sentence)
  → x_train
• 정답 역할을 하게 될 모델의 출력 문장을 타겟 문장(Target Sentence)
  → y_train

corpus 이용 정제 데이터 구축

# 여기에 정제된 문장을 모을겁니다
corpus = []

for sentence in raw_corpus:
    # 우리가 원하지 않는 문장은 건너뜁니다
    if len(sentence) == 0: continue
    if sentence[-1] == ":": continue
    
    # 정제를 하고 담아주세요
    preprocessed_sentence = preprocess_sentence(sentence)
    corpus.append(preprocessed_sentence)
        
# 정제된 결과를 10개만 확인해보죠
corpus[:10]

['<start> before we proceed any further , hear me speak . <end>',
 '<start> speak , speak . <end>',
 '<start> you are all resolved rather to die than to famish ? <end>',
 '<start> resolved . resolved . <end>',
 '<start> first , you know caius marcius is chief enemy to the people . <end>',
 '<start> we know t , we know t . <end>',
 '<start> let us kill him , and we ll have corn at our own price . <end>',
 '<start> is t a verdict ? <end>',
 '<start> no more talking on t let it be done away , away ! <end>',
 '<start> one word , good citizens . <end>']

tf.keras.preprocessing.text.Tokenizer 패키지

 - 정제된 데이터를 토큰화 
 - 단어 사전(vocabulary 또는 dictionary라고 칭함) 제작
 - 데이터를 숫자로 변환.

→ 벡터화(vectorize), 숫자로 변환된 데이터를 텐서(tensor)

• Tensor란 무엇인가?

# 토큰화 할 때 텐서플로우의 Tokenizer와 pad_sequences를 사용합니다
# 더 잘 알기 위해 아래 문서들을 참고하면 좋습니다
# https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/text/Tokenizer
# https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/sequence/pad_sequences
def tokenize(corpus):
    # 7000단어를 기억할 수 있는 tokenizer를 만들겁니다
    # 우리는 이미 문장을 정제했으니 filters가 필요없어요
    # 7000단어에 포함되지 못한 단어는 '<unk>'로 바꿀거에요
    tokenizer = tf.keras.preprocessing.text.Tokenizer(
        num_words=7000, 
        filters=' ',
        oov_token="<unk>"
    )
    # corpus를 이용해 tokenizer 내부의 단어장을 완성합니다
    tokenizer.fit_on_texts(corpus)
    # 준비한 tokenizer를 이용해 corpus를 Tensor로 변환합니다
    tensor = tokenizer.texts_to_sequences(corpus)   
    # 입력 데이터의 시퀀스 길이를 일정하게 맞춰줍니다
    # 만약 시퀀스가 짧다면 문장 뒤에 패딩을 붙여 길이를 맞춰줍니다.
    # 문장 앞에 패딩을 붙여 길이를 맞추고 싶다면 padding='pre'를 사용합니다
    tensor = tf.keras.preprocessing.sequence.pad_sequences(tensor, padding='post')  
    
    print(tensor,tokenizer)
    return tensor, tokenizer

tensor, tokenizer = tokenize(corpus)

[[   2  143   40 ...    0    0    0]
 [   2  110    4 ...    0    0    0]
 [   2   11   50 ...    0    0    0]
 ...
 [   2  149 4553 ...    0    0    0]
 [   2   34   71 ...    0    0    0]
 [   2  945   34 ...    0    0    0]] <keras_preprocessing.text.Tokenizer object at 0x7fdf6cb56df0>

→ 텐서 데이터를 3번재 행, 10번째 열까지만 출력

print(tensor[:3, :10])

[[   2  143   40  933  140  591    4  124   24  110]
 [   2  110    4  110    5    3    0    0    0    0]
 [   2   11   50   43 1201  316    9  201   74    9]]

• 텐서 데이터는 모두 정수
• 숫자는 tokenizer에 구축된 단어 사전의 인덱스
• 2번 인덱스가 바로 \

for idx in tokenizer.index_word:
    print(idx, ":", tokenizer.index_word[idx])

    if idx >= 10: break

1 : <unk>
2 : <start>
3 : <end>
4 : ,
5 : .
6 : the
7 : and
8 : i
9 : to
10 : of

• 텐서 출력부에서 행 뒤쪽에 0이 많이 나온 부분은 정해진 입력 시퀀스 길이보다 문장이 짧을 경우 0으로 패딩(padding)을 채워 넣은 것
• 사전에는 없지만 0은 바로 패딩 문자 \

# tensor에서 마지막 토큰을 잘라내서 소스 문장을 생성합니다
# 마지막 토큰은 <end>가 아니라 <pad>일 가능성이 높습니다.
src_input = tensor[:, :-1]  
# tensor에서 <start>를 잘라내서 타겟 문장을 생성합니다.
tgt_input = tensor[:, 1:]    

print(src_input[0])
print(tgt_input[0])

[  2 143  40 933 140 591   4 124  24 110   5   3   0   0   0   0   0   0
   0   0]
[143  40 933 140 591   4 124  24 110   5   3   0   0   0   0   0   0   0
   0   0]

• corpus 내의 첫 번째 문장에 대해 생성된 소스와 타겟 문장을 확인
• 소스는 2(\)에서 시작해서 3(\)으로 끝난 후 0(\)로 채워져
• 타겟은 2로 시작하지 않고 소스를 왼쪽으로 한 칸 시프트 한 형태

tf.data.Dataset.from_tensor_slices() 메소드를 이용 → tf.data.Dataset 생성

• 텐서로 생성된 데이터를 이용해 tf.data.Dataset객체를 생성하는 방법
• tf.data.Dataset객체는 텐서플로우에서 사용할 경우 데이터 입력 파이프라인을 통한 속도 개선 및 각종 편의 기능을 제공
• tf.data.Dataset.from_tensor_slices() 메소드를 이용
  → tf.data.Dataset 생성

BUFFER_SIZE = len(src_input)
BATCH_SIZE = 256  #왜 256으로??
steps_per_epoch = len(src_input) // BATCH_SIZE

 # tokenizer가 구축한 단어사전 내 7000개와, 여기 포함되지 않은 0:<pad>를 포함하여 7001개
VOCAB_SIZE = tokenizer.num_words + 1   

# 준비한 데이터 소스로부터 데이터셋을 만듭니다
# 데이터셋에 대해서는 아래 문서를 참고하세요
# 자세히 알아둘수록 도움이 많이 되는 중요한 문서입니다
# https://www.tensorflow.org/api_docs/python/tf/data/Dataset
dataset = tf.data.Dataset.from_tensor_slices((src_input, tgt_input))
dataset = dataset.shuffle(BUFFER_SIZE)
dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)
dataset

<BatchDataset shapes: ((256, 20), (256, 20)), types: (tf.int32, tf.int32)>

인공지능학습

우리가 만들 구조도

• tf.keras.Model을 Subclassing하는 방식
• 1개의 Embedding 레이어, 2개의 LSTM 레이어, 1개의 Dense 레이어로 구성
  

class TextGenerator(tf.keras.Model):
    def __init__(self, vocab_size, embedding_size, hidden_size):
        super().__init__()
        
        self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_size)
        self.rnn_1 = tf.keras.layers.LSTM(hidden_size, return_sequences=True)
        self.rnn_2 = tf.keras.layers.LSTM(hidden_size, return_sequences=True)
        self.linear = tf.keras.layers.Dense(vocab_size)
        
    def call(self, x):
        out = self.embedding(x)
        out = self.rnn_1(out)
        out = self.rnn_2(out)
        out = self.linear(out)
        
        return out
    
embedding_size = 256
hidden_size = 1024
model = TextGenerator(tokenizer.num_words + 1, embedding_size , hidden_size)

• 텍스트 분류 모델의 Embedding 레이어의 역할
• 입력 텐서에는 단어 사전의 인덱스 포함
• Embedding 레이어는 이 인덱스 값을 해당 인덱스 번째의 워드 벡터로 변경
• 워드 벡터는 의미 벡터 공간에서 단어의 추상적 표혀능로 사용

위 코드에서 embedding_size 는 워드 벡터의 차원수, 즉 단어가 추상적으로 표현되는 크기
예를 들어 2라면,

• 차갑다: [0.0, 1.0]
• 뜨겁다: [1.0, 0.0]
• 미지근하다: [0.5, 0.5]

• 클수록 추상적인 특징을 잡아낼 수 있음

• 충분한 데이터가 없으면 혼란이 야기

• 위의 문제에서는 256으로 설정

• LSTM 레이어의hidden state의 차원수인 hidden_size도 같은 맥락

• 1024가 적당 > 왜???

• model 빌딩은 아직

  • model.complie()를 호출 안함
  • model 의 입력 텐서 지정도 안함

• model의 input shape가 결정되면서 model.build()가 자동으로 호출

# 데이터셋에서 데이터 한 배치만 불러오는 방법입니다.
# 지금은 동작 원리에 너무 빠져들지 마세요~
for src_sample, tgt_sample in dataset.take(1): break

# 한 배치만 불러온 데이터를 모델에 넣어봅니다
model(src_sample)

<tf.Tensor: shape=(256, 20, 7001), dtype=float32, numpy=
array([[[-4.31300432e-05, -1.61468924e-04, -2.28978643e-05, ...,
         -1.30526796e-05, -1.65740246e-04, -1.52532608e-04],
        [-3.31729389e-04, -3.35492572e-04,  9.25426939e-05, ...,
         -5.40830388e-06, -3.98255826e-04, -1.54450114e-04],
        [-3.56497185e-04, -5.21454436e-04,  9.67504602e-05, ...,
          5.08658530e-04, -2.61457870e-04, -4.00694320e-04],
        ...,
        [-1.85111989e-04, -4.65744082e-03, -2.55297264e-03, ...,
         -1.98253267e-03,  1.08430139e-03, -1.12067943e-03],
        [-2.26652643e-04, -4.91228886e-03, -2.57866457e-03, ...,
         -2.21222127e-03,  1.26814318e-03, -1.42959598e-03],
        [-2.72341655e-04, -5.11216559e-03, -2.58543598e-03, ...,
         -2.40770658e-03,  1.43469241e-03, -1.71830074e-03]],

       [[-4.31300432e-05, -1.61468924e-04, -2.28978643e-05, ...,
         -1.30526796e-05, -1.65740246e-04, -1.52532608e-04],
        [-5.15408523e-04, -2.02041178e-04,  1.23195961e-04, ...,
          2.49126664e-04, -3.87586042e-04, -2.07115838e-04],
        [-4.60794341e-04, -6.10847856e-05,  1.97986214e-04, ...,
          4.49985295e-04, -6.17051148e-04, -3.10465286e-04],
        ...,
        [ 8.63971800e-05, -4.08918737e-03, -2.27619591e-03, ...,
         -2.37792335e-03,  3.57422628e-04, -1.23522384e-03],
        [ 4.76920541e-05, -4.44815168e-03, -2.36615562e-03, ...,
         -2.57940381e-03,  6.33708783e-04, -1.43076328e-03],
        [-4.88970727e-06, -4.74188896e-03, -2.42232508e-03, ...,
         -2.74938415e-03,  8.77008599e-04, -1.63904799e-03]],

       [[-4.31300432e-05, -1.61468924e-04, -2.28978643e-05, ...,
         -1.30526796e-05, -1.65740246e-04, -1.52532608e-04],
        [-3.92017188e-04, -4.05272236e-04, -4.03737446e-04, ...,
          2.08484649e-04, -1.78227972e-04, -1.51166416e-04],
        [-6.78456272e-04, -8.21831811e-04, -4.12415975e-04, ...,
          7.16181123e-04, -2.64001399e-04, -1.19791046e-04],
        ...,
        [ 6.99736876e-04, -3.99236009e-03, -1.08700444e-03, ...,
         -1.69491197e-03,  2.50219717e-04, -7.33265886e-04],
        [ 6.50285685e-04, -4.42640856e-03, -1.28968060e-03, ...,
         -1.98570453e-03,  5.35400759e-04, -1.02897582e-03],
        [ 5.66453091e-04, -4.77890717e-03, -1.45729876e-03, ...,
         -2.23665801e-03,  7.83600728e-04, -1.31549360e-03]],

       ...,

       [[-4.31300432e-05, -1.61468924e-04, -2.28978643e-05, ...,
         -1.30526796e-05, -1.65740246e-04, -1.52532608e-04],
        [ 9.46695582e-06, -1.02088648e-04,  2.74929276e-04, ...,
          2.84693117e-04, -2.84875568e-04, -2.80248147e-04],
        [ 2.56561616e-04, -2.39318193e-04,  5.11636317e-04, ...,
          1.42004428e-04, -4.73114924e-04, -4.22215729e-04],
        ...,
        [ 3.18835628e-05, -5.07764611e-03, -2.44524307e-03, ...,
         -2.17102608e-03,  9.32406518e-04, -1.62668424e-04],
        [-3.98430202e-05, -5.27923508e-03, -2.50015478e-03, ...,
         -2.35773833e-03,  1.14679523e-03, -5.46753930e-04],
        [-1.08012224e-04, -5.43248793e-03, -2.52589677e-03, ...,
         -2.51999241e-03,  1.33289036e-03, -9.18680802e-04]],

       [[-4.31300432e-05, -1.61468924e-04, -2.28978643e-05, ...,
         -1.30526796e-05, -1.65740246e-04, -1.52532608e-04],
        [-2.36422085e-04, -2.61728710e-04,  2.46185751e-04, ...,
         -6.08692972e-05, -3.13386961e-04, -1.68910818e-04],
        [-2.05222939e-04, -2.19296082e-04,  1.04809449e-04, ...,
          1.52687702e-04, -2.95088452e-04, -1.40395117e-04],
        ...,
        [-3.88026383e-04, -4.55201278e-03, -2.38304026e-03, ...,
         -2.11151317e-03,  1.44088583e-03, -1.46701431e-03],
        [-4.51929373e-04, -4.85128677e-03, -2.44412408e-03, ...,
         -2.32648896e-03,  1.53514405e-03, -1.73510751e-03],
        [-5.07737219e-04, -5.08674514e-03, -2.47974368e-03, ...,
         -2.51027266e-03,  1.62658445e-03, -1.98661070e-03]],

       [[-4.31300432e-05, -1.61468924e-04, -2.28978643e-05, ...,
         -1.30526796e-05, -1.65740246e-04, -1.52532608e-04],
        [-9.77924428e-05, -4.37246083e-04,  3.97726777e-04, ...,
          5.69955155e-05, -2.75543978e-04, -6.65865809e-05],
        [-1.78766222e-05, -7.11038534e-04,  5.13010891e-04, ...,
          6.48956920e-05, -4.87306388e-04,  4.01803874e-04],
        ...,
        [ 7.31389737e-04, -3.84947122e-03, -2.41923332e-03, ...,
         -2.36577378e-03,  1.51708734e-03, -6.34322700e-04],
        [ 5.93748991e-04, -4.21182066e-03, -2.47242069e-03, ...,
         -2.56023020e-03,  1.65442866e-03, -9.69938294e-04],
        [ 4.57269518e-04, -4.51200176e-03, -2.50035292e-03, ...,
         -2.72135716e-03,  1.77274307e-03, -1.29425328e-03]]],
      dtype=float32)>

• 모델의 최종 출력 텐서 shape를 유심히 보면 shape=(256, 20, 7001)임
• 7001은 Dense 레이어의 출력 차원수
• 7001개의 단어 중 어느 단어의 확률이 가장 높을지를 모델링해야 하기 때문
• 256은 이전 스텝에서 지정한 배치 사이즈
• dataset.take(1)를 통해서 1개의 배치, 즉 256개의 문장 데이터를 가져온 것
• 20은
  • tf.keras.layers.LSTM(hidden_size, return_sequences=True)로 호출한 LSTM 레이어에서 return_sequences=True이라고 지정한 부분
  • LSTM은 자신에게 입력된 시퀀스의 길이만큼 동일한 길이의 시퀀스를 출력한다는 의미
  • return_sequences=False였다면 LSTM 레이어는 1개의 벡터만 출력
  • 데이터셋의 max_len이 20으로 맞춰져 있었던 것

# 드디어 model.summary() 출력
model.summary()

Model: "text_generator"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding (Embedding)        multiple                  1792256   
_________________________________________________________________
lstm (LSTM)                  multiple                  5246976   
_________________________________________________________________
lstm_1 (LSTM)                multiple                  8392704   
_________________________________________________________________
dense (Dense)                multiple                  7176025   
=================================================================
Total params: 22,607,961
Trainable params: 22,607,961
Non-trainable params: 0
_________________________________________________________________

Output Shape???

• 모델은 입력 시퀀스의 길이를 모르기 때문에 Output Shape를 특정할 수 없는 것
  모델의 파라미터 사이즈는 측정
  - 22million
  - GPT-2의 파라미터 사이즈는, 1.5billion
  - GPT-3의 파라미터 사이즈는 GPT-2의 100배

모델 학습

# optimizer와 loss등은 차차 배웁니다
# 혹시 미리 알고 싶다면 아래 문서를 참고하세요
# https://www.tensorflow.org/api_docs/python/tf/keras/optimizers
# https://www.tensorflow.org/api_docs/python/tf/keras/losses
# 양이 상당히 많은 편이니 지금 보는 것은 추천하지 않습니다
optimizer = tf.keras.optimizers.Adam()
loss = tf.keras.losses.SparseCategoricalCrossentropy(
    from_logits=True,
    reduction='none'
)

model.compile(loss=loss, optimizer=optimizer)
model.fit(dataset, epochs=30)

Epoch 1/30
93/93 [==============================] - 21s 203ms/step - loss: 1.8062
Epoch 2/30
93/93 [==============================] - 20s 216ms/step - loss: 1.6858
Epoch 3/30
93/93 [==============================] - 19s 205ms/step - loss: 1.6052
Epoch 4/30
93/93 [==============================] - 19s 200ms/step - loss: 1.5281
Epoch 5/30
93/93 [==============================] - 19s 202ms/step - loss: 1.4540
Epoch 6/30
93/93 [==============================] - 19s 207ms/step - loss: 1.3776
Epoch 7/30
93/93 [==============================] - 19s 206ms/step - loss: 1.3050
Epoch 8/30
93/93 [==============================] - 19s 203ms/step - loss: 1.2305
Epoch 9/30
93/93 [==============================] - 19s 203ms/step - loss: 1.1576
Epoch 10/30
93/93 [==============================] - 19s 204ms/step - loss: 1.0847
Epoch 11/30
93/93 [==============================] - 19s 206ms/step - loss: 1.0169
Epoch 12/30
93/93 [==============================] - 19s 205ms/step - loss: 0.9519
Epoch 13/30
93/93 [==============================] - 19s 203ms/step - loss: 0.8902
Epoch 14/30
93/93 [==============================] - 19s 203ms/step - loss: 0.8373
Epoch 15/30
93/93 [==============================] - 19s 203ms/step - loss: 0.7912
Epoch 16/30
93/93 [==============================] - 19s 203ms/step - loss: 0.7523
Epoch 17/30
93/93 [==============================] - 19s 204ms/step - loss: 0.7208
Epoch 18/30
93/93 [==============================] - 19s 204ms/step - loss: 0.6963
Epoch 19/30
93/93 [==============================] - 19s 204ms/step - loss: 0.6760
Epoch 20/30
93/93 [==============================] - 19s 205ms/step - loss: 0.6597
Epoch 21/30
93/93 [==============================] - 19s 205ms/step - loss: 0.6463
Epoch 22/30
93/93 [==============================] - 19s 204ms/step - loss: 0.6353
Epoch 23/30
93/93 [==============================] - 19s 203ms/step - loss: 0.6260
Epoch 24/30
93/93 [==============================] - 19s 203ms/step - loss: 0.6183
Epoch 25/30
93/93 [==============================] - 19s 203ms/step - loss: 0.6118
Epoch 26/30
93/93 [==============================] - 19s 203ms/step - loss: 0.6053
Epoch 27/30
93/93 [==============================] - 19s 203ms/step - loss: 0.6007
Epoch 28/30
93/93 [==============================] - 19s 203ms/step - loss: 0.5963
Epoch 29/30
93/93 [==============================] - 19s 204ms/step - loss: 0.5925
Epoch 30/30
93/93 [==============================] - 19s 205ms/step - loss: 0.5893





<keras.callbacks.History at 0x7fdedafa3400>

Loss는 모델이 오답을 만들고 있는 정도라고 생각( Loss가 1일 때 99%를 맞추고 있다는 의미는 아님).
오답률이 감소하고 있으니 학습이 잘 진행되고 있다 고 해석

작문을 시켜보고 직접 평가

def generate_text(model, tokenizer, init_sentence="<start>", max_len=20):
    # 테스트를 위해서 입력받은 init_sentence도 텐서로 변환합니다
    test_input = tokenizer.texts_to_sequences([init_sentence])
    test_tensor = tf.convert_to_tensor(test_input, dtype=tf.int64)
    end_token = tokenizer.word_index["<end>"]

    # 단어 하나씩 예측해 문장을 만듭니다
    #    1. 입력받은 문장의 텐서를 입력합니다
    #    2. 예측된 값 중 가장 높은 확률인 word index를 뽑아냅니다
    #    3. 2에서 예측된 word index를 문장 뒤에 붙입니다
    #    4. 모델이 <end>를 예측했거나, max_len에 도달했다면 문장 생성을 마칩니다
    while True:
        # 1
        predict = model(test_tensor) 
        # 2
        predict_word = tf.argmax(tf.nn.softmax(predict, axis=-1), axis=-1)[:, -1] 
        # 3 
        test_tensor = tf.concat([test_tensor, tf.expand_dims(predict_word, axis=0)], axis=-1)
        # 4
        if predict_word.numpy()[0] == end_token: break
        if test_tensor.shape[1] >= max_len: break

    generated = ""
    # tokenizer를 이용해 word index를 단어로 하나씩 변환합니다 
    for word_index in test_tensor[0].numpy():
        generated += tokenizer.index_word[word_index] + " "

    return generated

generate_text() 함수에서 init_sentence를 인자로 받고
받은 인자를 일단 텐서로
디폴트로는 \ 단어 하나만

- while의 첫 번째 루프에서 test_tensor에 \<start> 하나만 들어갔다고 합시다.
    - 우리의 모델이 출력으로 7001개의 단어 중 A를 골랐다고 합시다.
- while의 두 번째 루프에서 test_tensor에는 \<start> A가 들어갑니다. 
    - 그래서 우리의 모델이 그다음 B를 골랐다고 합시다.
- while의 세 번째 루프에서 test_tensor에는 <\start> A B가 들어갑니다. 
    - 그래서..... (이하 후략)

generate_text(model, tokenizer, init_sentence="<start> I")

'<start> i am not well , sir , i am not well . <end> '

문장만들기

데이터 다운로드

데이터 읽어오기

• glob 모듈을 사용하면 파일을 읽어오는 작업을 하기가 아주 용이
  • txt 파일을 읽어온 후
  • raw_corpus 리스트에 문장 단위로 저장

import glob
import os

txt_file_path = './lyricist/data/lyrics/*'

txt_list = glob.glob(txt_file_path)

raw_corpus = []

# 여러개의 txt 파일을 모두 읽어서 raw_corpus 에 담습니다.
for txt_file in txt_list:
    with open(txt_file, "r") as f:
        raw = f.read().splitlines()
        raw_corpus.extend(raw)

print("데이터 크기:", len(raw_corpus))
print("Examples:\n", raw_corpus[:3])

데이터 크기: 187088
Examples:
 ['The first words that come out', 'And I can see this song will be about you', "I can't believe that I can breathe without you"]

데이터 정제

• preprocess_sentence() 함수 활용
• 추가로 지나치게 긴 문장은 다른 데이터들이 과도한 Padding을 갖게 하므로 제거
• 토큰화 했을 때 토큰의 개수가 15개를 넘어가는 문장을 학습 데이터에서 제외하기 를 권장

평가 데이터셋 분리

---

• tokenize() 함수로 데이터를 Tensor로 변환한 후, sklearn 모듈의 train_test_split() 함수를 사용해 훈련 데이터와 평가 데이터를 분리
• 단어장의 크기는 12,000 이상 으로 설정하세요! 총 데이터의 20% 를 평가 데이터셋으로 사용

enc_train, enc_val, dec_train, dec_val = <코드 작성>

  File "/tmp/ipykernel_2308/3310982766.py", line 1
    enc_train, enc_val, dec_train, dec_val = <코드 작성>
                                             ^
SyntaxError: invalid syntax

# 결과확인
print("Source Train:", enc_train.shape)
print("Target Train:", dec_train.shape)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

/tmp/ipykernel_2308/1251382030.py in <module>
      1 # 결과확인
----> 2 print("Source Train:", enc_train.shape)
      3 print("Target Train:", dec_train.shape)


NameError: name 'enc_train' is not defined

# 인공지능 만들기
- 모델의 Embedding Size와 Hidden Size를 조절하며 10 Epoch 안에 val_loss 값을 2.2 수준으로 줄일 수 있는 모델을 설계
- Loss 함수를 그대로 사용

  File "/tmp/ipykernel_2308/1025019345.py", line 2
    - 모델의 Embedding Size와 Hidden Size를 조절하며 10 Epoch 안에 val_loss 값을 2.2 수준으로 줄일 수 있는 모델을 설계
          ^
SyntaxError: invalid syntax

#Loss
loss = tf.keras.losses.SparseCategoricalCrossentropy(
    from_logits=True, reduction='none')

generate_text(lyricist, tokenizer, init_sentence="<start> i love", max_len=20)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

/tmp/ipykernel_2308/936477000.py in <module>
----> 1 generate_text(lyricist, tokenizer, init_sentence="<start> i love", max_len=20)


NameError: name 'lyricist' is not defined

평가문항 상세기준
1. 가사 텍스트 생성 모델이 정상적으로 동작하는가?

텍스트 제너레이션 결과가 그럴듯한 문장으로 생성되는가?

2. 데이터의 전처리와 데이터셋 구성 과정이 체계적으로 진행되었는가?

특수문자 제거, 토크나이저 생성, 패딩처리 등의 과정이 빠짐없이 진행되었는가?

3. 텍스트 생성모델이 안정적으로 학습되었는가?

텍스트 생성모델의 validation loss가 2.2 이하로 낮아졌는가?