REC_ord_ING

[딥러닝을 이용한 자연어 처리 입문] Chapter 8. 순환 신경망 (Recurrent Neural Network) (2)

빈이즈 — Wed, 2 Apr 2025 09:59:03 +0900

이 글은 [유원준 , 상준 ]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/48558

08. 순환 신경망(Recurrent Neural Network)

앞서 배운 피드 포워드 신경망은 입력의 길이가 고정되어 있어 자연어 처리를 위한 신경망으로는 한계가 있었습니다. 결국 다양한 길이의 입력 시퀀스를 처리할 수 있는 인공 신경망이 …

wikidocs.net

08-05 RN 언어 모델 (Recurrent Neural Network Language Model, RNNLM)

1. RNN 언어 모델(Recurrent Neural Network Language Model, RNNLM)

- n-gram, NNLM은 고정된 개수의 단어만을 입력으로 받아야 함 -> '시점'이라는 개념이 도입된 RNN은 입력의 길이를 고정하지 않을 수 있음! -> RNN으로 만든 언어모델을 RNNLM(Recurrent Neural Network Model)이라고 함

예문 : 'what will the fat cat sit on'

- RNNLM은 이전 시점의 출력을 현재 시점의 입력으로 함.

- 예문으로 보면 RNNLM은 what을 입력받으면 will을 예측하고, 이 will은 다음 시점의 입력이 되어 the를 예측. 결과적으로 세번째 시점에서 fat은 앞서 나온 what, will, the 라는 시퀀스로 인해 결정된 단어, 네번째 시점의 cat은 앞서 나온 what, wil, the, fat이라는 시퀀스로 인해 결정된 단어이다.

- 위 과정은 훈련이 끝난 모델의 테스트 과정 동안(실제 사용할 때)의 이야기이고, 훈련 과정에서는 이전 시점의 예측 결과를 다음 시점의 입력으로 넣으면서 예측 X -> what will the fat cat is sit on라는 훈련 샘플이 있다면, what aill the fat cat sit 시퀀스를 모델의 입력으로 넣으면, will the fat cat sit on 을 예측하도록 훈련됨.
- 이러한 RNN 훈련 기법을 교사 강요(teacher forcing)라고 함.

- 교사 강요란 테스트 과정에서 t시점의 출력이 t+1 시점의 입력으로 사용되는 RNN 모델을 훈련시킬 때 사용하는 훈련 기법으로, 모델이 t시점에서 예측한 값을 t+1 시점에 입력으로 사용하지 않고, t 시점의 레이블, 즉 실제 알고 있는 정답을 t+1 시점의 입력으로 사용.

- 출력층에서 사용하는 활성화 함수는 소프트맥스 함수, 손실함수는 크로스 엔트로피 함수를 사용함.
- RNNLM은 총 4개의 층으로 이루어진 인공 신경망. 현 시점을 4로 가정. 4번째 입력 단어 fat의 원-핫 벡터가 입력이 됨.
- 출력층을 보자. 모델이 예측해야하는 정답에 해당하는 단어 cat의 원-핫 벡터는 출력층에서 모델이 예측한 값의 오차를 구하기 위해 사용될 예정 => 이 오차로부터 손실 함수를 사용해 인공 신경망 학습.

- 현 시점의 입력 단어의 원-핫 벡터 xt를 입력 받은 RNNLM은 임베딩층(embedding layer)을 지남. 이 임베딩층은 기본적으로 NNLM에서 배운 투사층. NNLM에서는 룩업 테이블을 수행하는 층을 투사층이라고 표현했지만, 이미 투사층의 결과로 얻는 벡터를 임베딩 벡터라고 부른다고 했으므로, 앞으로는 임베딩 벡터를 얻는 투사층을 임베딩층이라는 표현으로 사용.
- 단어 집합의 크기가 V일 때, 임베딩 벡터의 크기를 M으로 설정하면, 각 입력 단어들은 임베딩층에서 V X M 크기의 임베딩 행렬과 곱해짐. 여기서 V는 단어 집합의 크기를 의미. 그리고 이 임베딩 행렬은 역전파 과정에서 다른 가중치들과 함께 학습됨.

임베딩층 : et = lookup(xt)

- 이 임베딩 벡터는 은닉층에서 이전 시점의 은닉 상태인 h_(t-1)과 함께 다음의 연산을 하여 현재 시점의 은닉 상태 ht를 계산하게 됨.

은닉층 : ht = tanh(Wxet + Whh_(t-1) + b)

- 출력층에서는 활성화 함수를 소프트맥스 함수를 사용하는데, V차원의 벡터는 소프트맥스 함수를 지나면서 0과 1사이의 실수값을 가지며 총 합은 1이 되는 상태로 바뀜. 이렇게 나온 벡터를 RNNLM의 t시점의 예측값이라는 의미에서 yt hat이라고 하자.

출력층 : yt hat = softmax(Wy ht + b)

- yt hat의 각 차원 안에서의 값이 의미하는 것은 j번째 인덱스가 가진 0과 1 사이의 값은 j번째 단어가 다음 단어일 확률을 나타냄. 그리고 실제 정답에 해당하는 단어인 원-핫 벡터의 값에 가까워져야 함. 손실함수로 cross-entropy함수를 사용. 역전파가 이루어지면서 가중치 행렬들이 학습되는데 이 과정에서 임베딩 벡터값들도 학습됨.
- 룩업 테이블의 대상이 되는 테이블인 임베딩 행렬은 E라고 하였을 때, 결과적으로 RNNLM에서 학습 과정에서 학습되는 가중치 행렬은 다음의 E, Wx, Wh, Wy이다.

08-06 RNN을 이용한 텍스트 생성(Text Generation using RNN)

- 다 대 일 (many-to-one) 구조의 RNN을 사용하여 문맥을 반영해서 텍스트를 생성하는 모델을 만들어보자.

1. RNN을 이용하여 텍스트 생성하기

- 예를 들어서 '경마장에 있는 말이 뛰고 있다'와 '그의 말이 법이다'와 '가는 말이 고와야 오는 말이 곱다'라는 세 가지 문장이 있다고 해보자. 모델이 문맥을 학습할 수 있도록 전체 문장의 앞의 단어들을 전부 고려하여 학습하도록 데이터를 재구성한다면 아래와 같이 11개의 샘플이 구성됨. (ex, 경마장에|있는, 경마장에 있는 |말이, ...)

1) 데이터에 대한 이해와 전처리

import numpy as np
from tensorflow.keras.preprocessing. text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.utilis import to_categorical

# 세 문장 저장
text = """경마장에 있는 말이 뛰고 있다\n
그의 말이 법이다\n
가는 말이 고와야 오는 말이 곱다\n"""

- 단어 집합을 생성하고 크기를 확인해보자. 단어 집합의 크기를 저장할 때는 케라스 토크나이저의 정수 인코딩은 인덱스가 1부터 시작하지만, 패딩을 위한 0을 고려하여 +1을 해주기

tokenizer = Tokenizer()
tokenizer.fit_on_texts([text])
vocab_size = len(tokenizer.word_index)+1
print('단어 집합의 크기 : %d' % vocab_size)

- 출력
단어 집합의 크기 : 12
- 각 단어와 단어에 부여된 정수 인덱스 출력

print(tokenizer.word_index)

- 출력
{'말이': 1, '경마장에': 2, '있는': 3, '뛰고': 4, '있다': 5, '그의': 6, '법이다': 7, '가는': 8, '고와야': 9, '오는': 10, '곱다': 11}

- 훈련 데이터 만들기

sequences = list()
for line in text.split('\n'):  # 줄 바꿈 문자를 기준으로 문장 토큰화
   encoded = tokenizer.texts_to_sequences([line])[0]
   for i n range(1, len(encoded)):
      sequence = encoded[:i+1]
      sequences.append(sequence)
print('학습에 사용할 샘플의 개수 : %d' % len(sequences))

- 출력:
학습에 사용할 샘플의 개수: 11

- 샘플의 개수는 총 11개가 나옴

print(sequences)

[[2, 3], [2, 3, 1], [2, 3, 1, 4], [2, 3, 1, 4, 5], [6, 1], [6, 1, 7], [8, 1], [8, 1, 9], [8, 1, 9, 10], [8, 1, 9, 10, 1], [8, 1, 9, 10, 1, 11]]

- [2,3]은 [경마장에, 있는]에 해당되며 [2,3,1]은 [경마장에, 있는, 말이]에 해당 => 맨 우측 단어를 레이블로 분리해야 함.
- 우선 전체 샘플에 대해 길이를 일치시키기. 가장 긴 샘플 길이인 6을 기준으로.

max_len = max(len(1) for l in sequences) # 모든 샘플에서 길이가 가장 긴 샘플의 길이 출력
print('샘플의 최대 길이 : {}'.format(max_len))

- 출력:
샘플의 최대 길이 : 6

- 전체 샘플의 길이를 6으로 패딩. 'pre'로 padding함으로써 6보다 짧은 샘플의 앞을 0으로 채우기

sequences = pad_sequences(sequences, maxlen=max_len, padding ='pre')
print(sequences)

- 출력:
[[ 0  0  0  0  2  3]
[ 0  0  0  2  3  1]
[ 0  0  2  3  1  4]
[ 0  2  3  1  4  5]
[ 0  0  0  0  6  1]
[ 0  0  0  6  1  7]
[ 0  0  0  0  8  1]
[ 0  0  0  8  1  9]
[ 0  0  8  1  9 10]
[ 0  8  1  9 10  1]
[ 8  1  9 10  1 11]]

- 이제 각 샘플의 마지막 단어를 레이블로 분리.

sequences = np.array(sequences)
X = sequences[:, :-1]
y = sequences[:, -1]
print(X)

- 출력:
[[ 0  0  0  0  2]
[ 0  0  0  2  3]
[ 0  0  2  3  1]
[ 0  2  3  1  4]
[ 0  0  0  0  6]
[ 0  0  0  6  1]
[ 0  0  0  0  8]
[ 0  0  0  8  1]
[ 0  0  8  1  9]
[ 0  8  1  9 10]
[ 8  1  9 10  1]]

print(y)

- 출력:
[ 3 1 4 5 1 7 1 9 10 1 11]

- 훈련 전 레이블에 대해서 원-핫 인코딩 수행

y = to_categorical(y, num_classes = vocab_size)
print(y)

[[0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0.] # 3에 대한 원-핫 벡터
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0.] # 4에 대한 원-핫 벡터
[0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.] # 5에 대한 원-핫 벡터
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터
[0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.] # 7에 대한 원-핫 벡터
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.] # 9에 대한 원-핫 벡터
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.] # 10에 대한 원-핫 벡터
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] # 1에 대한 원-핫 벡터
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]] # 11에 대한 원-핫 벡터

2) 모델 설계하기

- 하이퍼 파라미터인 임베딩 벡터의 차원은 10, 은닉 상태의 크기는 32. 다 대 일 구조의 RNN을 사용. 전결합층을 출력층으로 단어 집합 크기만큼의 뉴런을 배치하여 모델을 설계.
- 해당 모델은 마지막 시점에서 모든 가능한 단어 중 하나의 단어를 예측하는 다중 클래스 분류 문제를 수행하는 모델 => 출력층에 소프트맥스 회귀를 사용해야 하므로 활성화 함수로 소프트맥스 함수, 손실 함수로 크로스 엔트로피 함수를 사용하여 200에포크 수행

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dense, SimpleRNN

embdding_dim = 10
hidden_units = 32
model = Sequential()
model.add(Embedding(vocab_size, embedding_dim))
model.add(SimpleRNN(hidden_units))
model.add(Dense(vocab_Size, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer = 'adam', merics= ['accuracy'])
model.fit(X, y, epochs = 200, verbose=2)

- 문장을 정확하게 예측하고 있는지 문장을 생성하는 함수를 만들어서 출력해보자

def sentence_generation(modek, tokenizer, current_word, n) : # 모델, 토크나이저, 현재 단어, 반복활 횟수
   init_word = current_word
   sentence = ''
   # n번 반복
   for _ in range(n) :
      #현재 단어에 대한 정수 인코딩과 패딩
      encoded = tokinizer.texts_to_sequences({current_word])[0]
      encoded = pad_sequences({encoded], maxlen=5, padding = 'pre')
      # 입력한 x(현재 단어)에 대해서 Y를 예측하고 Y(예측한 단어)를 result에 저장
      result = model.predict(Encoded, verbose = 0
      result = np.argmax(result, axis = 1)
   
      for =word, index in tokenizer.word_index.items() :
         # 만약 예측한 단어와 인덱스와 동일한 단어가 있다면 break
         if index == result :
            break
      # 현재 단어 _ ' ' +예측 단어를 현재 단어로 변경
      current_word = current_word + ' ' + word
   
      # 예측 단어를 문장에 저장
      sentence = sentence + ' ' + word
   sentence = init_word+sentence
   return sentence

- 입력된 단어로부터 다음 단어를 예측해서 문장을 생성하는 함수를 만들었다. '경마장에'라는 단어 뒤에는 총 4개의 단어가 있으므로 4번 예측해봅시다.

print(sentence_generation(mode, tokenizer, '경마장에', 4))

- 출력:
경마장에 있는 말이 뛰고 있다

print(sentence_generation(model, tokenizer, '그의', 2))

- 출력:
그의 말이 법이다

print(sentence_generation(model, tokenizer, '가는', 5))

- 출력:
가는 말이 고와야 오는 말이 곱다

2. LSTM을 이용한 텍스트 생성하기

1) 데이터에 대한 이해와 전처리

- 사용할 데이터 : 뉴욕 타임즈 기사의 제목

import pandas as pd
improt numpy as np
from string import punctuation
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.utils import to_categorical

df = pd.read_csv('ArticlesApril2018.csv')
print('열의 개수: ', len(df.columns))
print(df.columns)

- 출력:
열의 개수:  15
Index(['articleID', 'articleWordCount', 'byline', 'documentType', 'headline',
       'keywords', 'multimedia', 'newDesk', 'printPage', 'pubDate',
       'sectionName', 'snippet', 'source', 'typeOfMaterial', 'webURL'], dtype='object')

- 총 15개의 열이 있음. 여기서 사용할 열은 headline 열. 결측이 있는지 확인

print(df['headline'].isnull().values.any())

- 출력:
False

headline = []
headline.extend(list(Df.headline.values))
headline[:5]

- 출력:
['Former N.F.L. Cheerleaders’ Settlement Offer: $1 and a Meeting With Goodell',
'E.P.A. to Unveil a New Rule. Its Effect: Less Science in Policymaking.',
'The New Noma, Explained',
'Unknown',
'Unknown']

- 네번째와 다섯 번째 샘플에 Unknown 값이 들어가 있음. Null은 아니지만 실습에 도움이 되지 않는 노이즈 데이터이므로 제거해줄 필요가 있음.

headline = [word for word in headline if word != "Unknown"]

- 이제 데이터 전처리 중 구두점 제거와 단어의 소문자화를 수행하자

def repreprocessing(rasw_sentence) :
   prtprocessed_sentence = rasw_sentence.encode("utf8"),decode("ascii", 'ignore')
   # 구두점 제거와 동시에 소문자화
   return ' '.join(word for word in preprocessed_sentence if word in punctuation.lower()

preprocessed_headline = [repreprocessing(x) for x in headline]
preprocessed_headline[:5]

- 출력:
['former nfl cheerleaders settlement offer 1 and a meeting with goodell',
'epa to unveil a new rule its effect less science in policymaking',
'the new noma explained',
'how a bag of texas dirt became a times tradition',
'is school a place for selfexpression']

- 이제 단어집합(vocabulary)을 만들고 크기 확인

tokenizer = Tokenizer()
tokenizer.fit_on_texts(preprocessed_headline)
vocab_size = len(tokenizer.word_index) + 1)
print('단어 집합의 크기 : %d' % vocab_size)

- 출력:
단어 집합의 크기 : 3494

# 총 3494개 단어 존재. 정수 인코딩과 동시에 하나의 문장을 여러 줄로 분해하여 훈련데이터를 구성.
sequences = list()
for sentence in preprocessed_headline:
   # 각 샘플에 대한 정수 인코딩
   encoded = tokenizer.texts_to_sequences([sentence])[0]
   for i in range(1, len(Encoed):
      sequence = encoded[:i+1]
      sequences.append(sequence)
sequences[:11]

- 출력:
[[99, 269], # former nfl
[99, 269, 371], # former nfl cheerleaders
[99, 269, 371, 1115], # former nfl cheerleaders settlement
[99, 269, 371, 1115, 582], # former nfl cheerleaders settlement offer
[99, 269, 371, 1115, 582, 52], # 'former nfl cheerleaders settlement offer 1
[99, 269, 371, 1115, 582, 52, 7], # former nfl cheerleaders settlement offer 1 and
[99, 269, 371, 1115, 582, 52, 7, 2], # ... 이하 생략 ...
[99, 269, 371, 1115, 582, 52, 7, 2, 372],
[99, 269, 371, 1115, 582, 52, 7, 2, 372, 10],
[99, 269, 371, 1115, 582, 52, 7, 2, 372, 10, 1116], # 모든 단어가 사용된 완전한 첫번째 문장
# 바로 위의 줄은 : former nfl cheerleaders settlement offer 1 and a meeting with goodell
[100, 3]] # epa to에 해당되며 두번째 문장이 시작됨.

- 어떤 정수가 어떤 단어를 의미하는지 알아보기 위해 인덱스로부터 단어를 찾는 index_to_word를 만들기

index_to_word = {}
for key, value in tokenizer.word_index.items() # 인덱스를 단어로 바꾸기 위해 index_to_word를 생성
   index_to_Word[value] = key
print('빈도수 상위 582번 단어 : {}'.ormat(index_to_word[582]))

- 출력:
빈도수 상위 582번 단어 : offer

- 이제 전체 샘플의 길이를 동일하게 만드는 패딩 작업 수행.

max_len = max(len(1) for l in sequences)
print('샘플의 최대 길이 : {}'format(max_len))

- 출력:
샘플의 최대 길이 : 24

sequences = pad_sequences(sequences, maxlen = max_len, padding= 'pre')

sequences = np.array(sequences)
X = sequences [:, :-1]
y = sequences[:,-1]
# 레이블 데이터 y에 대해서 원-핫 인코딩 수행
y = to_Categorical(y, num_classes=vocab_size)

2) 모델 설계하기

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dense, LSTM

- 벡터의 차원은 10, 은닉 상태의 크기는 128, 다 대 일 구조의 LSTM을 사용. 전결합층을 출력층으로 단어 집합 크기만큼의 뉴런을 배치하여 모델을 설계, 출력층 활성화 함수 소프트맥스 함수, 손실함수 크로스 엔트로피 함수 사용.

embedding_dim = 10
hidden_units = 128

model = Sequential()
model.add(Embedding(vocab_size, embeddinf_dim))
model.add(LSTM(hidden_units))
model.add(Dense(vocab_Size, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
model.fit(X, y,epochs = 200, verbose = 2)

def sentence_generation(model, tokenizer, current_word, n): # 모델, 토크나이저, 현재 단어, 반복할 횟수
    init_word = current_word
    sentence = ''

    # n번 반복
    for _ in range(n):
        encoded = tokenizer.texts_to_sequences([current_word])[0]
        encoded = pad_sequences([encoded], maxlen=max_len-1, padding='pre')

        # 입력한 X(현재 단어)에 대해서 y를 예측하고 y(예측한 단어)를 result에 저장.
        result = model.predict(encoded, verbose=0)
        result = np.argmax(result, axis=1)

        for word, index in tokenizer.word_index.items(): 
            # 만약 예측한 단어와 인덱스와 동일한 단어가 있다면
            if index == result:
                break

        # 현재 단어 + ' ' + 예측 단어를 현재 단어로 변경
        current_word = current_word + ' '  + word

        # 예측 단어를 문장에 저장
        sentence = sentence + ' ' + word

    sentence = init_word + sentence
    return sentence

- 임의의 단어 'i'에 대해서 10개의 단어를 추가 생성해보자

print(sentence_generatino(model, tokenizer, 'i', 10))

- 출력:
i disapprove of school vouchers can i still apply for them

- 임의의 단어 'how'에 대해서 10개의 단어를 추가 생성 해보자

print(sentence_generation(model, tokenizer, 'how', 10)))

-출력:
how to make facebook more accountable will so your neighbor chasing

08-07 문자 단위 RNN (Char RNN)

- 입출력의 단위를 단어 레벨(word_level) -> 문자 레벨(Character-level)로 변경하여 RNN 구현하기

1. 문자 단위 RNN 언어 모델 (Char RNNLM)

- 단어가 아닌 문자 단위를 사용하기 때문에 ㅇ미베딩층을 여기서는 사용하지 않고 훈련과정과 테스트 과정의 차이를 이해하는데 집중

1) 데이터에 대한 이해와 전처리

: 데이터를 로드, 특스문자 제거, 단어를 소문자화

import numpy as np
iomport urllib.request
from tensorflow.keras.utils import to_categorical

# 데이터 로드
urllib.request.urlretrieve("http://www.gutenberg.org/files/11/11-0.txt", filename="11-0.txt")

f  = open('11-0.txt', 'rb')
sentences = []
for sentence in f: # 데이터로부터 한 줄 씩 읽는다.
   sentence = sentence.strip() # strip()을 통해 \r, \n을 제거한다.
   sentence = sentence.lower() # 소문자화
   sentence = sentence.decode('ascii', 'ignore') # \xe2\x80\99 등과 같은 바이트 열 제거
   if len(sentence) > 0 :
      sentences.append(sentence)
f.close()

sentences[:5]

- 출력:
['the project gutenberg ebook of alices adventures in wonderland, by lewis carroll',
'this ebook is for the use of anyone anywhere in the united states and',
'most other parts of the world at no cost and with almost no restrictions',
'whatsoever. you may copy it, give it away or re-use it under the terms',
'of the project gutenberg license included with this ebook or online at']

- 아직 의미있게 문장 토큰화가 되진 않음. => 하나의 문자열로 통합

total_data = ' '.join(sentences)
print('문자열의 길이 또는 총 문자의 개수: %d' % len(total_data))

- 출력:
문자열의 길이 또는 총 문자의 개수: 159484

- 이 문자열로부터 문자 집합을 만들자.

char_vocab = sorted(list(set(Total_Data)))
vocab_size = len(char_vocab)
print('문자 집합의 크기 : {}'.format(vocab_size))

-출력:
문자 집합의 크기 : 56

- 영어가 훈련 데이터일 때 문자 집합의 크기는 단어 집합을 사용했을 경우보다 집합의 크기가 현저히 작음. (영어 단어를 표현하기 위해 사용되는 문자는 26개의 알파벳뿐이기 때문. -> 훈련 데이터가 대, 소문자 구분된 상태라고 하더라도 모든 영어 단어는 총 52개의 알파벳으로 표현가능)

#문자에 고유한 정수 부여
char_to_index = dict((char, index) for index, char in enumerate(char_vocab))
print('문자 집합 :', char_to_index)

- 출력 :
문자 집합 : {' ': 0, '!': 1, '"': 2, '#': 3, '$': 4, '%': 5, "'": 6, '(': 7, ')': 8, '*': 9, ',': 10, '-': 11, '.': 12, '/': 13, '0': 14, '1': 15, '2': 16, '3': 17, '4': 18, '5': 19, '6': 20, '7': 21, '8': 22, '9': 23, ':': 24, ';': 25, '?': 26, '[': 27, ']': 28, '_': 29, 'a': 30, 'b': 31, 'c': 32, 'd': 33, 'e': 34, 'f': 35, 'g': 36, 'h': 37, 'i': 38, 'j': 39, 'k': 40, 'l': 41, 'm': 42, 'n': 43, 'o': 44, 'p': 45, 'q': 46, 'r': 47, 's': 48, 't': 49, 'u': 50, 'v': 51, 'w': 52, 'x': 53, 'y': 54, 'z': 55}

#반대로 정수로부터 문자를 리턴하는 index_to_char
index_to_char = []
for key, value in char_to_index.items():
   index_to_char[value] = key

- 훈련 데이터 구성을 위한 간소화 된 예 : 훈련 데이터에 apple이라는 시퀀스가 있고 입력의 길이를 4라고 정했을 때, 입력의 길이가 4이므로 입력 시퀀스와 출력 시퀀스 모두 길이는 4가 됨. (총 네번의 시점을 가질 수 있다는 의미) => 입력은 'appl' 출력은 'pple'으로 데이터가 구성됨.

- 위의 예제는 문장의 길이를 60으로 정해서 해보자. => 샘플의 수는 2658개가 됨.
seq_length = 60

# 문자열의 길이를 seq_length로 나누면 전처리 후 생겨날 샘플 수
n_samples = int(np.floor((len(total_data) - 1) / seq_length))
print ('샘플의 수 : {}'.format(n_samples))

- 결과 :
샘플의 수 : 2658

- 전처리 코드:

train_X = []
train_y = []

for i in range(n_samples):
   # 0:60 -> 60:120 -> 120:!80로 loop를 돌면서 문장 샘플을 1개씩 pick
   X_sample = total_data[i * seq_length : (i+1) * seq_length]
   # 정수 인코딩
   X_encoded  = [char_to_index[c] for c in X_sample]
   train_X.append(X_encoded)
   # 오른쪽으로 1칸 쉬프트
   y_sample = total_data[i*seq_length + 1 : (i+1) * seq_length +1]
   y_encoded = [char_to_index[c] for c in y_sample]
   train_y.append(y_encoded)

- 원핫 인코딩 수행 (문자 단위 RNN은 입력 시퀀스에 대해서 워드 임베딩을 하지 않음 -> 임베딩층 사용 X -> 입력시퀀스인 train_X에 대해서도 원-핫 인코딩 수행)

train_X = to_categorical(train_X)
train_y = to_categorical(train_y)
print('train_X의 크기(shape) : {}'.format(train_X.shape)) # 원-핫 인코딩
print('train_y의 크기(shape) : {}'.format(train_y.shape)) # 원-핫 인코딩

- 출력:
train_X의 크기(shape) : (2658, 60, 56)
train_y의 크기(shape) : (2658, 60, 56)
- 이는 샘플의 수가 2,658개, 입력 시퀀스의 길이가 60, 각 벡터의 차원(input_dim)이 55임을 의미.
- 원-핫 벡터의 차원은 문자 집합의 크기인 56이어야 하므로 원-핫 인코딩이 수행되었음을 알 수 있음

2) 모델 설계하기

- 하이퍼파라미터인 은닉 상태의 크기는 256. 모델은 다 대 다 구조의 LSTM을 사용하며 LSTM 은닉층은 두 개를 사용.
- 전결합층을 출력층으로 문자 집합 크기만큼의 뉴런을 배치하여 모델을 설계
- 하나의 문자를 예측하는 다중 클래스 분류 문제이므로 활성화함수 소프트맥스 함수, 손실함수 크로스 엔트로피 함수 사용.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, TimeDistributed

hidden_units = 256
model = Sequential()
model.add(LSTM(hidden_units, input_shape(None, train_X.shape[2]], return_sequences = True))
model.add(LSTM(hidden_units, return_Sequences = True))
model.add(TimeDistributed(Dense(vocab_size, activation = 'softmax')))

model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
model.fit(train_X, train_y, epochs=80, verbose = 2)

# sentence_generation 함수 구현 : 특정 문자를 주면 다음 문자를 계속해서 생성해내는 함수
# 인자로 학습한 모델, 다음 문자를 생성할 횟수를 전달하면 다음 문자를 지속적으로 예측하여 문장을 생성
def sentence_generation(model, length):
   # 문자에 대한 랜덤한 정수 생성
   ix = [np.random.randint(vocab_size)]
   # 랜덤한 정수로부터 맵핑되는 문자 생성
   y_char = [index_to_char[ix[-1]]]
   print(ix[-1], '번 문자', y_char[-1],'로 예측을 시작!')
   # (1,length,55) 크기의 x 생성. 즉 LSTM의 입력 시퀀스 생성
   X = np.zeros((1, length, vocab_Size))

   for i in range(length) :
      # X[0][i][예측한 문자의 인덱스] = 1, 즉, 예측 문자를 다음 입력 시퀀스에 추가
      X[0][i][ix[-1]] = 1
      print(index_to_Char(ix[-1]], end="")
      ix = np.argmax(model.predict(X[:, :i+1,:])[0],1)
      y_char.append(index_to_Char[ix[-1]])
   return ('').join(y_char)
result = sentence_genreation(model, 100)
print(result)

-출력:
49 번 문자 u 로 예측을 시작!
ury-men would have done just as well. the twelve jurors were to say in that dide. he went on in a di'

2. 문자 단위 RNN (Char RNN)으로 텍스트 생성하기

: 이번에는 다 대 일 구조의 rNN을 문자 단위로 학습시키고 텍스트 생성

1) 데이터 이해와 전처리

import numpy as np
from tensorflow.keras.utils import to _categorical
raw_text = '''
I get on with life as a programmer,
I like to contemplate beer.
But when I start to daydream,
My mind turns straight to wine.

Do I love wine more than beer?

I like to use words about beer.
But when I stop my talking,
My mind turns straight to wine.

I hate bugs and errors.
But I just think back to wine,
And I'm happy once again.

I like to hang out with programming and deep learning.
But when left alone,
My mind turns straight to wine.
'''

# 단락 구분 없애기
tokens = raw_text.split()
raw_text = ' '.join(tokens)
print(raw_text)

- 출력:
I get on with life as a programmer, I like to contemplate beer. But when I start to daydream, My mind turns straight to wine. Do I love wine more than beer? I like to use words about beer. But when I stop my talking, My mind turns straight to wine. I hate bugs and errors. But I just think back to wine, And I'm happy once again. I like to hang out with programming and deep learning. But when left alone, My mind turns straight to wine.

# 중복을 제거한 문자 집합 생성
char_vocab = sorted(list(set(raw_text)))
vocab_size = len(Char_vocab)
print('문자 집합 :', char_vocab)
print('문자 집합의 쿠기 : {}'.format(vocab_size))

- 출력:
문자 집합 : [' ', "'", ',', '.', '?', 'A', 'B', 'D', 'I', 'M', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'r', 's', 't', 'u', 'v', 'w', 'y']
문자 집합의 크기 : 33

char_to_index = dict((char, index) for index, char in enumerate(char_vocab)) # 문자에 고유한 정수 인덱스 부여

- 이번 실습은 대소문자 구분하고 구두점과 공백을 포함.
- 예시. 입력 시퀀스의 길이를 5라고 하고(RNN의 시점timesteps이 5), 훈련 데이터에 student라는 단어가 있다면, 입력 시퀀스와 예측해야 하는 문자는 다음과 같이 구성
stude -> n
tuden -> t

- 이번 예제는 입력 시퀀스의 길이를 10으로 구성 (아래 코드는 예측 대상문자까지 해서 길이를 11로 함)

length = 11
sequences = []
for i in range(length, len(raw_text)):
   seq = raw_text[i-length:i] # 길이 11의 문자열을 지속적으로 만든다.
   sequences.append(seq)
print(;총 훈련 샘플의 수 : %d' % len(sequences))

- 출력:
총 훈련 샘플의 수: 426

# 정수 인코딩
encoded_sequences = []
for sequence in sequences: ㄸ 전체 데이터에서 문장 샘플을 1개씩 꺼낸다.
   encoded_sequence = [char_to_index[char] for char in sequence] # 문장 샘플에서 각 문자에 대해서 정수 인코딩 수행
   encoded_sequences.append(encoded_sequence)

#  예측 대상 문자 분리
encoded_sequences = np.array(encoded_sequences)
# 맨 마지막 위치의 문자를 분리
X_data = encoded_sequences[:, :-1]
# 맨 마지막 위치의 문자를 저장
y_data = encoded_sequences[:, -1]

#원-핫 인코딩
X_data_one_hot = [to_categorical(encoded, num_classes=voab_size) for encoded in X_data]
X_data_one_hot = np.array(X_data_one_hot)
y_data_one_hot = to_categorical(y_data, num_classes=vocab_size)
print(X_data_one_hot.shape)

- 출력:
(426, 10, 33)

- 샘플의 수(No. of samples)가 426개, 입력 시퀀스의 길이(input_length)가 10, 각 벡터의 차원(input_dim)이 33임을 의미

2) 모델 설계하기

- 하이퍼파라미터인 은닉 상태의 크기는 64. 활성화함수 소프트맥스, 손실함수로 크로스 엔트로피 함수

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM
from tensorflow.keras.preprocessing.sequence import pad_sequences

hidden_units = 64

model = Sequential()
model.add(LSTM(hidden_units, input_shape=(X_data_one_hot.shape[1], X_data_one_hot.shape[2])))
model.add(Dense(vocab_size, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X_data_one_hot, y_data_one_hot, epochs=100, verbose=2)

def sentence_generation(model, char_to_index, seq_length, seed_text, n):

    # 초기 시퀀스
    init_text = seed_text
    sentence = ''

    # 다음 문자 예측은 총 n번만 반복.
    for _ in range(n):
        encoded = [char_to_index[char] for char in seed_text] # 현재 시퀀스에 대한 정수 인코딩
        encoded = pad_sequences([encoded], maxlen=seq_length, padding='pre') # 데이터에 대한 패딩
        encoded = to_categorical(encoded, num_classes=len(char_to_index))

        # 입력한 X(현재 시퀀스)에 대해서 y를 예측하고 y(예측한 문자)를 result에 저장.
        result = model.predict(encoded, verbose=0)
        result = np.argmax(result, axis=1)

        for char, index in char_to_index.items():
            if index == result:
                break

        # 현재 시퀀스 + 예측 문자를 현재 시퀀스로 변경
        seed_text = seed_text + char

        # 예측 문자를 문장에 저장
        sentence = sentence + char

    # n번의 다음 문자 예측이 끝나면 최종 완성된 문장을 리턴.
    sentence = init_text + sentence
    return sentence

print(sentence_generation(model, char_to_index, 10, 'I get on w', 80))

- 출력:
I get on with life as a programmer, I like to hang out with programming and deep learning.

다음은 10장으로 넘어가야지..!

[딥러닝을 이용한 자연어 처리 입문] Chapter 8. 순환 신경망 (Recurrent Neural Network) (1)

빈이즈 — Tue, 1 Apr 2025 11:00:36 +0900

https://wikidocs.net/48558

08. 순환 신경망(Recurrent Neural Network)

wikidocs.net

08. 순환 신경망(Recurrent Neural Network)

- 피드 포워드 신경망은 입력의 길이가 고정되어 있어 자연어 처리를 위한 신경망으로는 한계가 있음 => 다양한 길이의 입력 시퀀스를 처리할 수 있는 인공신경망이 필요. => 대표적인 인공 신경망이 바로 순환 신경망(REcurrent Neural Network, RNN)
- 바닐라 RNN, 이를 개선한 LSTM, GRU에 대해 학습해볼 예정.

08-01 순환 신경망 (Recurrent Neural Network, RNN)

- 입력과 출력을 시퀀스 단위로 처리하는 시퀀스 모델.

1. 순환 신경망(Recurrent Neural Network, RNN)

- 은닉층의 노드에서 활성화 함수를 통해 나온 결과값을 출력층 방향으로도 보내면서, 다시 은닉층 노드의 다음 계산의 입력으로 보내는 특징을 가짐.
- RNN에서 은닉층에서 활성화 함수를 통해 결과를 내보내는 역할을 하는 노드를 셀(cell)이라 함. 이 셀은 이전의 값을 기억하려고 하는 일종의 메모리 역할을 수행하므로 이를 메모리 셀 또는 RNN 셀이라고 표현.
- 은닉층의 메모리 셀은 각각의 시점(time step)에서 바로 이전 시점에서의 은닉층의 메모리 셀에서 나온 값을 자신의 입력으로 사용하는 재귀적 활동을 함.
- 현재시점을 t라고 하면, 메모리 셀이 출력층 방향 또는 다음 시점인 t+1의 자신에게 보내는 값을 은닉 상태(hidden state)라고 함.
- 피드 포워드 신경망에서는 뉴런이라는 단어를 사용했지만 RNN에서 뉴런보다는 입력층과 출력층에서는 각각 입력벡터와 출력벡터, 은닉층에서는 은닉 상태라는 표현을 주로 사용함.

- RNN은 입력과 출력의 길이를 다르게 설계할 수 있음. RNN 셀의 각 시점의 입,출력의 단위는 사용자가 정의하기 나름이지만 가장 보편적인 단위는 '단어 벡터'.

예를 들어 하나의 입력에 대해서 여러 개의 출력을 의미하는 일 대 다 (one-to-many) 구조의 모델은 하나의 이미지 입력에 대해서 사진의 제목을 출력하는 이미지 캡셔닝(Image Captioning) 작업에 사용할 수 있음. 사진의 제목은 단어들의 나열이므로 시퀀스 출력임.

- 또한 단어 시퀀스에 대해서 하나의 출력을 하는 다 대 일 (many-to-one) 구조의 모델은 입력 문서가 긍정적인지 부정적인지 판별하는 감성 분류(sentiment classification), 또는 메일이 정상 메일인지 스팸 메일인지 판별하는 스팸 메일 분류 (spam detection) 등에 사용할 수 있음.

- 다 대 다 (many-to-many) 구조의 모델의 경우에는 사용자가 문장을 입력하면 대답 문장을 출력하는 챗봇과 입력 문장으로부터 번역된 문장을 출력하는 번역기, 또는 '태깅 작업' 챕터에서 배우는 개체명 인식이나 품사 태깅과 같은 작업에 속함.

- 현재 시점 t에서의 은닉 상태값을 ht라고 정의. 은닉층의 메모리 셀은 ht 계산을 위해 총 두 개의 가중치를 가짐. 하나는 입력층을 위한 가중치 Wx이고, 하나는 이전 시점 t-1의 은닉상태값인 ht-1을 위한 가중치 Wh임.

- 식으로 표현하면 다음과 같음
- ht를 계산하기 위한 활성화 함수로는 주로 하이퍼볼릭탄젠트 함수(tanh)가 사용됨.

2. 케라스(Keras)로 RNN 구현하기

- 코드:

from tensorflow.keras.layers import SimpleRNN
model.add(SimpleRNN(hidden_units))
# 추가 인자를 사용할 때
model.add(SimpleRNN(hidden_units, input_shape=(timesteps, input_dim)))
# 다른 표기
model.add(SimpleRNN(hidden_units, input_length=M, input_dim=N))

- hidden_units = 은닉 상태의 크기를 정의. 메모리 셀이 다음 시점의 메모리 셀과 출력층으로 보내는 값의 크기(output_dim)와도 동일. RNN의 용량을 늘린다고 보면 되며, 중소형 모델의 경우 보통 128,256,512,1024 등의 값을 가짐
- timesteps = 입력 시퀀스의길이 (input_length)라고 표현하기도 함. 시점의 수
- input_dim = 입력의 크기
- RNN층은 (batch_size, timesteps, input_dim) 크기의 3D 텐서를 입력으로 받음. batch_size는 한 번에 학습하는 데이터의 개수를 말함.
- RNN 층은 사용자의 설정에 따라 두 가지 종류의 출력을 내보냄. 메모리 셀의 최종 시점의 은닉 상태만을 리턴하고자 한다면 (batch_size, output_dim) 크기의 2D 텐서를 리턴. 하지만 메모리 셀의 각 시점(time step)의 은닉 상태값들을 모아서 전체 시퀀스를 리턴하고자 한다면 (batch_size, timesteps, output_dim) 크기의 3D 텐더를 리턴 => 이는 RNN 층의 return_Sequences 매개변수에 True를 입력하면 설정 가능. output_dime은 앞서 코드에서 정의한 hidden_units의 값으로 설정.
-모델 내부적으로 출력 결과를 어떻게 정의하는지 코드 확인:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimplrRNN
model = Sequential()
model.add(SimpleRNN(3, input_shape(2,10)))
# model.add(SimpleRNN(3, input_length=2, input_dim=10))와 동일
model.summary()

- 출력 :
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
simple_rnn_1 (SimpleRNN) (None, 3) 42
=================================================================
Total params: 42
Trainable params: 42
Non-trainable params: 0
_________________________________________________________________

- 출력값이 (batch_size, output_dim)의 크기의 2D 텐서일때, output_dim은 hidden_units의 값인 3이 됨. 이 경우 batch_size를 현 단계에서 알 수 없으므로 (None, 3)이 됨.
-이번에는 batch_size를 미리 정의해보자

model = Sequential()
model.add(SimplrRNN(3, batch_input_shape=(8,2,10)))
model.summary()

- 출력:
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
simple_rnn_2 (SimpleRNN) (8, 3) 42
=================================================================
Total params: 42
Trainable params: 42
Non-trainable params: 0
_________________________________________________________________

- batch_size를 8로 기재하면 출력의 크기가 (8,3)이 됨.
- 이번에는 return_sequences 매개변수에 True를 기재하여 출력값으로 (batch_size, timesteps, output_dim) 크기의 3D 텐서를 리턴하도록 만들어 보자.
- 코드:

model = sequential()
model.add(SimpleRNN(3, batch_input_shape=(8,2,10), return_sequences = True))

_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
simple_rnn_3 (SimpleRNN) (8, 2, 3) 42
=================================================================
Total params: 42
Trainable params: 42
Non-trainable params: 0
_________________________________________________________________
- 출력의 크기가 (8,2,3)이 됨.

3. 파이썬으로 RNN 구현하기

- numpy로 RNN 층 구현하기
ht = tanh(WxXt + Whht-1+b)

- t 시점의 은닉상태 = hidden_state_t, 입력데이터의 길이 = input_length (=시점의 수 timesteps), t시점의 입력값 = input_t라고 선언.

- 각 메모리 셀은 각 시점마다 input_t와 hidden_state_t(이전 상태의 은닉 상태)를 입력으로 활성화 함수인 하이퍼볼릭탄젠트 함수를 통해 현 시점의 hidden_state_t를 계산
- 아래 코드는 이해를 돕기 위해 (timesteps, input_dim) 크기의 2D 텐서를 입력으로 받았다고 가정했으나, 실제로 케라스에서는 (batch_size, timesteps, input_dim)의 크기의 3D 텐서를 입력으로 받는 것을 기억하자
- timestpes는 시점의 수 => 자연어 처리에서는 보통 문장의 길이.
- input_dim은 입력의 차원 => 자연어처리에서는 보통 단어 벡터의 차원
- hidden_units는 은닉 상태의 크기로 메모리 셀의 용량. 초기 은닉 상태는 0의 값을 가지는 벡터로 초기화함
- 코드 :

import numpy as np
timesteps = 10
input_dim = 4
hidden_units = 8
#입력에 해당되는 2D 텐서
inputs = np.random.random((timesteps, input_dim))
# 초기 은닉 상태는 0(벡터)로 초기화
hidden_state_t = np.zeros((hidden_units,))
print('초기 은닉 상태 :', hidden_state_t)

- 출력:
초기 은닉 상태 : [0. 0. 0. 0. 0. 0. 0. 0.]

- 은닉 상태의 크기를 8로 정했으니, 8의 차원을 가지는 0의 값으로 구성된 벡터가 출력됨.
- 가중치와 편향을 각 크기에 맞게 정의하고 크기를 출력해보자

Wx = np.random.random((hidden_units, input_dim))  # (8,4) 크기의 2D 텐서 생성, 입력에 대한 가중치
Wh = np.random.random((hidden_units, hidden_units)) # (8,8) 크기의 2D 텐서 생성. 은닉 상태에 대한 가중치
b = np.random.random((hidden_units,)) # (8, ) 크기의 1D 텐서 생성. 이 값은 편향

- Wx는 (은닉 상태의 크기 X 입력의 차원), Wh는 (은닉 상태의 크기 X 은닉 상태의 크기), b는 (은닉 상태의 크기)의 크기를 가짐.
- RNN 층을 동작시켜보자

total_hidden_states = []
# 각 시점 별 입력값
   # Wx * Xt + Wh * Ht-1 + b(bias)
   output_t = np.tanh(np.dot(Wx, input_t) + np.dot(Wh, hidden_state_t) + b)
   # 각 시점 t별 메모리 셀의 출력의 크기는 (timestep t, output_dim)
   # 각 시점의 은닉 상태의 값을 계속해서 누적
   total_hidden_states.append(list(output_t))
   hidden_state_t = output_t
# 출력 시 값을 깔끔하게 해주는 용도
total_hiddne_states = np.stack(total_hidden_states, axis = 0)
# (timesteps, output_dim)
print('모든 시점의 은닉 상태 : ')
print(total_hidden_states)

- 출력:
모든 시점의 은닉 상태 :
[[0.85575076 0.71627213 0.87703694 0.83938496 0.81045543 0.86482715 0.76387233 0.60007514]
[0.99982366 0.99985897 0.99928638 0.99989791 0.99998252 0.99977656 0.99997677 0.9998397 ]
[0.99997583 0.99996057 0.99972541 0.99997993 0.99998684 0.99954936 0.99997638 0.99993143]
[0.99997782 0.99996494 0.99966651 0.99997989 0.99999115 0.99980087 0.99999107 0.9999622 ]
[0.99997231 0.99996091 0.99976218 0.99998483 0.9999955 0.99989239 0.99999339 0.99997324]
[0.99997082 0.99998754 0.99962158 0.99996278 0.99999331 0.99978731 0.99998831 0.99993414]
[0.99997427 0.99998367 0.99978331 0.99998173 0.99999579 0.99983689 0.99999058 0.99995531]
[0.99992591 0.99996115 0.99941212 0.99991593 0.999986 0.99966571 0.99995842 0.99987795]
[0.99997139 0.99997192 0.99960794 0.99996751 0.99998795 0.9996674 0.99998177 0.99993016]
[0.99997659 0.99998915 0.99985392 0.99998726 0.99999773 0.99988295 0.99999316 0.99996326]]

4. 깊은 순환 신경망(Deep Recurrent Neural Network)

- 은닉층이 2개 이상
- 은닉층을 2개 추가하는 경우 코드:

model = Sequential()
model.add(SimppeRNN(hidden_units, input_length=10 input_dim=5, return_sequences = True))
model.add(SimpleRNN(hidden_units, return_sequences = True))

- 첫번째 은닉층은 다음 은닉층이 존재하므로 return_sequences=True를 설정하여 모든 시점에 대해서 은닉 상태 값을 다음 은닉층으로 보내주고 있음

5. 양방향 순환 신경망(Bidirectional Recurrent Neural Network)

- 시점 t에서의 출려값을 예측할 때 이전 시점의 입력뿐만 아니라, 이후 시점의 입력 또한 예측에 기여할 수 있다는 아이디어에 기반함.
- ex. '운동을 열심히 하는 것은 [ ]을 늘리는 데 효과적이다'의 빈칸을 예측하기 위해 앞문장인 '운동을 열심히 하는 것은'만으로 빈칸을 예측하기는 어렵다.
- 기본적으로 두 개의 메모리 셀을 사용함. 첫번째 메모리 셀은 앞 시점의 은닉 상태(Forward States)를 전달받아 현재의 은닉 상태를 계산. 두번째 메모리 뒤 시점의 은닉 상태(Backward States)를 전달받아 현재의 은닉 상태를 계산.
- 코드:

from tensorflow.keras.layers import Bidireactinoal
timesteps = 10
input_dim = 5
model = Sequential()
model.add(Bidireactional(SimpleRNN(hidden_units, return_Sequences = True), input_shape=(timesteps, input_dim)))

- 양방향도 다수의 은닉층을 가질 수 있음

* 내가 생각한 개념 정리)
timesteps : 단어 개수
input_dim : 단어 길이
hidden_units : 은닉노드 (hidden units와 출력층의 차원이 같음)
batch_size : 데이터 개수

08-02 장단기 메모리 (Long Short-Term Memory, LSTM)

- 08-01에서 배운 RNN을 가장 단순한 형태의 RNN이라고 하여 바닐라 RNN이라고 함. (케라스에서 SimpleRNN)
- 바닐라 RNN의 한계를 극복하기 위해 다양한 RNN의 변형이 나옴 -> LSTM도 그 중 하나.

1. 바닐라 RNN의 한계

- 비교적 짧은 시퀀스(sequence)에 대해서만 효과를 보이는 단점이 있음. 바닐라 RNN의 시점이 길어질 수록 앞의 정보가 뒤로 충분히 전달되지 못하는 현상이 발생 => 장기 의존성 문제

2. 바닐라 RNN 내부 열어보기

- xt와 ht-1이라는 두 개의 입력이 각각의 가중치가 곱해져서 메모리 셀의 입력이 됨. 이를 하이퍼볼릭탄젠츠 함수의 입력으로 사용하고 이 값은 은닉층의 출력인 은닉 상태가 됨.

3. LSTM(Long Short-Term Memory)

- 은닉층의 메모리 셀에 입력 게이트, 망각 게이트, 출력 게이트를 추가하여 불필요한 기억을 지우고, 기억해야 할 것들을 정함 => 은닉 상태를 계산하는 식이 전통적인 RNN보다 조금 더 복잡해지고 셀 상태(cell state)라는 값을 추가함 => 긴 시퀀스의 입력을 처리하는데 탁월한 성능을 보임.
- 셀 상태 또한 이전에 배운 은닉 상태처럼 이전 시점의 셀 상태가 다음 시점의 셀 상태를 구하기 위한 입력으로서 사용됨. 은닉 상태의 값과 셀 상태의 값을 구하기 위해서 새로 추가된 3개의 게이트 사용 => 삭제 게이트, 입력 게이트, 출력 게이트. 게이트 모두 시그모이드 함수가 존재 => 0~1 사이의 값이 나오게 되는데 이 값들을 가지고 게이트를 조절.
- xt와 각 게이트에서 사용되는 네개의 가중치가 존재, ht-1과 각게이트에서 사용되는 4개의 가중치가 있고, 각 게이트에서 사용되는 4개의 편향이 있음.

(1) 입력 게이트

- 현재 정보를 기억하기 위한 게이트. 우선 현재 시점 t의 x값과 입력 게이트로 이어지는 가중치 Wx를 곱한 값과 이전 시점 t-1의 은닉 상태와 입력 게이트로 이어지는 가중치 Wh를 곱한 값을 더하여 시그모이드 함수를 지남 => 그 값을 i_t라고 함.
- 그리고 현재 시점 t의 x값과입력 게이트로 이어지는 가중치 Wxg를 곱한 값과 이전 시점 t-1의 은닉 상태가 입력 게이트로 이어지는 가중치 Whg를 곱한 값을 더하여 하이퍼볼릭탄젠트 함수를 지남 => 이를 gt라고 함.
- 시그모이드 함수를 지나 0과 1 사이의 값을 가지는 i_t와 하이퍼볼릭탄젠트 함수를 지나 -1과 1 사이의 값을 가지는 gt. 이 두 개의 값을 가지고 이번에 선택된 기억할 정보의 양을 정하게 됨.

(2) 삭제 게이트
- 기억을 삭제하기 위한 게이트.
- 현재 시점 t의 x값과 이전 시점 t-1의 은닉 상태가 시그모이드 함수를 지나게 되면서 0과 1 사이의 값이 나오는데, 이 값이 곧 삭제 과정을 거친 정보의 양.
- 0에 가까울 수록 정보가 많이 삭제된 것이고, 1에 가까울수록 정보를 온전히 기억한 것. 이를 가지고 셀 상태를 구하게 됨.

(3) 셀 상태
- 셀 상태 Ct를 구하는 방법을 알아보자. (삭제 게이트에서 일부 기억을 잃은 상태)
- 입력 게이트에서 구한 i_t, gt 두 개의 값에 대해서 원소별 곱을 진행. => 같은 크기의 두 행렬이 있을 때 같은 위치의 성분끼리 곱하는 것을 말함. 식으로는 ○ 이라고 표현. 이것이 이번에 선택된 기억할 값.
- 입력 게이트에서 선택된 기억을 삭제 게이트의 결과값과 더하기. 이 값을 현재 시점 t의 셀 상태라고 하며, 이 값은 다음 시점 t+1 시점의 LSTM 셀로 넘겨짐.
- 삭제 게이트의 출력값인 ft가 0이 되면, 이전 시점의 셀 상태의 값인 Ct-1은 현재 시점의 셀 상태의 값을 결정하기 위한 영향력이 0이 되면서, 오직 입력 게이트의 결과만이 현재 시점의 셀 상태의 값 Ct를 결정할 수 있음 => 삭제 게이트가 완전히 닫히고 입력 게이트를 연 상태를 의미.
- 입력 게이트의 i_t 값을 0이라고 한다면, 현재 시점의 셀 상태의 값 Ct는 오직 이전 시점의 셀 상태의 값 Ct-1의 값에만 의존 => 이는 입력 게이트를 완전히 닫고 삭제 게이트만을 연 상태를 의미.
- 결과적으로 삭제 게이트는 이전 시점의 입력을 얼마나 반영할지의 의미이고, 입력 게이트는 현재 시점의 입력을 얼마나 반영할지를 결정

(4) 출력 게이트와 은닉 상태
- 현재 시점의 t의 x값과 이전 시점 t-1의 은닉 상태가 시그모이드 함수를 지난 값.
- 해당 값은 현재 시점 t의 은닉 상태를 결정하는 일에 쓰임. 셀 상태의 값이 하이퍼볼릭탄젠트 함수를 지나 -1과 1 사이의 값이 되고, 해당 값은 출력 게이트 값과 연산되면서 , 값이 걸러지는 효과가 발생하여 은닉 상태가 됨. 은닉 상태의 값은 또한 출력층으로도 향함.

08-03 게이트 순환 유닛 (Gated Recurrent Unit, GRU)

- LSTM의 장기 의존성 문제에 대한 해결책을 유지하면서, 은닉 상태를 업데이트하는 계산을 줄임.
- 즉, GPU 성능은 LSTM과 유사하면서 복잡한 LSTM 구조를 간단화

1. GRU (Gated Recurrent Unit)

- 업데이트 게이트와 리셋 게이트 두 가지 게이트만 존재.
- LSTM과 비교하여 어떤 것이 성능이 낫다라고 단정지을 수 없지만, 경험적으로 데이터 양이 적을 때는 매개 변수의 양이 적은 GRU가 조금 더 낫고, 데이터 양이 더 많으면 LSTM이 더 낫다고도 함.

2. 케라스에서의 GRU

- 코드:

model.add(GRU(hidden_size, input_shape=(timesteps, input_dim)))

08-04 케라스의 SimpleRNN과 LSTM 이해하기

1. 임의의 입력 생성하기

- 코드:

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import SimpleRNN, LSTM, Bidirectional
# 임의의 입력 생성
train_X = [[0.1, 4.2, 1.5, 1.1, 2.8], [1.0, 3.1, 2.5, 0.7, 1.1], [0.3, 2.1, 1.5, 2.1, 0.1], [2.2, 1.4, 0.5, 0.9, 1.1]]
print(np.shape(train_X))

- 출력:
(4, 5)

- 벡터의 차원은 5이고, 문장의 길이가 4인 경우를 가정한 입력 => 4번의 시점(timesteps), 각 시점마다 5차원의 단어 벡터가 입력으로 사용
- RNN은 2D 텐서가 아니라 3D 텐서를 입력으로 받으므로 2D 텐서를 3D 텐서로 변경 => 배치 크기 1을 추가하기
- 코드 :

train_X = [[[0.1, 4.2, 1.5, 1.1, 2.8], [1.0, 3.1, 2.5, 0.7, 1.1], [0.3, 2.1, 1.5, 2.1, 0.1], [2.2, 1.4, 0.5, 0.9, 1.1]]]
train_X = np.array(train_X, dtype=np.float32)
print(train_X.shape)

- 출력:
(1, 4, 5)

- (batch_size, timesteps, input_dim)에 해당되는 (1,4,5)의 크기를 가지는 3D 텐서 생성. batch_size는 한 번에 rNN이 학습하는 데이터의 양을 의미하지만, 여기서는 샘플이 하나밖에 없으므로 batch_size는 1이다.

2. SimpleRNN 이해하기

- 대표적인 인자로 return_sequences와 return_state가 있음. 기본값은 둘 다 False. 은닉 상태의 크기를 3으로 지정한 출력값을 확인해보자
- 코드:

rnn = SimpleRNN(3)
# rnn = SimpleRNN(3, return_sequence=False, return_state = False)와 동일
hidden_state = rnn(train_X)
print('hidden state : {}, shape : {}'.format(hidden_state, hidden_state.shape))

- 출력:
hidden state : [[-0.866719 0.95010996 -0.99262357]], shape: (1, 3)

- (1,3) 크기의 텐서가 출력되는데, 이는 마지막 시점의 은닉 상태. 은닉 상태의 크기를 3으로 지정했음을 주목하자. return_sequences가 False인 경우에는 마지막 시점의 은닉 상태만 출력.
- return_sequences=True일때 코드:

rnn = SimpleRNN(3, return_sequences = True)
hidden_states = rnn(train_X)
print('hidden state : {}, shape {}'.format(hidden_state, hidden_state.shape))

- 출력 :
hidden states : [[[ 0.92948604 -0.9985648   0.98355013]
  [ 0.89172053 -0.9984244   0.191779  ]
  [ 0.6681082  -0.96070355  0.6493537 ]
  [ 0.95280755 -0.98054564  0.7224146 ]]], shape: (1, 4, 3)

- (1,4,3) 크기의 텐서가 출력됨. 입력 데이터는 (1,4,5) 크기를 가지는 3D 텐서였고, 그 중 4가 시점에 해당하는 값이므로 모든 시점에 대해서 은닉 상태의 값을 출력하여 (1,4,3) 크기의 텐서를 출력.
- return_state가 True일 경우에는 return_sequences에 상관없이 마지막 시점의 은닉 상태를 출력.
- 코드 :

rnn = SimpleRNN(3, return_sequences = True, return_state = True)
hidden_states, last_state = rnn(train_X)

print('hidden state : {}, shape : {}'.format(hidden_states, hidden_states.shape))
print('last hidden state : {}, shape : {}'.format(last_state, last_states.shape))

- 출력 :
hidden states : [[[ 0.29839835 -0.99608386  0.2994854 ]
  [ 0.9160876   0.01154806  0.86181474]
  [-0.20252597 -0.9270214   0.9696659 ]
  [-0.5144398  -0.5037417   0.96605766]]], shape: (1, 4, 3)
last hidden state : [[-0.5144398  -0.5037417   0.96605766]], shape: (1, 3)

- 첫번째 출력은 return_sequences = True로 인한 출력으로 모든 시점의 은닉 상태
- 두번째 출력은 return_state = True로 인한 출력으로 마지막 시점의 은닉 상태.
- 이번에는 return_sequences가 False, return_state =True인 경우 코드 :

rnn = SimpleRNN(3, return_sequences = False, return_state = True)
hidden_state, last_state = rnn(train_X)
print('hidden state : {}, shape : {}'.format(hidden_state, hidden_state.shape))
print('last hidden state : {}, shape: {}'.format(last_state, last_state.shape))

- 출력:
hidden state : [[0.07532981 0.97772664 0.97351676]], shape: (1, 3)
last hidden state : [[0.07532981 0.97772664 0.97351676]], shape: (1, 3)
- 두 개의 출력 모두 마지막 시점의 은닉 상태를 출력하게 됨

3. LSTM 이해하기

- 실제로 SimpleRNN이 사용되는 경우는 거의 없고, LSTM이나 GRU를 주로 사용. 그 중 LSTM을 사용할 경우를 보자.
- 코드 :

lstm = LSTM(3, return_sequences = False, return_state = True)
hidden_state, last_state, last_cell_state = lstm(train_X)

print('hidden state : {}, shape : {}'.format(hidden_state, hidden_state.shape))
print('last hidden state : {}, shape: {}'.format(last_state, last_state.shape))
print('last cell state : {}, shape : {}'.format(last_cell_state, last_cell_state.shape))

- 출력:
hidden state : [[-0.00263056  0.20051427 -0.22501363]], shape: (1, 3)
last hidden state : [[-0.00263056  0.20051427 -0.22501363]], shape: (1, 3)
last cell state : [[-0.04346419  0.44769213 -0.2644241 ]], shape: (1, 3)

- SimpleRNN과 달리 세 개의 결과를 반환. return_sequences가 False이므로 우선 첫번째 결과는 마지막 시점의 은닉 상태.
- SimpleRNN과 다른 점은 return_state를 True로 둔 경우에는 마지막 시점의 은닉 상태뿐만 아니라 셀 상태까지 반환한다는 점.
- return_sequences = True 코드:

lstm = LSTM(3, return_sequences=True, return_state=True)
hidden_states, last_hidden_state, last_cell_state = lstm(train_X)
print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape))
print('last hidden state : {}, shape: {}'.format(last_hidden_state, last_hidden_state.shape))
print('last cell state : {}, shape: {}'.format(last_cell_state, last_cell_state.shape))

- 출력:
hidden states : [[[ 0.1383949   0.01107763 -0.00315794]
  [ 0.0859854   0.03685492 -0.01836833]
  [-0.02512104  0.12305924 -0.0891041 ]
  [-0.27381724  0.05733536 -0.04240693]]], shape: (1, 4, 3)
last hidden state : [[-0.27381724  0.05733536 -0.04240693]], shape: (1, 3)
last cell state : [[-0.39230722  1.5474017  -0.6344505 ]], shape: (1, 3)
- 두번째 출력값은 마지막 은닉 상태, 세번째 출력값은 셀 상태인 것은 변함없지만, return_state=True이므로 첫번째 출력값은 모든 시점의 은닉 상태가 출력

4. Bidirectional(LSTM) 이해하기

- 양방향 LSTM의 출력값을 확인해보자. return_sequences가 True인 경우와 False인 경우에 대해서 은닉 상태의 값이 어떻게 바뀌는지 직접 비교하기 위해 이번에는 출력되는 은닉 상태의 값을 고정.
- 코드 :

k_init = tf.keras.initializers.Constant(value = 0.1)
b_init = tf.keras.initializers.Constant(value=0)
r_init = tf.keras.initializers.Constant(value = 0.1)

- return_sequences가 False이고, return_State가 True인 경우 코드 :

bilstm = Bidirectional(LSTM(3, return_sequences = False, return_state = True, kernel_initializer=k_init, 
                 bias_initializer = b_nit, recurrent_initializer = r_init)
hidden_states, forward_h, forward_c, backward_h, backward_c = bilstm(train_X)
print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape))
print('forward state : {}, shape: {}'.format(forward_h, forward_h.shape))
print('backward state : {}, shape: {}'.format(backward_h, backward_h.shape))

- 출력:
hidden states : [[0.6303139 0.6303139 0.6303139 0.70387346 0.70387346 0.70387346]], shape: (1, 6)
forward state : [[0.6303139 0.6303139 0.6303139]], shape: (1, 3)
backward state : [[0.70387346 0.70387346 0.70387346]], shape: (1, 3)

- return_state = True인 경우에는 정방향 LSTM의 은닉 상태와 셀 상태, 역방향 LSTM의 은닉 상태와 셀 상태 4가지를 반환하기 때문에 은닉상태까지 총 5가지의 값을 반환.
- 첫 번째 출력값의 크기가 (1,6)인 것에 주목해보자. 이는 return_sequences가 False인 경우 정방향 LSTM의 마지막 시점의 은닉 상태와 역방향 LSTM의 첫번째 시점의 은닉 상태가 연결된 채 반환되기 때문.
- return_state가 True인 경우에 반환한 은닉 상태의 값인 forward_h와 backward_h는 각각 정방향 LSTM의 마지막 시점의 은닉 상태와 역방향 LSTM의 첫번째 시점의 은닉 상태값. 이 두 값을 연결한 값이 hidden_states에 출력되는 값.

-정방향 LSTM의 마지막 시점의 은닉 상태값과 역방향 LSTM의 첫번째 은닉 상태값을 기억하자.
정방향 LSTM의 마지막 시점의 은닉 상태값 : [0.6303139 0.6303139 0.6303139]
역방향 LSTM의 첫번째 시점의 은닉 상태값 : [0.70387346 0.70387346 0.70387346]
- 현재 은닉 상태의 값을 고정시켜두었기 때문에 return_sequences를 True로 할 경우 출력이 어떻게 변하는지 비교가 가능함. 코드 :

bilstm = Bidirectional(LSTM(3, return_sequences=True, return_state=True, \
                            kernel_initializer=k_init, bias_initializer=b_init, recurrent_initializer=r_init))
hidden_states, forward_h, forward_c, backward_h, backward_c = bilstm(train_X)
print('hidden states : {}, shape: {}'.format(hidden_states, hidden_states.shape))
print('forward state : {}, shape: {}'.format(forward_h, forward_h.shape))
print('backward state : {}, shape: {}'.format(backward_h, backward_h.shape))

-출력:
hidden states : [[[0.3590648  0.3590648  0.3590648  0.70387346 0.70387346 0.70387346]
  [0.5511133  0.5511133  0.5511133  0.5886358  0.5886358  0.5886358 ]
  [0.5911575  0.5911575  0.5911575  0.39516988 0.39516988 0.39516988]
  [0.6303139  0.6303139  0.6303139  0.21942243 0.21942243 0.21942243]]], shape: (1, 4, 6)
forward state : [[0.6303139 0.6303139 0.6303139]], shape: (1, 3)
backward state : [[0.70387346 0.70387346 0.70387346]], shape: (1, 3)

- hidden states의 출력값에선는 이제 모든 시점의 은닉 상태가 출력됨. 역방향 LSTM의 첫번째 시점의 은닉상태는 더이상 정방향 LSTM의 마지막 시점의 은닉상태와 연결됨.

8장도 길어서 (2)편으로 이어서 써야 할듯..! 완벽히 이해되지는 않았지만 그래도 계속 하다보면 이해되지 않을까..

[딥러닝을 이용한 자연어 처리 입문] Chapter 7. 딥 러닝(Deep Learning) 개요 (2)

빈이즈 — Fri, 21 Mar 2025 16:46:53 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/22882

07. 딥 러닝(Deep Learning) 개요

딥 러닝(Deep Learning)은 머신 러닝(Machine Learning)의 특정한 한 분야로서 인공 신경망(Artificial Neural Network)의 층을 연속적으…

wikidocs.net

07. 딥러닝(Dep LEarning)의 개요

: 머신러닝(Machine Learning)의 특정한 한 분야로서 인공 신경망의 층을 연속적으로 깊게 쌓아올려 데이터를 학습하는 방식.

07-07 기울기 소실 (Gradieny Vanishing)과 폭주(Exploding)

- 깊은 인공 신경망을 학습하다보면 역전파 과정에서 입력층으로 갈수록 기울기가 점차적으로 작아지는 현상(=기울기 소실)이 발생할 수 있음
- 반대로 기울기가 점차 커지더니 가중치들이 비상식적으로 큰 값이 되면서 결국 발산되기도 함 (=기울기 폭주)

1. ReLU와 ReLU의 변형들

- 시그모이드 함수를 사용하면 입력의 절대값이 클 경우에 시그모이드 함수의 출력값이 0 또는 1에 수렴하면서 기울기가 0에 가까워짐. -> 역전파 과정에서 기울기가 점차 사라져서 입력층으로 갈수록 제대로 역전파가 되지 않는 기울기 소실 문제가 발생할 수 있음
- 기울기 소실을 완화하는 가장 간단한 방법은 은닉층의 활성화 함수로 시그모이드나 하이퍼볼릭탄젠트 함수 대신에 ReLU나 ReLU의 변형 함수와 같은 Leaky ReLU를 사용하는 것.
- 은닉층에서는 시그모이드 함수를 사용하지 말기
- Leaky ReLU를 사용하면 모든 입력값에 대해서 기울기가 0에 수렴하지 않아 죽은 ReLU 문제를 해결함.
- 은닉층에서는 ReLU나 Leaky ReLU와 같은 ReLU 함수의 변형들을 사용하기

2. 그래디언트 클리핑 (Gradient Clipping)

- 기울기 값을 자르는 것을 의미함. 기울기 폭주를 막기 위해 임계값을 넘지 않도록 값을 자름.
=> 임계치만큼 크기를 감소시킴. (RNN에서 유용함. 역전파 과정에서 시점을 역행하면서 기울기를 구하는데, 이때 기울기가 너무 커질 수 있기 떄문)

from tensorflow.keras import optimizers
Adam = optimizers.Adam(lr=0.0001, clipnorm=1.)

3. 가중치 초기화

: 가중치가 초기값에 따라 모델의 훈련 결과가 달라지기도 함.
=> 가중치 초기화를 적절히 해준다면 기울기 소실 문제를 완화시킬 수도 있음

> 세이비어 초기화 (Xavier Initialization)

- 2010년 세이비어 글로럿과 요슈아 벤지오는 가중치 초기화가 모델에 미치는 영향을 분석하여 새로운 초기화 방법을 제안 => 세이비어 초기화 또는 글로럿 초기화라고 함.
- 이 방법은 균등 분포 또는 정규 분포로 초기화할 때 두 가지 경우로 나뉘며, 이전 층의 뉴런 개수와 다음 층의 뉴런 개수를 가지고 식을 세움.
- 여러 층의 기울기 분산 사이에 균형을 맞춰서 특정 층이 너무 주목을 받거나 다른 층이 뒤쳐지는 것을 막음.
- 시그모이드 함수나 하이퍼볼릭 탄젠트 함수와 같은 S자 형태의 활성화 함수와 함께 사용할 때는 좋은 성능을 보이지만, ReLU 함께 사용할 경우 성능이 좋지 않음. => 그 경우 He 초기화 (He initialization)을 사용하는 것이 좋음

> He 초기화 (He initialization)

- 세이비어 초기화와 유사하게 정규 분포와 균등 분포 두 가지 경우로 나뉨. 다만, 다음 층의 뉴런의 수를 반영하지 않음.
(이전 층의 뉴런의 개수만 반영)
- 시그모이드 함수나 하이퍼볼릭탄젠트 함수를 사용할 경우에는 세이비어 초기화 방법이, ReLU 계열 함수를 사용할 경우에는 He 초기화 방법이 효율적. (ReLU + He 초기화 방법이 좀 더 보편적임)

4. 배치 정규화 (Batch Normalization)

: ReLU 계열의 함수와 He 초기화를 사용하는 것만으로도 어느 정도 기울기 소실과 폭주를 완화시킬 수 있지만, 또 다른 방법이 배치 정규화. 배치정규화는 인공 신경망의 각 층에 들어가는 입력을 평균과 분산으로 정규화하여 학습을 효율적으로 만듦

> 내부 공변량 변화 (Internal Covariate Shift)

- 학습 과정에서 층 별로 입력 데이터 분포가 달라지는 현상을 말함.
- 이전 층들의 학습에 의해 이전 층의 가중치 값이 바뀌게 되면, 현재 층에 전달되는 입력 데이터의 분포가 현재 층이 학습했던 시점의 분포와 차이가 발생
- (공변량 변화는 훈련 데이터와 테스트 데이터의 분포가 다른 경우를 의미)
- (내부 공변량 변화는 신경망 층 사이에서 발생하는 입력 데이터의 분포 변화를 의미)

> 배치 정규화 (Batch Normalization)

- 한 번에 들어오는 배치 단위로 정규화를 하는 것. 각 층에서 활성화 함수를 통과하기 전에 수행됨.
- 입력에 대해 평균을 0으로 만들고, 정규화를 함. 그리고 정규화 된 데이터에 대해서 스케일과 시프트를 수행.
- 학습 시 배치 단위의 평균과 분산들을 차례대로 받아 이동 평균과 이동 분산을 저장해놓았다가 테스트 할 때는 해당 배치의 평균과 분산을 구하지 않고 구해놓았던 평균과 분산으로 정규화
- (배치 정규화를 사용하면 시그모이드 함수나 하이퍼볼릭 탄젠트 함수를 사용하더라도 기울기 소실 문제가 크게 개선)
- (가중치 초기화에 훨씬 덜 민감해짐)
- (훨씬 큰 학습률을 사용할 수 있어 학습 속도 개선)
- (미니 배치마다 평균과 표준편차를 계산하여 사용하므로 과적합을 방지하는 효과도 냄. -> 드롭아웃과 비슷한 효과)
- (배치 정규화는 모델을 복잡하게 함. 계산이 필요해서 실행시간이 느려짐. => 서비스 속도 고려하여 꼭 필요한 작업인지 고민이 필요함)

> 배치 정규화의 한계

- 1) 미니 배치 크기에 의존적이다 : 너무 작은 배치 크기에서는 잘 동작하지 않을 수 있음.
- 2) RNN에 적용하기 어렵다 : RNN은 각 시점마다 다른 통계치를 가짐 => 배치 정규화를 적용하는 것이 어려움

> 층 정규화 (Layer Normalization)

- 배치 크기에 의존적이지 않으며 RNN에도 적용하는 것이 수월함
- 배치 정규화가 특성에 다른 평균과 분산을 구하여 정규화를 해주는 거라면, 층 정규화는 각각의 데이터 별로 평균과 표준편차를 구해 정규화를 수행하는 것

07-08 케라스(Keras) 훑어보기

1. 전처리(Preprocessing)

- Tokenizer() : 토큰화와 정수 인코딩을 위해 사용됨.
- (훈련 데이터로부터 단어 집합을 생성, 해당 단어 집합으로 임의의 문장을 정수 인코딩하는 코드)

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preporcessing.sequence import pad_sequences
tokenizer = Tokenizer()
train_text = "The earth is an awesome place live"
# 단어 집합 생성
tokenizer.fit_on_texts([train_text])
# 정수 인코딩
sub_text = "The earth is an great place live"
sequences = tokenizer.text_to_sequences([sub_text])[0]
print("정수 인코딩 : ",sequences)
print("단어 집합 : ",tokenizer.word_index)

(출력 결과 : )
정수 인코딩 : [1, 2, 3, 4, 6, 7]
단어 집합 : {'the': 1, 'earth': 2, 'is': 3, 'an': 4, 'awesome': 5, 'place': 6, 'live': 7}

- 출력 결과 great는 단어 집합(vocabulary)에 없으므로 출력되지 않음
-전체 훈련 데이터에서 각 샘플의 길이는 서로 다를 수 있고 각 문서 또는 각 문장은 단어의 수가 제각각임 => 모델의 입력으로 사용하려면 모든 샘플의 길이를 동일하게 맞추어야 할 때가 있음. => 패딩(Padding)
- 패딩은 보통 숫자 0을 넣어서 길이가 다른 샘플들의 길이를 맞춤. 케라스에서는 pad_Sequence()를 사용. 정한 길이보다 길이가 긴 샘플의 값을 일부 자르고, 정한 길이보다 길이가 짧은 샘플은 값을 0으로 채움
- 코드 예시: padding='pre' (앞에 0을 채움)/'post'(뒤에 0을 채움)

pad_sequences([[1,2,3], [3,4,5,6], [7,8]], maxlen=3, padding='pre')

- 출력 결과:
array([[1, 2, 3],
[4, 5, 6],
[0, 7, 8]], dtype=int32)

2. 워드 임베딩 (Word Embedding)

- 텍스트 내의 단어들을 밀집 벡터로 만드는 것.
- 원-핫 벡터는 대부분이 0의 값을 가지고, 단 하나의 1의 값을 가지는 벡터로, 차원이 대체적으로 크다는 성질을 가짐. 단어 집합의 크기 = 벡터의 크기. 단어 벡터 간의 유의미한 유사도를 구할 수 없다는 단점이 있음.
- 워드 임베딩으로부터 얻은 임베딩 벡터는 상대적으로 저차원을 가지며 모든 원소의 값이 실수를 가짐.
- 원-핫 벡터의 차원이 주로 20,000 이상을 넘어가는 것과는 달리 임베딩 벡터는 주로 256, 512, 1024 등의 차원을 가짐.
- Enbedding() : 단어를 밀집 벡터로 만드는 역할을 함 = 임베딩 층을 만드는 역할. 정수 인코딩이 된 단어들을 입력으로 받아서 임베딩을 수행함
- embedding()은 (number of samples, input_length)인 2D 정수 텐서를 입력받고 워드 임베딩 작업을 수행하고 (number of samples, input_length, embedding word dimensionality)인 3D 텐서를 리턴함. 정수 인코딩이 완료된 sample을 입력으로 사용함
- embedding의 인자 : 1) 첫번째 인자 = 단어 집합의 크기 = 총 단어의 개수. 2) 두번째 인자= 임베딩 벡터의 출력 차원 = 결과로서 나오는 임베딩 벡터의 크기. 3) input_length = 입력 시퀀스의 길이

3. 모델링(Modeling)

- Sequential() : model로 선언한 뒤 model.add()라는 코드를 통해 층을 단계적으로 추가.
- Embedding()을 통해 생성하는 임베딩 층(Embedding layer)을 추가하는 예시 코드

model = Sequential()
model.add(Embedding(vacab_size, output_dim, input_length))

- 전결합층(fully-connected layer)을 추가하는 예시 코드

model = Sequential()
model.add(Dense(1, input_dim=3, activation= 'relu'))

- dense()는 한 번 사용되었지만 더 많은 층의 추가가 가능.

- Dens()의 대표 인자 : 1) 첫번째인자 = 출력 뉴런의 수. 2) input_dim = 입력 뉴런의 수. 3) activation = 활성화 함수 (linear : 디폴트. 별도 활성화함수 없음. sigmoid : 이진분류 주로 사용. softmax : 다중 클래스 분류문제에서 주로 사용, relu : 은닉층에서 주로 사용)

4. 컴파일(Compile)과 훈련(Training)

- compile() : 모델을 기계가 이해할 수 있도록 컴파일. 손실 함수와 옵티마이저, 메트릭 함수를 선택함
- RNN을 이용하여 이진 분류를 하는 예시 코드

from tensorflow.keras.layers import SimpleRNN, Embedding, Dense
from tensorflow.keras.models import Sequential
vocab_size = 10000
embedding_Dim = 32
hidden_units = 32

model = Sequential()
model.add(Embedding(vocab_size, embedding_dim))
model.add(SimpleRNN(hidden_units))
model.add(Dense(1,activation = 'sigmoid'))
model.compile(optimizer = 'rmsprop', loss= 'binary_crossentropy', metrics= ['acc'])

- optimizer = 훈련 과정을 설정하는 옵티마이저.
- loss = 훈련 과정에서 사용할 손실 함수 (loss function) 설정
- metrics = 훈련을 모니터링하기 위한 지표 선택
- 대표적으로 사용되는 손실 함수와 활성화함수의 조합
1) 회귀문제 : 손실함수(mean_squared_error)
2) 다중 클래스 분류 : 손실함수(categorical_crossentropy), 출력층 활성화함수(소프트맥스)
3) 다중 클래스 분류 : 손실함수(sparse_categorical_crossentropy), 출력층 활성화함수(소프트맥스)
* sparse_categorical_crossentropy : categorical_crossentropy와 동일하게 다중 클래스 분류에서 사용되지만, 레이블을 원-핫 인코딩하지 않고 정수 인코딩 된 상태에서 수행 가능하다는 점이 다름.
4) 이진분류 : 손실함수(binary_crossentropy), 출력층 활성화함수(시그모이드)

- fit() : 모델 학습.
- 예시 코드

model.fit(X_train, y_train, epochs=10, batch_size=32, verbose=0, validation_data(X_val, y_val))

- 첫번쨰인자 = 훈련데이터
- 두번째인자 = 지도학습에서 레이블 데이터
- epochs = 에포크. 에포크 1은 전체 데이터를 한 차례 훑고 지나간 것을 의미. 정수값 사용해야 함.
- batch_size = 배치 크기. 기본값은 32, 미니 배치 경사 하강법을 사용하고 싶지 않을 때 None으로 기재
- validation_data(x_val, y_val) = 검증 데이터. 검증 데이터의 오차가 낮아지다 높아지기 시작하면 이는 과적합의 신호
-예시 코드 2

model.fit(X_train, y_train, epochs=10, batch_size=32, verbose=0, validation_split=0.2))

- validation_split = validation_data와 동일하게 검증 데이터를 사용하기 위한 용도.
- verbose = 학습 중 출력되는 문구 설정 (0 : 아무것도 출력하지 않음, 1: 훈련의 진행도를 나타내는 진행 막대 표시 2 : 미니 배치마다 손실 정보를 출력)

5. 평가(Evaluatoin)와 예측{Prediction)

- evaluate() : 테스트 데이터를 통해 학습한 모델에 대한 정확도를 평가
- 코드 :

model.evaluate(X_test, y_test, batch_size = 32)

- 첫번째인자 = 테스트 데이터
- 두번째인자 = 레이블 테스트 데이터
- batch_size = 배치 크기
- predict() : 임의의 입력에 대한 모델의 출력값
- 코드

model.predict(X_input, batch_size = 32)

6. 모델의 저장(Save)와 로드(Load)

- 학습이 끝난 신경망의 구조를 보존하고 계속해서 사용할 수 있게 모델을 저장
- save() : 인공 신경망 모델을 hdf5파일에 저장

model.save("model_name.h5")

- load_model() : 저장해둔 모델을 불러오기

from tensorflow.keras.models import load_model
model = load_model("model_name.h5")

07-09 케라스의 함수형 API (Keras Functional API)

: 여러 층을 공유하거나 다양한 종류의 입력과 출력을 사용하는 등의 복잡한 모델을 만드는 일에 한계가 있는 Sequential API => 더욱 복잡한 모델을 생성할 수 있는 방식: Functional API

1. Sequential API로 만든 모델
- 직관적이고 편리하지만 단순히 층을 쌓는 것만으로는 구현할 수 없는 복잡한 신경망을 구현할 수 없음.

2. Functional API로 만든 모델
- 각 층을 일종의 함수(function)로서 정의함. 각 함수를 조합하기 위한 연산자들을 제공하는데, 이를 이용하여 신경망을 설계
- 입력의 크기 (shape)를 명시한 입력층(Input layer)을 모델의 앞단에 정의해주어야 함.

1) 전결합 피드 포워드 신경망 (Fully-connected FFNN)
- 입력데이터의 크기를 인자로 출력층을 정의해야 함.
- 코드: 10개의 입력을 받는 입력층

from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model
impurts = Input(Shape = (10,))
hidden1 = Dense(64, activation='relu')(inputs)
hidden2 = Dense(64, activation = 'relu')(hidden1)
output = Dense(1, activation = 'sigmoid')(hidden2)
model = Model(inputs = inputs, outputs = output)

- Input() 함수에 입력의 크기 정의
- 이전층을 다음층 함수의 입력으로 사용하고 변수에 할당
- Model() 함수에 입력과 출력을 정의
- sequential API와 마찬가지로 model.compile, model.fit 등이 사용 가능.

- 다른 코드 예시 : FFNN

inputs = Input(shape(10,))
x = Dense(8, activation="relu")(inputs)
x = Dense(4, activation = "relu")(x)
x = Dense(1, activation = "linear")(x)
model = Model (inputs, x)

2) 선형 회귀 (Linear Regression)
- sequential API로 구현했던 코드를 Functional API로 구현

from tensorflow.keras.layers import Input, Dense
from tensorflow.keras import optimizers
from tensorflow.keras.models import Model
x = [1,2,3,4,5,6,7,8,9]
y = [11,22,33,44,53,66,77,87,95]
inputs = Input(shape(1,))
output = Dense(1, activation = 'linear')(inputs)
linear_model = Model(inputs, output)
sgd = optimizers.SGD(lr=0.01)
linear_model.compile(optimizer=sgd, loss='mse', metrics=['mse'])
linera_model.fit(X,y, epochs = 300)

4) 다중 입력을 받는 모델 (model that accepts multiple inputs)
- 코드

from tensorflow.kears.layers import Inputm Dense, concatenate
from tensorflow.kears.models import Model

# 두 개의 입력층을 정의
inputA = Input(shape=(64,))
inputB = Input(Shape=(128,))

# 첫번째 입력층으로부터 분기되어 진행되는 인공 신경망을 정의
x = Dense(16, activation = "relu")(inputA)
x = Dense(8, activation = "relu")(x)
x = model(inputs = inputA, outputs = x)

# 두 번째 입력층으로부터 분기되어 진행되는 인공신경망을 정의
y = Dense(64, activation = "relu")(inputB)
y = Dense(32, activation = "relu")(y)
y = Dense(8, activation = "relu")(y)
y = Model(inputs=inputB, output = y)

# 두 개의 인공신경망의 출력을 연결 (concatenate)
result = concatenate([x.output, y.output])

z = Dense(2, activation ="relu")(result)
z = Dense(1, activation = "linera")(z)

model = Model(inputs = [x.input, y.input], output=z)

07-10 케라스 서브클래싱 API (Keras Subclassing API)

1. 서브클래싱 API 로 구현한 선형 회귀

- 코드 :

import tensorflow as tf

class LinearRegression(tf.keras.Model) :
   def f__init__(self) :
      super(LinearRegression, self).__init__()
      self.linear_layer = tf.keras.layers.Dense(1, input_dim = 1, activation = 'linear')
   def call(self, x) :
      y_pred = self.linear_layer(x)
      return y_pred

model = LinearRegression()
x = [1,2,3,4,5,6,7,8,9] 
y = [11,22,33,44,53,66,77,87,95]

sgd = tf.keras.optimizers.SGD(lr=0.01)
model.compile(optimizer = sgd, loss = 'mse', metrics = ['mse'])
model.fit(X, y, epochs = 300)

- 클래스(class) 형태의 모델은 tf.keras.Model을 상속받음. init()에서 모델의 구조와 동적을 정의하는 생성자를 정의. 파이썬에서 객체가 갖는 속성값을 초기화하는 역할로 객체가 생성될 때 자동으로 호출됨. super() 함수를 부르면 여기서 만든 클래스는 tf.keras.Model 클래스의 속성들을 가지고 초기화 됨. call() 함수는 모델이 데이터를 입력받아 예측 값을 리턴하는 포워드(forward) 연산을 진행시키는 함수.

2. 언제 서브클래싱 API를 써야 할 까?

- Sequential API : 간단한 모델을 구현하기에 적합
- Functional API : Sequential API로 구현할 수 없는 복잡한 모델들 구현 가능.
- Subclassing API : Functional API가 구현할 수 없는 모델들조차 구현할 수 있는 경우가 있음.
- Functional API는 기본적으로 딥러닝 모델을 DAG(directed acyclic graph)로 취급. 대부분의 딥러닝 모델이 이에 속하기는 하지만 항상 그런 것은 아님 (ex. 재귀 네트워크, 트리 RNN) => 그런 일부를 제외하고 대부분의 딥 러닝 모델은 Functional API 수준에서도 전부 구현 가능. => Subclassing API는 밑바닥부터 새로운 수준의 아키텍처를 구현해야 하는 실험적 연구를 하는 연구자들에게 적합함.

3. 세 가지 구현 방식 비교

1) Sequential API

- 장점 : 단순하게 층을 쌓는 방식으로 쉽고 간단.
- 단점 : 다수의 입력(multi-input), 다수의 출력(multi-output)을 가진 모델 또는 층 간의 연결(concatenate)이나 덧셈(Add)과 같은 연산을 하는 모델을 구현하기에는 적합하지 않음. => 이런 모델들의 구현은 Functional API를 사용해야 함.

2) Functional API
- 장점 : Seuquential API로는 구현하기 어려운 복잡한 모델들을 구현할 수 있음.
- 단점 : 입력의 크기(Shape)를 명시한 입력층(Input layer)을 모델의 앞단에 정의해주어야 함.
- 코드 예시 :

  inputs = Input(shape=(1,))

3) Subcalssing API
- 장점 : Functional API로도 구현할 수 없는 모델의 구현도 가능
- 단점 : 객체 지향 프로그래밍에 익숙해야하므로 코드 사용이 가장 까다로움.

07-11 다층 퍼셉트론 (MultiLayer Perceptron, MLP)으로 텍스트 분류하기

1. 다층 퍼셉트론 (MultiLayer Perceptron, MLP)

- 피드 포워드 신경망(Feed Forward Neural Network, FFNN)의 가장 기본적인 형태.
- 피드 포워드 신경망은 입력층에서 출력층으로 오직 한 방향으로만 연산 방향이 정해져 있는 신경망을 말함.

2. 케라스의 texts_to_matrix() 이해하기

- 케라스 Tokenizer의 text_to_matrix()를 이해해보자
- 코드 :

import numpy as np
from tensorflow.keras.proprocessing.text import Tokenizer
texts = ['먹고 싶은 사과', '먹고 싶은 바나나', '길고 노란 바나나 바나나', '저는 과일이 좋아요']
# 정수 인코딩 (1부터 시작)
tokenizer = Tokenizer()
tokenizer.fit_on_texts(texts)
print(tokenizer.word_index)

-> 출력 : {'바나나' : 1, '먹고' : 2, '싶은' : 3, '사과':4, '길고':5, '노란':6, '저는':7, '과일이':8, '좋아요': 9}

- texts_to_matrix() : 입력된 텍스트 데이터로부터 행렬(matrix)를 만드는 도구. 'binary', 'count', 'freq', 'tfidf' 총 4개의 모드를 지원함. 그 중 'count' 모드를 사용한 코드를 보자.

print(tokenizer.texts_To_matrix(texts, mode = 'count'))

-> 출력 :
[[0. 0. 1. 1. 1. 0. 0. 0. 0. 0.]
[0. 1. 1. 1. 0. 0. 0. 0. 0. 0.]
[0. 2. 0. 0. 0. 1. 1. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 1. 1. 1.]]

- count 모드를 사용한 결과 문서 단어 행렬(DTM)을 생성함. DTM에서의 인덱스는 앞서 확인한 word_index의 결과.
- 주의할 점은 각 단어에 부여되는 인덱스는 1부터 시작하는 반면 완성되는 행렬의 인덱스는 0부터 시작. => 실제로 단어의 개수는 9개였지만 완성된 행렬의 열의 개수는 10개인 것과 첫번째 열은 모든 행에서 값이 0. 인덱스 0에는 그 어떤 단어도 할당되지 않았기 때문 (인덱스가 1부터 시작되니까)
- DTM은 bag of words를 기반으로 하기 때문에 단어 순서 정보는 보존되지 않음. (구체적으로는 4개의 모든 모드에서 단어 순서 정보는 보존되지 않음.)

- 'binary' 모드의 코드 :

print(tokenizer.texts_to_matrix(texts, mode = 'binary'))

-> 출력:
[[0. 0. 1. 1. 1. 0. 0. 0. 0. 0.]
[0. 1. 1. 1. 0. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 1. 1. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 1. 1. 1.]]

- DTM의 결과와 매우 유사함. 다만 세번째 행, 두번째 열의 값이 DTM에서는 2였는데 여기선 1로 바뀜 -> 'binary' 모드는 해당 단어가 존재하는지만 관심을 가지고 해당 단어가 몇 개였는지는 무시하기 때문. (단어가 존재하면 1, 존재하지 않으면 0의 값을 가짐)

- 'tfidf' 모드의 코드:

print(tokenizer.texts_to_matrix(texts mode = 'tfidf').round(2))

-> 출력 :
[[0.   0.   0.85 0.85 1.1  0.   0.   0.   0.   0.  ]
[0.   0.85 0.85 0.85 0.   0.   0.   0.   0.   0.  ]
[0.   1.43 0.   0.   0.   1.1  1.1  0.   0.   0.  ]
[0.   0.   0.   0.   0.   0.   0.   1.1  1.1  1.1 ]]

- 말 그대로 TF-IDF 행렬을 만듦. 다만, 앞서 배운 기본식에서 TF는 각 문서에서의 각 단어의 빈도였다면, 'tfidf' 모드에서 TF는 각 문서에서의 각 단어의 빈도에 자연 로그를 씌우고 1을 더한 값으로 정의.

- 'freq' 모드의 코드:

print(tokenizer.texts_to_matrix(texts, mode = 'freq').round(2))

-> 출력 결과:
[[0.   0.   0.33 0.33 0.33 0.   0.   0.   0.   0.  ]
[0.   0.33 0.33 0.33 0.   0.   0.   0.   0.   0.  ]
[0.   0.5  0.   0.   0.   0.25 0.25 0.   0.   0.  ]
[0.   0.   0.   0.   0.   0.   0.   0.33 0.33 0.33]]

- 각 문서에서의 각 단어의 등장 횟수를 분자로, 각 문서의 크기(각 문서에서 등장한 모든 단어의 개수의 총 합)를 분모로 하는 표현 방법.

3. 20개 뉴스 그룹(Twenty Newsprouts) 데이터에 대한 이해

- 코드 :

# 라이브러리 불러오기
import pandas as pd
from sklearn.datasets import fetch_20newsgroups
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing. text import Tokenizer
from tensorflow.keras.utils import to_categorical

# 데이터 가져오기 (20개의 다른 주제를 가진 18,846개의 뉴스 그룹 이메일 데이터)
newsdata = fetch_20newgroups(subset = 'train') # 훈련 데이터만 입력 (all을 넣으면 전체데이터, test를 넣으면 테스트 데이터)

# 데이터의 속성 확인
print(newsdata.keys())
-> 출력 결과 : 이 중 target이 data와 메일이 어떤 주제인지 기재된 숫자 레이블로 실제 훈련에 사용할 속성임
dict_keys(['data', 'filenames', 'target_names', 'target', 'DESCR'])

# 주제의 개수 확인
print('총 주제의 개수 : {}'.format(len(newsdata.target_names)))
print(newsdata.target_names)
-> 출력 결과
총 주제의 개수 : 20
['alt.atheism', 'comp.graphics', 'comp.os.ms-windows.misc', 'comp.sys.ibm.pc.hardware', 'comp.sys.mac.hardware', 'comp.windows.x', 'misc.forsale', 'rec.autos', 'rec.motorcycles', 'rec.sport.baseball', 'rec.sport.hockey', 'sci.crypt', 'sci.electronics', 'sci.med', 'sci.space', 'soc.religion.christian', 'talk.politics.guns', 'talk.politics.mideast', 'talk.politics.misc', 'talk.religion.misc']

# 첫번째 샘플
print('첫번째 샘플의 레이블 : {}'.format(newsdata.target[0]))
-> 첫번째 샘플의 레이블 : 7

# 숫자로는 20개의 주제중 어떤 주제인지 모름. 실제 어떤 주제인지 확인
print('7번 레이블이 의미하는 주제 : {}'.format(newsdata.target_names[7]))
-> 7번 레이블이 의미하는 주제 : rec.autos

# 첫번째 샘플 본문내용
print(newsdata.data[0])

-> 출력 결과 :
From: lerxst@wahttp://m.umd.edu (where's my thing)
Subject: WHAT car is this!?
Nntp-Posting-Host: rac3.wahttp://m.umd.edu
Organization: University of Maryland, College Park
Lines: 15

I was wondering if anyone out there could enlighten me on this car I saw
the other day. It was a 2-door sports car, looked to be from the late 60s/
early 70s. It was called a Bricklin. The doors were really small. In addition,
the front bumper was separate from the rest of the body. This is
all I know. If anyone can tellme a model name, engine specs, years
of production, where this car is made, history, or whatever info you
have on this funky looking car, please e-mail.

Thanks,
- IL
---- brought to you by your neighborhood Lerxst ----

- 이메일의 내용을 보니 스포츠 카에 대한 글로 보임. 이 글의 레이블은 7이고, 7번 레이블은 rec.autos란 주제를 의미.

# data로부터 데이터프레임을 생성하고, target열을 추가
data = pd.DataFrame(newsdata.data, columns = ['email'])
data['target'] = pd.Series(newsdata.target)

# 결측 확인
data.isnull().values.any()

-> 결과 : False

# nunique() : 중복을 제거한 개수 확인
print('중복을 제외한 샘플의 수 : {}'.format(data['email'].nunique()))
print('중복을 제외한 주제의 수 : {}'.format(data['target'].nunique()))

-> 결과 :
중복을 제외한 샘플의 수 : 11314
중복을 제외한 주제의 수 : 20

# 레이블의 값 분포를 시각화
data['target'].value_counts().plot(kind='bar');

- 10번 레이블의 수가 가장 많고, 19번의 레이블의 수가 가장 적으며 대체적으로 400-600개 사이의 분포를 보임.
- 아래 코드를 통해 구체적은 수치 확인

print(data.groupby('target').size().reset_index(name='count'))

-> 결과
    target  count
0        0    480
1        1    584
2        2    591
3        3    590
4        4    578
5        5    593
6        6    585
7        7    594
8        8    598
9        9    597
10      10    600
11      11    595
12      12    591
13      13    594
14      14    593
15      15    599
16      16    546
17      17    564
18      18    465
19      19    377

# 훈련 데이터와 테스트 데이터의 본문과 레이블을 각각 저장
newsdata_test = fetch_20newsgroups(subset='test', shuffle = True)
train_email = data['email]
train_label = data['target']
test_email = newsdata_test.data
test_label = newdata_test.target

# 케라스의 토크나이저 도구를 사용하여 전처리
vocab_size = 10000 #  최대 단어 개수 정의. 빈도수가 가장 높은 상위 vocal_size개수만큼의 단어를 사용
num_calsses = 20
def prepare_data (train_data, test_data, mode) : # 전처리 함수
   tokenizer = Tokenizer(num_words = vocab_size) # vocal_size 개수만큼의 단어만 사용
   tokenizer.fit_on_texts(train_data)
   X_train = tokenizer.texts_to_matrix(train_data, mode = mode) # 샘플 수 x vocab_size 크기의 행렬 생성
   X_test = tokenizer.texts_to_matrix(test_data, mode = mode) # 샘플 수 x vocab_size 크기의 행렬 생성
   return X_train, X_test, tokenizer.index_word

- prepare_data : 케라스 토크나이저로 전처리를 수행하는 함수. 해당 함수는 케라스 토크나이저를 통해 단어 토큰화를 수행하고, 앞서 배운 texts_to_matrix()를 사용하여 훈련 데이터와 테스트 데이터를 'binary', 'count', 'tfidf', 'freq' 4개의 모드 중 사용자가 정한 모드로 변환함.

# 메일 본문에 대해서 'binary' 모드로 변환하고 훈련 데이터와 테스트 데이터의 레이블은 원-핫 인코딩을 수행
X_train, X_test, index_to_word = prepare_data(train_email, test_email, 'binary') # binary 모드로 변환
y_train = to_categorical(train_label, num_classes) # 원-핫 인코딩
y_test = to_categorical(test_label, num_classes) # 원-핫 인코딩
print('훈련 샘플 본문의 크기 : {}'.format(X_train.shape))
print('훈련 샘플 레이블의 크기 : {}'.format(y_train.shape))
print('테스트 샘플 본문의 크기 : {}'.format(X_test.shape))
print('테스트 샘플 레이블의 크기 : {}'.format(y_test.shape))

-> 결과 :
훈련 샘플 본문의 크기 : (11314, 10000)
훈련 샘플 레이블의 크기 : (11314, 20)
테스트 샘플 본문의 크기 : (7532, 10000)
테스트 샘플 레이블의 크기 : (7532, 20)

- 훈련 데이터와 테스트 데이터 모두 메일 본문의 크기가 샘플의수 X 10,000의 행렬로 변환됨. => 열의 개수가 10,000인 것은 prepare_data 함수 내부에서 Tokenizer의 num_words의 인자로 vocab_size를 지정해주었기 때문. 단어의 정수 인덱스는 1부터 시작하지만, 행렬의 인덱스는0부터 시작하여 0번 인덱스는 사용되지 않으므로 실제로 행렬에는 빈도수 기준 상위 9,999개의 단어가 표현된 셈.

- 빈도수 상위1번, 상위 999번 단어 확인:

print('빈도수 상위 1번 단어 : {}'.format(index_to_word[1]))
print('빈도수 상위 9999번 단어 : {}'.format(index_to_word[9999]))

-> 결과
빈도수 상위 1번 단어 : the
빈도수 상위 9999번 단어 : mic

4. 다층 퍼셉트론(Multilayer Perceptron, MLP)을 사용하여 텍스트 분류하기

# 라이브러리 불러오기
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

# 다층 퍼셉트론 설계
def fit_and_evaluate(X_train, y_trainn, X_test, y_test):
   model = Sequential()
   model.add(Dense(256, input_shape=(vocab_size,), activation = 'relu'))
   model.add(Dropout(0.5))  
   model.add(Dense(128, activation = 'relu'))
   model.add(Dropout(0.5))
   model.add(Dense(num_classes, activation = 'softmax'))
   model.compile(loss='categorical_crossentropy', optimizer = 'adam', metrics=['accuracy'])
   model.fit(X_train, y_train, batch_size = 128, epochs = 5, verbose = 1, validation_split = 0.1)
   score = model.evaluate(X_test, y_test, batch_size = 128, verbose = 0)
   return score{1]

- 위의 코드로 설계한 다층 퍼셉트론은 총 4개의 층을 가지고 있음. vocab_size의 크기를 가진 입력층, 256개의 뉴런을 가진 첫번째 은닉층, 128개의 뉴런을 가진 두 번째 은닉층, num_classes의 크기를 가진 출력층.
- 과적합을 피하기 위해 두번의 드롭아웃(Dropout)을 적용함. 이 문제는 다중 클래스 분류 문제이므로 출력층의 활성화함수로 소프트맥스 함수를 사용하고 손실함수로는 크로스 엔트로피(categorical_crossentropy) 함수를 사용.

# 모델 훈련
modes = ['binary', 'count', 'tfidf', 'freq'] # 네개의 모들를 저장
for mode in modes :
   X_train, X_test, __ = prepare_data(train_email, test_email, mode) # 모드에 따라 데이터 전처리
   score = fit_and_evaluate(X_train, y_train, X_test, y_test) 
   print(mode + '모드의 테스트 정확도 : ' , score)

-> 출력
binary 모드의 테스트 정확도: 0.8312533
count 모드의 테스트 정확도: 0.8239511
tfidf 모드의 테스트 정확도: 0.8381572
freq 모드의 테스트 정확도: 0.6902549

- 대체적으로 82-83%의 정확도 보이는데, 'freq' 모드에서만 정확도가 69%가 나옴.

07-12 피드 포워드 신경망 언어 모델(Neural Network Language Model, NNLM)

- 자연어는 많은 예외 사항, 시간에 따른 언어의 변화, 중의성과 모호성 문제 등을 전부 명세하기 어려움. 기계가 자연어를 표현하도록 규칙으로 명세하기 어려운 상황에서 대안은 규칙 기반 접근이 아닌 기계가 주어진 자연어 데이터를 학습하게 하는 것.
- 과거에는 통계적인 접근을 사용했으나, 최근에는 인공 신경망을 사용하는 방법이 자연어 처리에 더 좋은 성능을 얻고 있음. 번역기, 음성 인식 등과 같은 자연어 생의 기반으로 사용되는 언어 모델도 마찬가지.
- 신경망 언어 모델의 시초인 피드 포워드 신경망 언어 모델 (Feed Forward Neural Network Language Model)에 대해 학습하자.

1. 기존 N-gram 언어 모델의 한계

- 언어 모델은 문장에 확률을 할당하는 모델로 주어진 문맥으로부터 아직 모르는 단어를 예측하는 것을 언어 모델링이라고 함.
- n_gram 언어 모델은 언어 모델링에 바로 앞 n-1개의 단어를 참고함. 4-gram 언어 모델이라면 앞의 3개의 단어만 참고하는 것.
- 이러한 n_gram 언어 모델은 충분한 데이터를 관측하지 못하면 언어를 정확히 모델링하지 못하는 희소 문제가 있음.

2. 단어의 의미적 유사성

- 희소문제는 기계가 단어의 의미적 유사성을 알 수 있다면 해결할 수 있는 문제.
- '톺아보다'가 '샅샅이 살펴보다'와 유사한 의미일때, '발표 자료를 살펴보다'라는 단어 시퀀스는 존재하지만, '발표 자료를 톺아보다'라는 단어 시퀀스는 존재하지 않는 코퍼스를 학습한 언어 모델이 있다면, 발표 자료를 다음에 톺아보다가 올 확률을 0으로 연산함. (n-gram 언어 모델)
- 만약 언어 모델이 단어의 의미적 유사성을 학습할 수 있도록 설계한다면, 훈련 코퍼스에 없는 단어 시퀀스에 대한 예측이라도 유사한 단어가 사용된 단어 시퀀스를 참고하여 보다 정확한 예측을 할 수 있음. -> 이러한 아이디어를 반영한 언어모델이 신경망 언어 모델 NNLM임. 단어 벡터간 유사도를 구할 수 있는 벡터를 얻어내는 워드 임베딩의 아이디어기도 함.

3. 피드 포워드 신경망 언어 모델 (NNLM)

- NNLM이 언어 모델링을 학습하는 과정을 간소화된 형태로 설명해보자
- 예문 : "what will the fat cat sit on"
- 언어 모델은 주어진 단어 시퀀스로부터 다음 단어를 예측. 훈련 과정에서는 'what will the fat cat'이라는 단어 시퀀스가 입력으로 주어지면, 다음 단어 'sit을 예측하는 방식으로 훈련됨.
- 가장 먼저 해야 할 일은 다음과 같이 원-핫 인코딩.
what = [1, 0, 0, 0, 0, 0, 0]
will = [0, 1, 0, 0, 0, 0, 0]
the = [0, 0, 1, 0, 0, 0, 0]
fat = [0, 0, 0, 1, 0, 0, 0]
cat = [0, 0, 0, 0, 1, 0, 0]
sit = [0, 0, 0, 0, 0, 1, 0]
on = [0, 0, 0, 0, 0, 0, 1]

- n을 4라고 해보자. 이때, 언어 모델은 'what will the fat cat'이 주어졌을 때, 다음 단어를 예측하기 위해 앞의 4개 단어 'will the fat cat'까지만 참고함. 이 범위를 윈도우(window)라고 하기도 함 (이때 윈도우 크기는 4)

- 입력은 4개의 단어 (윈도우크기) 'will', 'the', 'fat', 'cat의 원-핫 벡터. 출력층(output layer)은 모델이 예측해야 하는 정답 해당되는 단어 sit의 원-핫 벡터는 모델이 예측한 값의 오차를 구하기 위해 레이블로서 사용됨.
- 4개의 원-핫 벡터를 입력 받은 NNLM은 다음층인 투사층(projection layer)을 지나게 됨.

- 인공 신경망에서 입력층과 출력층 사이는 보통 은닉층이라고 부르는데, 여기서 투사층이라고 명명한 이 층은 일반 은닉층과 다르게 가중치 행렬과의 곱셈은 이루어지지만 활성화 함수가 존재하지 않음.
- 투사층의 크기를 M으로 설정하면, 각 입력 단어들은 투사층에서 V X M 크기의 가중치 행렬과 곱해짐. 여기서 V는 단어 집합의 크기를 의미.
-원-핫 벡터의 특성으로 인해 i번째 인덱스에 1이라는 값을 가지고 그 외는 0의 값을 가지므로 원-핫 벡터와 가중치 W행렬의 곱은 사실 W행렬의 i번째 행을 그대로 읽어오는 것과 (lookup) 동일. 그래서 이 작업을 룩업 테이블(lookup table)이라고 함.

- 룩업 테이블 이후에는 V차원을 가지는 원-핫 벡터는 이보다 더 차원이 작은 M차원의 벡터로 맵핑됨.

- 이 벡터들은 초기에는 랜덤한 값을 가지지만 학습 과정에서 값이 계속 변경되는데 이 단어 벡터를 임베딩 벡터(Embedding vector)라고 함.
- 각 단어가 테이블 룩업을 통해 임베딩 벡터로 변경되고, 투사층에서 모든 임베딩 벡터들의 값은 연결됨.
- 일반적인 은닉층이 활성화 함수를 사용하는 비선형층인 것과는 달리 투사층은 활성화 함수가 존재하지 않는 선형층이라는 점이 다소 생소하지만, 이 다음은 다시 은닉층을 사용하는 일반적인 피드 포워드 신경망과 동일.

- 투사층의 결과는 h의 크기를 가지는 은닉층을 지남. 은닉층의 출력은 V의 크기를 가지는 출력층으로 향함. 이 과정에서 다시 또 다른 가중치와 곱해지고 편향이 더해지면, 입력이었던 원-핫 벡터들과 동일하게 V차원의 벡터를 얻음. 출력층에서는 활성화 함수로 소프트맥스 함수를 사용하는데, V차원의 벡터는 소프트맥스 함수를 지나면서 벡터의 각 원소는 0과 1 사이의 실수값을 가지며 총 합은 1이 되는 상태로 바뀜.

- NNLM의 예측값 벡터의 각 차원 안에서의 값이 의미하는 것은 이와 같음. j번째 인덱스가 가진 0과 1 사이의 값은 j번째 단어가 다음 단어일 확률을 나타냄. 실제값과 가까워지기 위해서 NNLM은 손실 함수로 크로스 엔트로피(cross-entropuy)를 사용.
- 충분한 훈련 데이터가 있다면, 수많은 문장에서 유사한 목적으로 사용되는 단어들은 결국 유사한 임베딩 벡터값을 얻게 됨 -> 다음 단어를 예측하는 과정에서 훈련 코퍼스에서 없던 단어 시퀀스라 하더라도 다음 단어를 선택할 수 있다는 이점이 있음.
- 단어간 유사도를 구할 수 있는 임베딩 벡터의 아이디어는 Word2Vec, FastText, Glove 등으로 발전됨.

4. NNLM의 이점과 한계

1) 기존 모델에서의 개선점
- 단어의 유사도를 계산할 수 있음 -> 희소 문제를 해결

2) 고정된 길이의 입력(Fixed - length input)
- 다음 단어를 예측하기 위해 모든 이전 단어를 참고하는 것이 아니라 정해진 n개의 단어만을 참고함 -> 이 한계를 극복할 수 있는 언어 모델이 RNN을 사용한 RNN 언어 모델.

모르는 것만 정리해두고 싶은데, 다 몰라서 거의 다 쓰고 있는 중... 요약 정리를 좀 해봐야겠다

다들 좋은 주말보내세요 *^____^*

[딥러닝을 이용한 자연어 처리 입문] Chapter 7. 딥 러닝(Deep Learning) 개요 (1)

빈이즈 — Tue, 4 Mar 2025 17:00:43 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/22882

07. 딥 러닝(Deep Learning) 개요

딥 러닝(Deep Learning)은 머신 러닝(Machine Learning)의 특정한 한 분야로서 인공 신경망(Artificial Neural Network)의 층을 연속적으…

wikidocs.net

07. 딥러닝(Dep LEarning)의 개요

: 머신러닝(Machine Learning)의 특정한 한 분야로서 인공 신경망의 층을 연속적으로 깊게 쌓아올려 데이터를 학습하는 방식.

07-01 퍼셉트론 (Perceptron)

> 퍼셉트론 (Perceptron)

: 초기 형태의 인공 신경망으로 다수의 입력으로부터 하나의 결과를 내보내는 알고리즘.

- x: 입력값, w: 가중치, y:출력값
- 각각의 입력값에는 각각의 가중치가 존재하고 가중치 값이 클수록 입력 값이 중요하다는 의미.
- 각 입력값과 가중치가 곱해져서 인공 뉴런에 보내지고, 각 입력값과 그에 해당하는 가중치의 곱의 전체 합이 임계치(threshole)를 넘으면 출력 신호로서 1을 출력, 그렇지 않은 경우 0을 출력함. 이러한 함수를 계단 함수(step function)라고 함.
- 활성화함수 : 출력값을 변형시키는 함수. ex. 계단함수, 시그모이드 함수, 소프트맥스 함수, ...

> 단층 퍼셉트론(Single-Layer Perceptron)

- 입력층과 출력층으로만 이루어짐.
- AND, NAND, OR 게이트는 구현 가능하지만 간단한 XOR 게이트조차도 구현할 수 없다는 지적을 받아옴.

> 다층 퍼셉트론(MultiLayer Perceptron, MLP)

- XOR 게이트는 기존의 AND, NAND, OR 게이트를 조합하면 만들 수 있음. -> 즉 층을 더 쌓으면 만들 수 있다는 것
- 입력층, 출력층 그리고 1개 이상의 은닉층이 존재함. (은닉층이 2개 이상인 신경망을 심층 신경망이라고 함.)
- 심층 신경망을 학습시키는 것이 딥러닝(Deep Learning)

07-02 인공 신경망(Artificial Neural Network) 훑어보기

> 피드 포워드 신경망(Feed-Forward Neural Network, FFNN)

- 순방향 신경망이라고도 함.
- 오직 입력층에서 출력층 방향으로 연산이 전개되는 신경망.

> 전결합층(Fully-connected layer, FC, Dense layer)

- 전결합층/완전연결층 : 어떤 층의 모든 뉴런이 이전 층의 모든 뉴런과 연결돼 있는 층.

ex. 다층 퍼셉트론은 은닉층과 출력층에 있는 모든 뉴런은 바로 이전 층의 모든 뉴련과 연결돼 있음 -> 모든 은닉층과 출력층은 전결합층 (=밀집층, Dense layer)

> 활성화 함수 (Activation Function)

- 활성화함수 : 은닉층과 출력층의 뉴런에서 출력값을 결정하는 함수
- 특징 1. 비선형 함수 : 선형 함수를 선택하면 은닉층을 쌓을 수 없음.
- 활성화 함수가 존재하지 않는 선형 함수 층을 사용하지 않는다는 의미는 아님. 종종 일부 추가하는 경우도 있음 -> 학습 가능한 가중치가 새로 생긴다는 점에서 의미 있음
- 선형 함수를 사용한 층을 활성화 함수를 사용하는 은닉층과 구분하기 위해 이 책에서는 선형층(linear layer) 혹은 투사층(projection layer) 등의 다른 표현을 사용.
- 활성화함수 종류1. 계단함수 : 거의 사용되지 않음
- 인공 신경망의 학습 과정 : 입력에 대해 순전파 연산 -> 연산을 통해 나온 예측값과 실제값의 오차를 손실 함수 (loss function)을 통해 계산 -> 이 손실(=오차)을 미분을 통해 기울기(gradient) 구함 -> 출력층에서 입력층 방향으로 가중치와 편향을 업데이트 (역전파 수행 : 경사 하강법 사용)
- 활성화함수 종류2. 시그모이드 함수 (Sigmoid function) : s자 곡선. 출력값이 0 또는 1에 가까워지면, 그래프의 기울기가 완만해짐 -> 미분값이 0에 가까운 아주 작은 값. (0.5에서의 미분값은 0.25) -> 미분값은 0.25이하의 값을 가짐 -> 시그모이드 함수를 활성화 함수로 하는 인공 신경망의 층을 쌓으면, 가중치와 편향을 업데이트하는 역전파 과정에서 0에 가까운 값이 누적해서 곱해지게 됨 -> 앞단(앞의 층)에는 기울기(미분값)가 잘 전달되자 않음 (=기울기 소실 문제)
=> 시그모이드 함수의 은닉층에서의 사용은 지양됨. 주로 이진 분류를 위해 출력층에서 사용함.

- 활성화함수 종류3. 하이퍼볼릭탄젠트 함수 (Hyperbolic tangent function) : 함수(tanh)는 입력값을 -1과 1 사이의 값으로 변환함. -> 시그모이드와 비슷한 모양으로 -1과 1에 가까운 출력값은 기울기가 0에 가까움. 그러나 시그모이드 함수와 달리 0을 중심으로 하고 있으며, 하이퍼볼릭탄젠트 함수를 미분했을 때의 최대값을 1로 시그모이드 함수의 최대값 0.25보다는 큼. => 미분했을 때 시그모이드 함수보다는 전반적으로 큰 값이 나오게 됨. => 시그모이드 함수보다 기울기 소실 이 적은 편이고 은닉층에서 시그모이드 함수보다는 선호됨

- 활성화함수 종류4. 렐루 함수 (ReLU) : 은닉층에서 가장 인기있는 함수. f(x) = max(0,x) 수식 -> 음수를 입력하면 0을, 양수를 입력하면 입력값 그대로를 출력하는 것이 가장 큰 특징. 0 이상의 입력값의 경우 미분 값이 항상 1. 깊은 신경망의 은닉층에서 시그모이드 함수보다 훨씬 더 잘 작동함. 단순해서 연산 속도도 빠름. BUT 문제점 : 입력값이 음수면 기울기(= 미분값)도 0이 됨. 이 뉴런은 다시 회생하는 것이 매우 어려움. -> 이 문제를 죽은 렐루(dying ReLU)라고 함.

- 활성화함수 종류 5. 리키 렐루(Leaky ReLU) : 죽은 렐루를 보완하기 위해 ReLU의 변형 함수들이 등장하기 시작. 그 중 하나가 Leaky ReLU. 입력값이 음수 일 경우에 0이 아니라 0.001과 같은 매우 작은 수를 반환하도록 되어있음. 수식은 f(x) = max(ax, x). a는 하이퍼파라미터로 Leaky('새는') 정도를 결정하며 일반적으로는 0.01 값을 가짐. 여기서 '새는 정도'는 입력값이 음수일 때의 기울기를 비유함. => 입력값이 음수라도 기울기가 0이 되지 않음

- 활성화함수 종류 6. 소프트맥스 함수(softmax function) : 은닉층에서는 ReLU를 사용하는 것이 일반적고, 소프트맥스 함수는 시그모이드 함수처럼 출력층에서 주로 쓰임. 시그모이드 함수가 이진 분류에 사용된다면 소프트맥스 함수는 세가지 이상의 상호 배타적인 선택지 중 하나를 고르는 다중 클래스 분류문제에 주로 사용됨.
=> 딥 러닝으로 이진 분류를 할 때는 출력층에 앞서 배운 로지스틱 회귀를 사용하고, 딥러닝으로 다중 클래스 분류 문제를 풀 때는 출력층에 소프트맥스 회귀를 사용한다고 생각할 수 있음.

07-03 행렬곱으로 이해하는 신경망

: 신경망의 순전파는 결과적으로 행렬의 곱셈으로 이해할 수 있다는 것과 다층 퍼셉트론 내의 학습 가능한 매개변수인 가중치 w와 편향 b의 개수를 추정하는 방법에 대해서 학습

> 순전파(Forward Propagation)

- 입력값은 입력층, 은닉층을 지나면서 각 층에서의 가중치와 함께 연산되며 출력층으로 향함. 입력층에서 출력층 방향으로 예측값의 연산이 진행되는 과정을 순전파라고 함.

> 행렬곱으로 순전파 이해하기

(코드예시 : 입력의 차원이 3, 출력의 차원이 2인 인공신경망 구현)

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
model = Sequential()
model.add(Dense(2, input_dim=3, activation = 'softmax'))

- 입력층의 뉴런이 3개, 출력층의 뉴런이 2개. 입력층에서 출력층으로 갈때 가중치 w의 개수는 6개가 됨.
- 이를 행렬곱 관점에서는 3차원 벡터에서 2차원 벡터가 되기 위해서 3X2 행렬을 곱했다고 할 수 있고, 각각의 원소가 각각의 w가 되는 것. 편향 b의 개수는 항상 출력의 차원을 기준으로 개수를 확인하면 됨 (=> 이 경우 2개)
- 가중치 w가 6개, 편향 b가 2개 총 매개변수가 8개가 됨
- 수식 : Y = XW + B

> 행렬곱으로 병렬 연산 이해하기

- 인공 신경망을 행렬곱으로 구현할 때 흥미로운 점은 병렬 연산도 가능하다는 점. (한번에 여러개의 샘플을 동시에 처리할 수 있음)
- 여기서 혼동하지 말아야 할 점은 학습가능한 매개변수의 수는 여전히 8개라는 점.
- 인공신경망이 다수의 샘플을 동시에 처리하는 것을 '배치 연산'이라고 함

> 행렬곱으로 다층 퍼셉트론의 순전파 이해하기

- 이런 인공신경망을 만들어보자 : 입력층(4개의 입력과 8개의 출력), 은닉층1(8개의 입력과 8개의 출력), 은닉층2(8개의 입력과 3개의 출력), 출력층(3개의 입력과 3개의 출력)
- 코드 :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
model = Sequential()
model.add(Dense(8, imput_dim=4,activaion='relu'))
model.add(Dense(8, activation = 'relu')
model.add(Dense(3, activation = 'softmax'))

- 위의 정보를 가지고 층마다 생기는 가중치와 편향 행렬의 크기를 추정해보자. 단 배치 크기는 1을 가정함.

1) 입력층 => 은닉층1

* 입력층(4개의 입력과 8개의 출력), 은닉층1(8개의 입력과 8개의 출력),
- XW + B = Y (X: 입력행렬, W : 가중치행렬, B : 편향행렬, Y : 출력행렬)
- 입력행렬 X의 크기는 1 X 4이고, 은닉층1의 출력은 8개 이므로, 출력행렬 Y의 크기는 1 X 8.
- 편향 행렬 B의 크기는 출력행렬 Y의 크기와 같음 => 1 X 8
- 가중치 행렬 W의 행의 크기는 X의 열의 크기와 같아야 하고, 열은 출력행렬과 같아야 함 => 4 X 8.

2) 은닉층1 => 은닉층2

* 은닉층1(8개의 입력과 8개의 출력), 은닉층2(8개의 입력과 3개의 출력)
- 위의 Y가 여기서는 X가 됨
- X1x8 X W8x8 + B1x8 = Y1x8

3) 은닉층2 => 은닉층3
- 출력행렬 Y는 은닉층3에서는 입력행렬 X로 다시 명명.
- X1x8 X W8x3 + B1x3 = Y1x3

- 은닉층과 출력층에 활성화 함수 relu와 softmax가 존재하지만 행렬의 크기에 영향을 주지 않음
- 이와 같이 순전파를 진행하고 예측값을 구하고나서 인공 신경망이 해야할 일은 예측값과 실제값으로부터 오차를 계산하고, 오차로부터 가중치와 편향을 업데이트 하는 일. => 인공신경망의 학습 단계
- 이때 인공신경망은 순전파와는 반대 방향으로 연산을 진행하며 가중치를 업데이트하는데 이 과정을 역전파(BackPropagation)라고 함.

07-04 딥 러닝의 학습 방법

1. 손실 함수 (Loss function)

- 실제값과 예측값의 차이를 수치화해주는 함수. 오차가 클수록 손실 함수의 값은 커짐.
- 회귀에서는 평균 제곱 오차, 분류에서는 크로스 엔트로피를 주로 사용함.
- 손실함수의 값을 최소화하는 두 개의 매개변수인 가중치 w와 편향 b를 찾는 것이 딥 러닝의 학습 과정이므로 손실 함수의 선정은 매우 중요함.

> MSE( Mean Squared Error, MSE)

- 평균 제곱 오차. 연속형 변수를 예측할 때 사용됨.
- compile의 loss에 문자열 'mse'라고 기재하거나 tf.keras.losses를 활용할 수도 있음
- 코드 :

model.compile(optimizer = 'adam', loss = 'mse', metrics = ['mse'])
model.compile(optimizer = 'adam', loss = tf.keras.losses.MeanSquareError(), metrics = ['mse'])

> 이진 크로스 엔트로피 (Binary Cross-Entropy)

- 출력층에서 시그모이드 함수를 사용하는 이진 분류 (Binary Classification)의 경우 binary_crossentropy를 사용. compile의 loss에 문자열로 'binary_crossentropy'를 기재하면 됨.
- 코드:

model.compile(loss='binary_crossentropy', optimizer= 'adam', metrics = ['acc'])
model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optiizer = 'adam', metrics = ['acc'])

> 카테고리칼 크소르 엔트로피 (Categorical Cross-Entropy)

- 출력층에서 소프트맥스 함수를 사용하는 다중 클래스 분류(Multi-Class Classification)일 경우 categorical_crossentropy'를 기재해주면 됨. compile의 loss에 문자열로 'categorical_crossentropy'를 기재해주면 됨.
- 코드 :

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics = ['acc'])
model.compile(loss=tf.keras.losses.CategoricalCrossentropy(), optimizer = 'adam', metrics=['acc'])

- 만약 레이블에 대해서 원-핫 인코딩 과정을 생략하고 정수값을 가진 레이블에 대해서 다중 클래스 분류를 수행하고 싶다면 다음과 같이 'sparse_categorical_crossentropy'를 사용
- 코드:

model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['acc'])
model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(), optimizer='adam', metrics=['acc'])

2. 배치 크기(Batch Size)에 따른 경사 하강법

- 손실함수의 값을 줄여나가면서 학습하는 방법은 어떤 옵티마이저를 사용하느냐에 따라 달라짐.
- 배치 : 가중치 등의 매개변수의 값을 조정하기 위해 사용하는 데이터의 양을 말함.

> 배치 경사 하강법(Batch Gradient Descent)

- 옵티마이저 중 하나로 오차(loss)를 구할 때 전체 데이터를 고려 -> 한 번의 매개 변수 업데이트에 시간이 오래 걸리고 메모리를 크게 요구한다는 단점을 가짐.
- 한 번의 훈련 횟수를 1 에포크라고 하는데, 배치 경사 하강법은 한 번의 에포크에 모든 매개변수 업데이트를 단 한 번 수행.

> 배치 크기가 1인 확률적 경사 하강법 (Stochastic Gradient Descent, SGD)

- 매개 변수의 값을 조정 시 전체 데이터가 아닌 랜덤으로 선택한 하나의 데이터에 대해서만 계산하는 방법.
- 적은 데이터 사용 -> 빠른 계산
- 매개변수의 변경폭이 불안정하고 배치 경사 하강법보다 정확도가 낮을 수도 있지만, 하나의 데이터에 대해서만 메모리에 저장하므로 자원이 적은 컴퓨터에서도 쉽게 사용 가능.
- 코드:

model.filt(trani_X, train_y, batch_size=1)

> 미니 배치 경사 하강법 (Mini-Batch Gradient Descent)

- 전체 데이터도, 1개의 데이터도 아닐 때, 배치 크기를 지정하여 해당 데이터 개수만큼에 대해서 계산하여 매개 변수의 값을 조정하는 경사 하강법.
- 전체 데이터를 계산하는 것보다 빠르고, SGD보다 안정적이라는 장점을 가짐.
- 배치 크기는 일반적으로 2의 n제곱에 해당하는 숫자로 선택하는 것이 보편적임.
- 만약, model_fit()에서 배치 크기를 별도로 지정해주지 않을 경우 기본값은 2의 5제곱에 해당하는 숫자 32로 설정.

3. 옵티마이저(Optimizer)

> 모멘텀(Momentum)

- 관성이라는 물리학의 법칙을 응용한 방법.
- 경사 하강법에서 계산된 접선의 기울기에 한 시점 전의 접선의 기울기값을 일정한 비율만큼 반영 => 마치 언덕에서 공이 내려올 때, 중간에 작은 웅덩이(ex. 극값)에 빠지더라도 관성의 힘으로 넘어서는 효과를 줄 수 있음.
- 코드:

tf.keras.optimizers.SGD(lr=0.01, momentum=0.9)

> 아다그리드(Adagrard)

- 각 매개변수에 서로 다른 학습률을 적용시킴.
- 변화가 많은 매개변수는 학습률이 작게 설정되고 변화가 적은 매개변수는 학습률을 높게 설정함.
- 코드:

tf.keras.optimizers.Adagrad(lr=0.01, epsilon=1e-6)

> 알엠에스프롭(RMSprop)

- Adagrad는 학습을 계속 진행한 경우에는 나중에 학습률이 지나치게 떨어진다는 단점이 있는데 이를 다른 수식에 대체하여 이러한 단점을 개선.
- 코드:

tf.keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)

> 아담(Adam)

: RMSprop과 Momentum 두 가지를 합친 듯한 방법으로 방향과 학습률 두 가지를 모두 잡기 위한 방법
- 코드:

tf.keras.optimizers.Adam(lr= 0.001, beta_1=0.9, beta_2= 0.999, epsilon = None, decay=0.0, amsgrad = False)

> 사용 방법

- 각 옵티마이저 인스턴스는 compile의 optimizer에서 호출.
- 코드예시(adam)

adam = tf.keras.optimizers.Adam(lr=0.001, beta_1= 0.9, beta_2 = 0.999, epsilon = None, decay=0.0, amsgrad = False)
model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['acc'])

(optimizer='adam'으로 작성해도 동일함)
- 다른 옵티마이저들도 optimizer = 'sgd', 'rmsprop'로 호출 가능.

4. 에포크와 배치 크기와 이터레이션

> 에포크

: 인공 신경망에서 전체 데이터에 대해서 순전파와 역전파가 끝난 상태. 전체 데이터를 하나의 문제지에 비유한다면 문제지의 모든 문제를 끝까지 다 풀고, 정답지로 채점을 하여 문제지에 대한 공부가 한 번 끝낸 상태.

> 배치 크기(Batch Size)

- 몇 개의 데이터 단위로 매개변수를 업데이트 하는지를 말함. 시험에 비유하면 문제지에서 몇 개씩 문제를 풀고나서 정답지를 확인하느냐의 문제.
- 배치 크기와 배치의 수는 다른 개념. 전체 데이터가 2000일 때 배치 크기를 200으로 한다면 배치의 수는 10임. 이때 배치의 수를 이터레이션이라고 함

> 이터레이션(Iteration) 또는 스템(Step)

- 한 번의 에포크를 끝내기 위해서 필요한 배치의 수 = 한 번의 에포크 내에서 이루어지는 매개변수의 업데이트 횟수
- 전체 데이터가 2000일 때 배치 크기를 200으로 한다면 이터레이션 수는 총 10임.
- 이터레이션은 스텝(Step)이라고도 함.

07-05 역전파(BackPropagation) 이해하기

1. 인공 신경망의 이해(Neural Network Overview)

- 입력층, 은닉층1개, 출력층 총 3개의 층으로 이루어진 인공신경망을 가정.
- 두개의 입력과, 두개의 은닉층 뉴런, 두개의 출력층 뉴런을 사용.
- 은닉층과 출력층의 모든 뉴런은 활성화함수로 시그모이드 함수 사용
- 입력층 두개의 뉴런을 각각 x1, x2. 2개의 은닉층의 뉴런을 z1/h1, z2/h2. 출력층 2개의 뉴런을 z3/o1, z4/o2라고하자.
- z1,z2,z3,z4는 이전층의 모든 입력이 각각의 가중치와 곱해진 값들의 합 => 즉 가중합을 의미함
- x1에서 첫번째 은닉 뉴런의 가중치를 w1, x2에서 첫번째 은닉 뉴런의 가중치를 w2라고 하면, z1= x1*z1 + x2*z2가 됨.

2. 순전파(Forward Propagaton)

- z1을 시그모이드 함수의 입력으로 사용하여 나온 출력을 h1이라고 함.
- 다시 h1, h2와 w5,w6,w7,w8과의 가중합을 구하여 나온 z3,z4를 시그모이드 함수의 입력으로 하여 나온 출력값 2개를 o1,o2라고 함.
- o1, o2는 예측값.
- 예측값과 실제값의 오차를 계산하기 위해 손실함수로 평균제곱오차 MSE를 사용.

3. 역전파 1단계 (BackPropagation Step 1)

- 역전파는 출력층에서 입력층 방향으로 계산하면서 가중치를 업데이트.
- 출력층 바로 이전의 은닉층을 N층이라고 하였을 때, 출력층과 N층 사이의 가중치를 업데이트하는 단계를 역전파 1단계, 그리고 N층과 N층의 이전층 사이의 가중치를 업데이트 하는 단계를 역전파 2단계라고 해보자.
- 역전파 1단계에서 업데이트 해야 할 가중치는 w5,w6,w7,w8 총 4개.
- w5를 구하려면 총오차에서 w5에 대한 편미분을 계산해야 함.
- 미분의 연쇄 법칙을 사용하면 이와 같이 풀어 쓸 수 있음
=> (총오차 (E_total)를 o1으로 편미분한 값) * (o1을 z3으로 편미분한값) * (z3을 w5로 편미분한값)
- 시그모이드 함수의 미분은 f(x) * (1-f(x))임.
-( https://wikidocs.net/37406) 자세한 계산은 이 링크 참고

> 역전파 2단계 (BackPropagation Step 2)
- 예시로 들고 있는 인공신경망은 은닉층이 1개이므로 이번단계가 마지막 단계.
- 이 단계에서는 w1,w2,w3,w4를 계산할 것임.
- w1에 대해 진행하자면 마찬가지로 E_total을 w1으로 편미분한 값을 계산

=> 인공신경망의 학습은 오차를 최소화하는 가중치를 찾는 목적으로 순전파와 역전파를 반복하는 것.

07-06 과적합(Overfitting)을 막는 방법들

1. 데이터의 양을 늘리기

- 데이터의 양을 늘릴 수록 모델은 데이터의 일반적인 패턴을 학습하여 과적합 방지
- 데이터의 양이 적다면 데이터 증식을 해주기도 함.

2. 모델의 복잡도 중요

- 복잡도는 은닉층의 수나 매개변수의 수 등으로 결정됨

3. 가중치 규제 (Regularization) 적용하기

- 복잡한 모델이 과적합될 가능성이 높음. 모델을 좀 더 간단하게 하는 방법으로 가중치 규제가 있음.
- L1규제 : 가중치 w들의 합계를 비용 함수에 추가함. L1 노름이라고도 함
- L2규제 : 모든 가중치 w들의 제곱합을 비용 함수에 추가. L2노름이라고도 함.
- 두 식 모두 비용 함수를 최소화하기 위해서는 가중치 w들의 값이 작아져야 한다는 특징이 있음.
- L1규제를 사용하면 비용 함수가 최소가 되게 하는 가중치와 편향을 찾는 동시에 가중치들의 절대값의 합도 최소가 되어야 함. -> 가중치 w의 값들은 0 또는 0에 가까이 작아져야 하므로 어떤 특성들은 모델을 만들 때 거의 사용되지 않게 됨.
- L2규제는 L1 규제와는 달리 가중치들의 제곱을 최소화하므로 w의 값이 완전히 0이 되기 보다는 0에 가까워지는 경향을 띔. 가중치 감쇠라고도 부름.
- L1규제는 어떤 특성들이 모델에 영향을 주고 있는지를 정확히 판단하고자 할 때 유용함. => 이런 판단이 필요 없다면 경험적으로는 L2규제가 더 잘 동작하므로 더 권장함.

4. 드롭아웃(Dropout)

- 학습 과정에서 신경망의 일부를 사용하지 않는 방법
- 예를 들어 드롭아웃의 비율을 0.5로 한다면 학습 과정마다 랜덤으로 절반의 뉴런을 사용하지 않고 절반의 뉴런만을 사용함.
- 드롭아웃은 신경망 학습 시에만 사용하고, 예측 시에는 사용하지 않는 것이 일반적. 학습 시에 인공 신경망이 특정 뉴런 또는 특정 조합에 너무 의존적이게 되는 것을 방지해주고, 매번 랜덤 선택으로 뉴런들을 사용하지 않으므로 서로 다른 신경망들을 앙상블하여 사용하는 것 같은 효과를 내어 과적합을 방지함.
- 코드:

from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import Dropout, Dense

max_wotds=10000
num_classes = 46

model_Sequential()
model.add(Dense(256,input_shape=(max_words,), activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation = 'softmax'))

오랜만에 올리는 자연어처리 공부노트!

자연어 처리 공부하고 관련 공모전에 나가서 실제로 어떻게 적용하는지 빨리 배워보고 싶다 ☺️

원인과 결과의 경제학 (나카무로 마키코, 쓰가와 유스케 지음)

빈이즈 — Wed, 4 Dec 2024 12:09:57 +0900

원인과 결과의 경제학_나카무로 마키코, 쓰가와 유스케 지음

: 넘치는 데이터 속에서 진짜 의미를 찾아내는 법

- 독서기간 : 2024-11-13 ~ 2024-12-03

- 책 내용 : 인과관계인지 상관관계인지 잘 따져봐야 한다

- 후기 : 상관관계와 인과관계의 차이에 대해 더 자세히 알게 됐고 조심해야 겠다는 생각이 들었고, 인과관계인지 확인하기 위한 '반사실', '이중차분법', 회귀 불연속 설계' 등 새로운 지식들을 배울 수 있어 유익한 책이었다

<프롤로그 :: 당신이 알고 있는 사실은 진실인가?>

> 인과관계와 상관관계
"정말 인과관계가 존재하는가?" -> '인과 추론' 방법론을 이용하여 확인

> 빅데이터 시대에는 데이터 분석 기술뿐 아니라 데이터의 분석 결과를 해석하는 기술도 필요하다

<제 1장 근어 없는 통설에 속지 않으려면 : 인과 추론의 본질>

Keyword 제3의 변수 : 원인과 결과 모두에 영향을 주며, 상관관계에 지나지 않는 것을 마치 인과관계가 있는 것처럼 보이게 만드는 성가신 존재. 전문용어로는 "교란 요인"이라고 부른다.

> 두 변수의 관계가 인과관계인지 아니면 상관관계인지 확인하기 위해 의심해 볼 세 가지

- '우연의 일치'는 아닌가? -> EX) 지구온난화가 진행되면 해적 수가 줄어든다, "미야자키 하야오 감독이 이끄는 스튜디오 지브리 영화가 일본 텔레비전에서 방영되면, 미국의 주가가 떨어진다"는 "지브라의 저주"
- '제3의 변수'는 없는가? -> EX) 체력이 좋은 아이들이 성적도 높다. => 아이들의 체력과, 성적에 모두 영향을 미치는 제3의 변수가 있는지 확인. => '부모의 교육열'이 강할 경우 아이에게 스포츠를 배우게 하거나 식사에 신경 쓰고, 동시에 공부를 시킬 것이기 때문에 성적도 높은 경향이 있음 => 이 경우 실제로 아이들의 성적을 향상시키는 것은 체력이 아닌 '부모의 교육열'임.
- '역의 인과관계'는 존재하지 않는가? -> EX) 경찰관 수와 범죄의 관계에 대해 생각해 볼 때, 지역별 경찰관의 수가 많다는 것이 원인이 되어 범죄의 발생 건수가 많다는 결과를 발생시켰다고 보기 어려움 (경찰관 -> 범죄)
=> 범죄가 많은 우범 지역이기 때문에 많은 경찰관을 배치한 것으로 보는 것이 타당 (범죄->경찰관)
=> 원인이라고 오해했던 것이 결과이고, 결과라고 생각했던 것이 원인인 상태를 "역의 인과관계"라고 부름.

> 두 변수가 인과관계에 있다면 다시 원인이 발생했을 때 같은 결과를 얻게 된다.

> '반사실'로 증명
- 반사실 : "만약에 -을 하지 않았더라면 결과는 어떻게 됐을까?"라는 식으로 실제로 일어나지 않은 사실을 가정하는 시나리오.
- 인과관계의 존재는 원인이 발생한 '사실'의 결과와 원인이 발생하지 않은 '반사실'의 결과를 비교하여 증명해야 함.

> 크리스마스 시즌에 맞춰 12월 초에 광고를 만듦 -> 매출이 전년 동기 대비 30퍼센트 증가 -> "올해 매출의 증가는 다 신문 광고 덕분입니다" 할 수 있나?
- 광고의 인과효과 : 광고를 냈을 때(사실)의 매출과, 똑같은 상황에서 광고를 내지 않았을 때(반사실)의 매출 차이를 말함
- 현실에서 반사실을 관찰할 수 없음 => 반사실을 '타당한 값'으로 채운다
EX) 지역 A-D 중 A,B는 광고를 하고 나머지 C, D은 광고를 하지 않았을 때, A, B가 광고를 하지 않는 경우(반사실)의 매출은 알 수 없고, 마찬가지로 C, D가 광고를 한 경우(사실)의 매출도 알 수 없음. (=> 반사실 관찰 불가)
=> 반사실과 사실의 매출 차이로 광고의 인과효과를 확인하기 어려움. => A,B 지역의 반사실 값을 C, D 지역의 매출로 채우는 방법이 있음
- 이 개념에는 조건이 하나 있음 : 광고를 낸 그룹과 광고를 내지 않는 그룹이 '비교 가능'해야 한다는 것.
- 비교가능하다는 것은 매출에 영향을 미칠 만한 모든 특징이 매우 비슷하고 유일한 차이가 '광고의 유무'만일 경우를 말함.
- 실제로는 그런 그룹은 존재하지 않음 => 비교가능하도록 만들어야 함

<제2장 건강검진을 받으면 오래 살 수 있다? :: 제대로 된 비교는 랜덤이 진리>

keyword 랜덤화 비교 실험 : 동전 던지기나 난수표, 또는 제비뽑기 등을 이용해 연구 대상자를 랜덤으로 개입을 받는 그룹(실험군)과 그렇지 않은 그룹(대조군)으로 나눈다. 이렇게 두 그룹을 비교 가능하게 한 다음, '만약 실험군이 개입을 받지 않았다면 어떻게 됐을까?'라고 가정하는 반사실을 대조군의 결과로 채우는 방법을 말한다

-EX. 임상시험 : 신약의 효과와 안정성을 확인하기 위해 실시되는 테스트. 예를 들어 실험용 쥐를 이용한 실험에서는 병에 걸린 쥐를 '랜덤 하게' 두 그룹으로 나누 다음, 투약한 쥐(실험군)와 투약하지 않은 쥐(대조군)를 비교한다. 만약 투약한 쥐가 치료율이 높았다면 약에 효과가 있었다고 할 수 있다.

- 통계적으로 유의미하지 않다: 실험군과 대조군의 차이가 우연에 의한 오차 범위 내에서 설명할 수 있다
- 통계적으로 유의미하다 : 관찰된 차이가 우연의 산물일 확률이 5퍼센트 이하이다. (유의확률 5%일 경우)

<제3장 남성 의사가 여성 의사보다 뛰어나다? :: 우연히 일어난 상황을 이용해 볼 수 있다면>

keyword 자연실험 : 연구 대상자들이 법률이나 제도의 변경, 자연재해 등 '외생적 쇼크'에 의해 자연적으로 개입을 받는 그룹(실험군)과 그렇지 않은 그룹(대조군)으로 나뉜 상황을 이용, 인과관계를 검증하는 방법

EX) 100개 점포 대상으로 신문에 광고지를 끼어 넣기로 결정 -> 광고지 인쇄를 맡은 회사 중 한 곳에서 인쇄기 고장 -> 일부 점포만 광고지를 배포할 수 없음 -> 예정대로 광고지를 배포한 점포와 그렇지 않은 점포를 비교함으로써 광고가 매출에 미치는 인과관계를 밝힐 수 있지 않을까?라는 관점으로 접근

<제4장 어린이집을 늘리면 여성 취업률이 올라갈까? :: '트렌드'에 속지 마라>

keyword 이중차분법 : 개입을 받는 그룹(실험군)과 그렇지 않은 그룹(대조군)의 개입 전후 결과의 차이와 실험군과 대조군의 차이 이렇게 두 개의 차이로 효과를 추정하는 방법. 이를 위해서는 두 가지 전제조건이 성립해야 한다. 먼저 실험군과 대조군은 개입 전 결과의 '트렌드'가 같아야 한다. 즉 '트렌드'가 비교 가능해야 한다. 또 다른 하나는 개입과 같은 타이밍에 결과에 영향을 줄 만한 다른 변화가 실험군과 대조군에 별개로 발생하지 않아야 한다.

> 준 실험 : 실험을 '모방한다'는 의미에서 준실험이라 불림. 관찰 데이터와 통계적 기법을 이용해 마치 랜덤화 비교 시험을 실시하고 있는 것 같은 상황을 만들어내는 것. 그러한 통계적 기법으로 이 책에서는 1) 이중차분법 2) 조작변수법 3) 회귀 불연속 설계 4) 매칭법을 소개한다.

> 이중차분법
개입을 받은 그룹의 개입 전 결과를 A1, 개입 후 결과를 A2라고 하자. 그리고 개입을 받지 않은 그룹(대조군)의 개입 전 결과를 B1, 개입 후 결과를 B2라고 한다. 실험군의 전후 비교(A2-A1)와 대조군의 전후 비교(B2-B1)의 차이인 {(A2-A1)-(B2-B1)}이 이중 차분에 의해 추정되는 개입 효과이다.

<제5장 텔레비전을 많이 보면 아이들 머리가 나빠진다? :: 제3의 변수를 이용하라?

keyword 조작 변수법 : '원인에게 영향을 주는 것을 통해서만 결과에 영향을 주는 조작 변수'를 이용해 개입을 받는 그룹(실험군)과 그렇지 않은 그룹(대조군)을 비교 가능한 상태로 만드는 방법. 이 방법이 효과적이기 위해서는 두 전제조건이 성립해야 한다. 먼저 조작 변수는 원인에는 영향을 미치지만 결과에는 직접 영향을 주지 않아야 하며, 또한 조작 변수와 결과 모두에 영향을 줄 만한 제4의 변수가 존재하지 않아야 한다는 점이 그것이다.

> 조작변수법 예시
-매출에 광고의 인과 효과가 있는지 알아보고 싶음.
- 조작변수 : 광고료
- 광고료가 내려가면 그 지방에 있는 점포들이 광고를 낼 확률은 높아짐 => 이 신문사의 광고료 할인 인벤트를 이용해 광고의 매출에 대한 인과 효과를 밝힐 수 없을까?
- 광고료 할인 이벤트를 하면 광고를 내는 점포는 증가할 것이다. 그러나 이 이벤트는 매출에는 직접 영향을 주지 않는다.
- 광고와 매출 사이에 인과관계가 있다면 : 이벤트로 광고를 내는 점포가 늘어 그 결과 매출도 증가할 것이다.
- 광고와 매출 사이에 인과관계가 없다면 : 이벤트로 광고를 내는 점포가 늘어도 매출은 증가하지 않을 것이다.

<제 6장 공부 잘하는 친구와 사귀면 성적이 오를까? :: 갑자기 튀어나온 '점프'에 주목하라>

keyword 회귀 불연속 설계 : 회귀 불연속 설계란 자의적으로 결정된 컷오프 값을 중심으로 실험군과 대조군으로 갈리는 상황을 이용해 인과 효과를 추정하는 방법이다. 이 기법이 성립하기 위한 전제조건은 컷오프 값 주변에서 결과에 영향을 줄 만한 다른 이벤트가 발생하지 않아야 한다는 것이다.

> 49명과 50명의 차이
- 종업수가 50명 이상인 대형 점포에 한해 연말에 크리스마스 특수를 노린 광고를 낸다.
- 종업원 수가 49명인 점포는 광고를 내지 않고 50명인 점포는 광고를 내게 된다는 소리 -> 49명인 점포와 50명인 점포는 고아고의 유무를 제외하고는 별반 다를 것이 없다. -> 49명인 점포와 50명인 점포의 매출 비교를 통해 광고의 매출에 대한 인과 효과를 밝힐 수 있지 않을까?
- 컷오프 값 부근에서 큰 매출의 격차가 발생 -> '점프'는 광고에 의해 발생한 것이기 때문에 그 크기야말로 광고가 매출에 미치는 인과효과라 볼 수 있다.

<제 7장 명문대를 졸업하면 연봉이 높을까?:: 비슷한 대상들끼리의 조합을 찾아라>

keyword 매칭법 : 결과에 영향을 줄 만한 공변량을 이용해 대조군에서 실험군과 매우 흡사한 샘플을 찾아내 매칭시켜 비교하는 방법. 공변량이 복수일 때는 모두 종합해 점수화하여 이용하는 경우도 있다(성향 점수 매칭법). 매칭이 성립하기 위한 조건은 결과에 영향을 줄 만한 공변량이 모두 관찰 가능해야 한다는 것이다.

> '짝'을 찾아낸다
- 총 점포 100개 가운데 30개는 광고를 낸 점포, 70개는 광고를 내지 않은 점포
- 광고를 내지 않은 70개 점포 가운데 광고를 낸 30개 점포와 매우 비슷한 조건의 점포를 30개 추출해 광고를 낸 30개 점포와 비교하면 되지 않을까?
- 광고를 낸 그룹 중 한 점포의 점장 연령이 45세라면, 광고를 내지 않은 그룹 중에서 점장의 연령이 45세인 점포를 골라 매칭. 55세면 55세를 골라 매칭
- 이렇게 하나씩 매칭시켜 나가면 결국 점장의 평균 연령이 같은 실험군과 대조군이 완성되고, 이 두 그룹은 비교 가능해진다.
- 이때 점장의 '연령'에 해당하는 변수를 '공변량'이라고 한다.
- 공변량은 하나 이상일 수 있음

> 성향 점수 매칭법
- 성향 점수 : 복수의 공변량을 종합해 점수화한 것. '실험군으로 분류될 확률.을 의미함.
- EX) 다양한 공변량을 고려한 결과 광고를 낼 확률이 50%인 점포의 성향 점수는 0.5, 30%인 점포는 0.3이 된다.
- 광고를 낸 점포(실험군) 중에서 성향 점수가 0.5인 점포가 있으면, 광고를 내지 않은 점포(대조군)에서 성향 점수가 0.5인 점포를 찾아 매칭한다.
- 이렇게 완성된 두 개의 그룹을 비교하면 성향 점수 계산에 이용한 모든 공변량이 두 그룹 사이에서 비슷한 값을 취하게 된다.

<제8장 어떻게 해도 도저히 예측이 불가능하다면 :: 기존 데이터를 다시 들여다보자>

keyword 최적선 : 데이터 간의 거리 합계가 가장 작아지도록 그은 선. 이 선의 기울기는 원인이 한 단위 증가했을 때 결과가 어느 정도 변화하는지 보여주는 것이며, 최적선의 기울기는 '인과 효과'를 의미한다.

<보론 1 분석의 타당성과 한계에 대해>

> 타당성 있는 것은 무엇인가
- 내적 타당성 : 두 변수 사이에 인과관계가 있을 확률. 즉 연구 대상이 된 집단에 재차 동일한 개입을 했을 때 같은 결과가 재현되는 정도를 가리킨다.
- 외적 타당성 : 연구 대상과는 다른 집단에 개입했을 때 같은 결과가 재현되는 정도를 말한다.
- EX) 미국에서 실시된 랜덤화 비교 실험에서 혈압을 떨어뜨리면 심근경색에 걸릴 위험성이 낮아져 사망률이 하락한다는 인과관계가 증명됨 -> 랜덤화 비교 시험은 에비던스 수준이 높은 기법이기 때문에 내적 타당성이 높다고 볼 수 있다 -> 이 결과가 다른 나라에도 해당되는지, 즉 외적 타당성에 대해 신중하게 살펴볼 필요 있음

(짧은 후기)

데이터 분석에 대한 더 많은 지식을 얻기 위하여 관련 독서를 시작!

앞으로 더 다양한 책을 읽으며, 분석 공부를 해보려고 한다.

(●'◡'●)

[딥러닝을 이용한 자연어 처리 입문] Chapter 9. 워드 임베딩 (Word Embedding)

빈이즈 — Tue, 6 Aug 2024 12:17:04 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/22644

09. 워드 임베딩(Word Embedding)

텍스트를 컴퓨터가 이해하고, 효율적으로 처리하게 하기 위해서는 컴퓨터가 이해할 수 있도록 텍스트를 적절히 숫자로 변환해야 합니다. 단어를 표현하는 방법에 따라서 자연어 처리의 성…

wikidocs.net

09. 워드 임베딩 (Word Embedding)

09-01 워드 임베딩 (Word Embedding)

> 밀집 표현

- 희소 표현과 반대되는 표현
- 벡터의 차원을 단어 집합의 크기로 상정하지 않고, 사용자가 설정한 값으로 모든 단어의 벡터 표현의 차원을 맞춤
- 0과 1 값만 가지지 않고 실수값을 가지게 됨

> 워드 임베딩

- 단어를 밀집 벡터(dense vector)의 형태로 표현하는 방법을 말함
- 이 밀집 벡터를 워드 임베딩 과정을 통해 나온 결과라고 하여 임베딩 벡터라고도 함
- 워드 임베딩 방법론 예시 : LSA, Word2Vec, FastText, Glove 등
- 케라스의 Embedding() : 단어를 랜덤한 값을 가지는 밀집 벡터로 변환한 후, 인공 신경망의 가중치를 학습하는 것과 같은 방식으로 단어 벡터를 학습.

09-02 워드투벡터(Word2Vec)

> 분산 표현

- 분산표현방법 : 분포 가설이라는 가정 하에 만들어진 표현 방법. 이 가정은 '비슷한 문맥에서 등장하는 단어들은 비슷한 의미를 가진다'라는 가정.
- 단어의 의미를 여러 차원에다가 분산하여 표현. => 단어 벡터 간 유의미한 유사도 계산 가능.
- 분산 표현의 대표적인 학습 방법이 Word2Vec

> Word2Vec 학습 방식

- CBOW와 Skip-Gram 두가지 방식이 있음
- CBOW : 주변에 있는 단어들을 입력으로 중간에 있는 단어들을 예측하는 방법
- Skip-Gram : 중간에 있는 단어들을 입력으로 주변 단어들을 예측하는 방법
- CBOW 예시 : 'The fat cat sat on the mat' 같은 예문이 있는데, ['The', 'fat', 'cat', 'on', 'the', 'met']으로부터 sat을 예측하는 것. 이때 예측해야 하는 단어 sat을 중심단어(center word)라고 하고, 예측에 사용되는 단어들을 주변 단어(context word)라고 함.

> Word2Vec

- Word2Vec은 은닉층이 다수인 딥 러닝 모델이 아닌 은닉층이 1개인 얕은 신경망 (shallow neural network)임. 또한 이 은닉층은 일반적인 은닉층과 달리 활성화 함수가 존재하지 않으며 룩업 테이블이라는 연산을 담당하는 층으로 투사층(projection layer)이라고 부르기도 함.

> CBOW

- 중심 단어를 예측하기 위해서 앞, 뒤로 몇 개의 단어를 볼지를 결정해야 하는데, 이 범위를 윈도우 (window)라고 함.
- 슬라이딩 윈도우 : 윈도우 크기가 정해지면 윈도우를 옆으로 움직여서 주변 단어와 중심 단어의 선택츨 변경해가며 학습을 위한 데이터 셋을 만드는 방법
- 입력층의 입력으로 앞, 뒤로 사용자가 정한 윈도우 범위 안에 있는 주변 단어들의 원-핫 벡터가, 출력층에서는 예측하고자 하는 중간 단어의 원-핫 벡터가 레이블로 필요함.
- 투사층의 크기가 M이면, 임베딩하고 난 벡터의 차원도 M.
- 입력벡터가 원-핫 벡터이기 때문에 i번째 인덱스에만 1 값을 가짐. -> 입력 벡터와 가중치 W 행렬의 곱은 사실 W행렬의 i번째 행을 그대로 읽어 오는 것과 (lookup) 동일. -> 이 작업을 룩업 테이블이라고 함.
- 이렇게 주변단어의 원-핫 벡터에 대하여 가중치 W가 곱해져 생겨진 결과 벡터들은 투사층에서 만나 벡터들의 평균인 벡터를 구하게 됨. (Skip-Gram과 차이점. Skip-Gram은 중심 단어 하나이기에 투사층에서 벡터의 평균을 구하지 않음)
- 이렇게 구해진 평균 벡터는 두번째 가중치 행렬 W'와 곱해짐. 곱셈의 결과로는 원-핫 벡터들ㅇ과 차원이 V로 동일한 벡터가 나옴.
- 이 벡터는 소프트맥스 함수를 지나면서 각 원소의 값은 0과 1 사이의 실수로, 총 합은 1이 됨.
- 오차를 줄이기 위해 손실함수로 크로스 엔트로피 함수 사용.
- 역전파를 수행하여 W와 W'가 학습됨.

> Skip-Gram

- 중심 단어에 대해서 주변 단어를 예측하므로 투사층에서 벡터의 평균을 구하는 과정이 없음 (입력이 하나였기 때문에 평균 구할 게 없음)
- 전반적으로 CBOW보다 성능이 좋다고 알려짐.

>NNLM VS. Word2Vec

- NNLM은 단어 벡터 간 유사도를 구할 수 있도록 워드 임베딩의 개념을 도입. NNLM의 느린 학습 속도와 정확도를 개선하여 탄생한 것이 Word2Vec
- NNLM은 다음 단어를 예측하는 것이 목적, Word2Vec(CBOW)은 워드 임베딩 자체가 목적이므로 다음 단어가 아닌 중심 단어를 예측하게 하여 학습. => 예측 단어의 이전 단어들만을 참고하였던 NNLM과 달리 예측 단어의 전, 후 단어들을 모두 참고.
- Word2Vec은 우선 NNLM에 존재하던 활성화 함수가 있는 은닉층을 제거함. => 투사층 다음에 출력층 연결.
- Word2Vec가 NNLM보다 학습 속도가 좋은 이유는 은닉층을 제거한 것뿐 아니라 추가적으로 사용되는 기법 덕분. 대표적으로 계층적 소프트맥스와 네거티브 샘플링이 있음. (이 책에선 네거티브 사용)

09-03 영어/한국어 Word2Vec 실습

>파이썬의 gensim 패키지 Word2Vec

(Word2Vec의 하이퍼파라미터값)
- vector_size = 워드 벡터의 특징 값. 즉 임베딩 된 벡터의 차원.
- window = 컨텍스트 윈도우 크기
- min_count = 단어 최소 빈도 수 제한
- workers = 학습을 위한 프로세스 수
- sg = 0은 CBOW, 1은 Skip-Gram
- model.wv.most_similar('단어') : 입력한 단어와 유사한 단어들과 각 단어의 유사도도 알려줌.
- model.similarity('단어1', '단어2') : 단어1, 단어2의 유사도 알려줌.

> 사전 훈련된 Word2Vec 임베딩

- 자연어 처리 작업을 할 때, 케라스의 Embedding()를 사용하여 갖고 있는 훈련 데이터로부터 처음부터 임베딩 벡터를 훈련시키기도 하지만, 방대한 데이터로 사전에 훈련된 워드 임베딩을 가져와 해당 벡터들의 값을 하는 작업에 사용할 수 있음.
- 예) 감성 분류 작업을 하는데 훈련 데이터의 양이 부족함 -> 다른 방대한 데이터를 Word2Vec이나 GLove 등으로 사전에 학습시켜놓은 임베딩 벡터들을 가지고 와서 모델의 입력으로 사용하는 것이 때로는 더 좋은 성능을 냄.

09-04 네거티브 샘플링을 이용한 Word2Vec 구현

> 네거티브 샘플링

- Word2Vec이 학습 과정에서 전체 단어 집합이 아닌 일부 단어 집합에만 집중할 수 있도록 하는 방법.
- 현재 집중하고 있는 단어가 '고양이', '귀여운'이라면, 여기에 '돈가스', '컴퓨터', '회의실'과 같은 단어 집합에서 무작위로 선택한 주변 단어가 아닌 단어들을 일부를 가져옴. => 전체 단어집합이 아닌 훨씬 작은 단어 집합을 만들어 두고 이진 분류 문제로 변환. => 주변 단어들을 긍정(positive), 랜덤으로 샘플링 된 단어들을 부정(negative)로 레이블링 한다면 이진 분류 문제를 위한 데이터셋이 됨. => 연산량에서 효율적임

> 네거티브 샘플링 Skip-Gram (SGNS)

- Skip-Gram이 중심단어를 입력으로, 주변단어를 출력이었다면, SGNS는 중심 단어와 주변 단어가 모두 입력이고 이 두 단어가 실제로 윈도우 크기 내에 존재하는 이웃 관계인지 그 확률을 예측함.
- 중심단어와 주변 단어를 각각 입력1, 입력2로 두고, 이 둘은 실제로 윈도우 크기 내에서 이웃 관계였으므로 레이블을 1로 둠.
- 실제로 입력 1(중심단어)와 주변 단어 관계가 아닌 단어들을 입력2로 두고 (단어집합에서 랜덤으로 선택한 단어들) 레이블을 0으로 함.
- 중심 단어와 주변 단어의 내적값을 이 모델의 예측값으로 하고, 레이블과의 오차로부터 역전파하여 중심 단어와 주변 다넝의 임베딩 벡터값을 업데이트.

> 네거티브 샘플링을 통한 데이터셋 구성

- 케라스의 skipgrams를 사용

09-05 글로브(Glove; Global Vectors for Word Representation)

> 글로브

- 카운트 기반과 예측 기반을 모두 사용하는 방법론으로, 기존의 카운트 기반의 LSA, 예측 기반의 Word2Vec의 단점을 지적하며 이를 보완한다는 목적으로 나옴.
- 현재까지의 연구에 따르면 단정적으로 Word2Vec와 Glove 중 어떤 것이 더 뛰어나다고 말할 순 없고 두 가지를 사용해보고 성능이 더 좋은 것을 사용하면 됨.

>기존 방법론 비판

- LSA는 카운트 기반으로 코퍼스의 전체적인 통계 정보를 고려하기는 하지만, 왕:남자 = 여왕:? (정답은 여자)와 같은 단어 의미의 유추 작업에는 성능이 떨어짐.
- Word2Vec는 예측 기반으로 단어 간 유추 작업에는 뛰어나지만, 임베딩 벡터가 윈도우 크기 내에서만 주변 단어를 고려하기에 코퍼스의 전체적은 통계정보를 반영하지 못함.
- GLoVe는 이러한 기존 방법론의 한계를 지적하며, LSA의 매커니즘인 카운트 기반의 방법과 Word2Vec의 메커니즘인 예측 기반의 방법론을 모두 사용함.

> 윈도우 기반 동시 등장 행렬

- 단어의 동시 등장 행렬 : 행과 열을 전체 단어 집합의 단어로 구성하고, i 단어의 윈도우 크기 내에서 k 단어가 등장한 횟수를 i행 k열에 기재한 행렬

> 동시 등장 확률

- P(K|i)는 동시 등장 행렬로부터 특정 단어 i의 전체 등장 횟수를 카운트하고, 특정 단어 i가 등장했을 때
어떤 단어 k가 등장한 횟수를 카운트하여 계산한 조건부확률. i가 중심단어, k 주변단어.

> 손실 함수 (Loss Function)

- X : 동시 등장 행렬
- X_ij : 중심 단어 i가 등장했을 때, 윈도우 내 주변 단어 j가 등장하는 횟수
- X_i : 동시 등장 행렬에서 i행의 값을 모두 더한 값
- P_ik = P(k|i) : 중심 단어 i가 등장했을 때, 윈도우 내 주변단어 k가 등장할 확률
- w_i : 중심 단어 i의 임베딩 벡터
- ~w_k : 주변 단어 k의 임베딩 벡터

- GloVe의 아이디어 : 임베딩 된 중심 단어와 주변 단어 벡터의 내적이 전체 코퍼스에서의 동시 등장 확률이 되도록 만드는 것. -> 이를 만족하도록 임베딩 벡터를 만드는 것이 목표
- dot product(w_i, ~w_k)가 P(k}i)와 비슷하도록 하기. 더 정확히는 log P(k|i)와 비슷하도록!

09-06 패스트텍스트(FastText)

: Word2Vec의 확장이라고 볼 수 있으나, 차이점은 Word2Vec는 단어를 쪼개질 수 없는 단위로 생각한다면, FastText는 하나의 단어 안에 여러 단어들이 존재하는 것으로 간주함. 내부 단어 즉 서브워드를 고려하여 학습.

> 내부 단어(subword)의 학습

- FastText에서는 각 단어는 글자 단위 n-gram의 구성으로 취급. n을 몇으로 결정하는 지에 따라서 단어들이 얼마나 분리되는 지 결정. 예를 들어 n을 3으로 잡은 트라이그램의 경우, apple은 app, ppl, ple로 분리하고 이들을 벡터로 만듦. 더 정확히는 시작과 끝을 의미하는 <,>를 도입하여 아래의 5개 내부 단어 (subword) 토큰을 벡터로 만듦.
- n=3인 경우, <ap, app, ppl, ple, le> => 내부단어 벡터. 여기에 추가적으로 기존 단어에 <와 >를 붙인<apple> 토큰을 벡터화함.
- 실제 사용할 때 n의 최소값과 최대값으로 범위를 지정할 수 있는데, 기본값으로는 각각 3과 6으로 설정되어져 있음. 최소값 3, 최대값 6인 경우 단어 apple에 대해서 FastText가 벡터화한 내부단어 => <ap, app, ppl, ple, le>, <app, appl, pple, ple>, <appl, pple>, ..., <apple>
- 내부단어들을 벡터화한다는 것은 그 단어들에 대해 Word2Vec을 수행한다는 것. 위와 같이 내부단어들의 벡터값을 얻었다면, 단어 apple의 벡터값은 저 위 벡터값들의 총 합. => apple = <ap+app+ppl+ple+le> + <app+appl+pple+ple> + <appl+pple> +, ..., + <apple>

> 모르는 단어(Out of Vocabulary, OOV)에 대한 대응

- FastText의 인공 신경망을 학습한 후에는 데이터 셋의 모든 단어의 각 n-gram에 대해서 워드 임베딩이 됨. => 데이터 셋이 충분하다면 내부 단어를 통해 모르는 단어에 대해서도 다른 단어와의 유사도를 계산할 수 있음.
- 예를 들어, FastText에서 birthplace(출생지)란 단어를 학습하지 않은 상태인데, 다른 단어에서 birth와 place라는 내부 단어가 있었다면, FastText는 birthplace의 벡터를 얻을 수 있음. 이는 모르는 단어에 제대로 대처할 수 없는 Word2Vec, Glove와 다른 점.

> 단어 집합 내 빈도 수가 적었던 단어(Rare Word)에 대한 대응

- Word2Vec의 경우 등장 빈도 수가 적은 단어에 대해서 임베딩의 정확도가 높지 않다는 단점이 있음.
- FastText의 경우, 희귀 단어라도 그 단어의 n-gram이 다른 단어의 n-gram과 겹치는 경우라면 비교적 높은 임베딩 벡터값을 얻을 수 있음
- 노이즈가 많은 코퍼스에서 강점을 가지는 것도 같은 이유. 실제 많은 비정형 데이터에는 오타나 맞춤법이 틀린 단어가 섞여있는데, 이 단어는 희귀 단어가 됨. 이런 단어의 경우 Word2Vec에서는 임베딩이 제대로 되지 않지만 FastText는 이에 대해서도 일정 수준의 성능을 보임
- Word2Vec는 모르는 단어에 대해서는 임베딩 벡터가 존재하지 않기에 단어의 유사도를 계산할 수 없지만, FastText는 유사한 단어를 계산하여 출력할 수도 있음.

09-08 사전 훈련된 워드 임베딩(Pre-trained Word Embedding)

> 케라스 임베딩 층

: 케라스 Embedding() : 인공 신경망 구조 관점에서 임베딩 층을 구현함

- 1) 임베딩 층은 룩업 테이블 : 임베딩 층의 입력으로 사용하기 위해서 입력 시퀀스의 각 단어들은 모두 정수 인코딩이 되어 있어야 함.
- 어떤 단어 -> 단어에 부여된 고유한 정수값(ex. 1, 127, 298,...) -> 임베딩 층 통과 -> 밀집 벡터 (ex. [0.5,21,1.9,1.5] <-임베딩 벡터의 차원이 4인 경우)
- NNLM이나 Word2Vec에서 룩업 테이블의 입력을 원-핫 벡터로 가정했는데, 케라스는 단어를 정수 인덱스로 바꾸고 원-핫 벡터 변환 없이 정수 인코딩까지만 진행 후 입력으로 사용함.
- vocab_size = 텍스트 데이터의 전체 단어 집합 크기. output_dim = 워드 임베딩 후의 임베딩 벡터의 차원. input_length = 입력 시퀀스의 길이.
- Embedding()은 (number of samples, input_length)인 2D 정수 텐서를 입력으로 받고, (이때 각 sample은 정수 인코딩이 된 정수 시퀀스) 워드 임베딩 작업을 수행한 후 (number of samples, input_length, embedding word dimentionality)인 3D 실수 텐서를 리턴.
- 2) 임베딩 층 사용하기 : 문장의 긍, 부정을 판단하는 감성 분류 모델을 만들어보자. 긍정인 문장은 레이블이 1, 부정인 문장은 레이블이 0.
- 이진분류 모델 설계. 출력층에 1개의 뉴런, 활성화 함수는 시그모이드 함수, 손실함수로 binary_crossentropy를 사용.

> 사전 훈련된 워드 임베딩 사용하기

- 훈련 데이터가 적은 상황이라면 케라스의 Embedding()으로 문제를 풀기 어려움. 이 경우 해당 문제에 특화된 것은 아니지만 보다 많은 훈련 데이터로 이미 Word2Vec나 GloVe 등으로 학습되어 있는 임베딩 벡터들을 사용하는 것이 좋음.

- 1) 사전 훈련된 GloVe 사용하기

from urllib.request import urlretrieve, urlopen
import gzip
import zipfile
urlretrieve("http://nlp.stanford.edu/data/glove.6B.zip", filename="glove.6B.zip")
zf = zipfile.ZipFile('glove.6B.zip')
zf.extractall() 
zf.close()

2) 사전 훈련된 Word2Vec 사용하기

import gensim
!pip install gdown
!gdown https://drive.google.com/uc?id=1Av37IVBQAAntSe1X3MOAl5gvowQzd2_j
word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin.gz', binary=True)
print('모델의 크기(shape) :',word2vec_model.vectors.shape) # 모델의 크기 확인

09-09 옐모(Embeddings from Language Model, ELMo)

: 언어 모델로 하는 임베딩. => 사전 훈련된 언어 모델을 사용한다는 것이 가장 큰 특징.

> ELMo

- Bank라는 단어가 Bank Account (은행 계좌)와 River Bank (강둑)에서 전혀 다른 의미를 가짐. 그러나 Word2Vec이나 Glove은 bank 단어를 두 경우 모두 같은 임베딩 벡터로 표현. (ex. [0.2, 0.8, -1.2])
- 워드 임베딩 시 문맥을 고려해서 임베딩 하겠다는 이 아이디어 => 문맥을 반영한 워드 임베딩(Contextualized Word Embedding).

> BiLM (Bidirectional Language Model)의 사전 훈련

- ELMo는 순방향 RNN과 역방향 RNN을 모두 학습하여 활용한다고 하여, 이 언어 모델을 biLM이라고 함.
- ELMO에서 말하는 biLM은 기본적으로 다층 구조(Multi-layer)를 전제로 함. (은닉층이 2개 이상)
- 각 시점의 입력이 되는 단어 벡터는 (이번 챕터에서 설명한) 임베딩 층을 사용해서 얻은 것이 아니라 합성곱 신경망을 이용한 문자 임베딩을 통해 얻은 단어 벡터.
- 양방형 RNN과 ELMo에서의 biLM은 다름. 양방향 RNN은 순방향 RNN의 은닉 상태와 역방향 RNN의 은닉 상태를 연결하여 다음 층의 입력으로 사용하지만, biLM은 순방향 언어모델과 역방향 언어모델이라는 두개의 언어모델을 별개의 모델로 보고 학습.

> biLM의 활용

- 단어임베딩과정 : 해당 시점의 BiLM의 각 층의 출력값(첫번째는 임베딩 층, 나머지 층은 각 층의 은닉 상태)을 가져옴 → 순방향 언어 모델과 역방향 언어 모델의 각 층의 출력값을 연결하고 추가 작업 진행.
- ELMo의 직관적인 아이디어는 '각 층의 출력값이 가진 정보는 전부 서로 다른 종류의 정보를 갖고 있을 것'이므로, 이들을 모두 활용한다는 점에 있음.
- ELMo가 임베딩 벡터를 얻는 과정 : 1) 각 층의 출력값을 연결한다. 2) 각 층의 출력값 별로 가중치를 준다. (s1, s2, s3,...) 3) 각 층의 출력값을 모두 더한다. (가중합) 4) 벡터의 크기를 결정하는 스칼라 매개변수를 곱한다. => 완성된 벡터를 ELMo 표현이라고 함.
- ELMo 표현을 기존의 임베딩 벡터와 함께 사용할 수 있음. 텍스트 분류 작업을 위해서 GloVe와 같은 기존의 방법론을 사용한 임베딩 벡터를 준비했다고 하자. 이때, GloVe를 사용한 임베딩 벡터만 텍스트 분류 작업에 사용하는 것이 아닌, 준비된 ELMo 표현을 GloVe 임베딩 벡터와 연결해서 입력으로 사용할 수 있음. 이때 biLM의 가중치는 고정하고 위에서 사용한 가중치(s1,s2,s3)와 스칼라 매개변수가 훈련과정에서 학습됨.

09-10 임베딩 벡터의 시각화

: 구글은 임베딩 프로젝터(Embedding projetor)라는 데이터 시각화 도구 지원

> 워드 임베딩 모델로부터 2개의 tsv 파일 생성

- 시각화를 위해서는 이미 모델을 학습하고, 파일로 저장되어져 있어야 함. 모델이 저장되어 있다면 아래 커맨드를 통해 시각화에 필요한 파일들을 생성할 수 있음. -> !python -m gensim.scripts.word2vec2tensor -- input 모델이름 --output 모델이름
- 커맨드를 수행하면, 주피터 노트북이 시작되는 경로에 기존에 있던 언어모델 외에도 두 개의 파일이 생김. (모델이름_metadata.tsv, 모델이름_tensor.tsv)

> 임베딩 프로젝터를 사용하여 시각화 (https://projector.tensorflow.org/)
- 사이트의 좌측 상단을 보면 Lad라는 버튼이 있음. 거기에 만들어진 두 파일을 업로드하면, 워드 임베딩 모델이 시각화 됨.
- 그 후 임베딩 프로젝터에서 다양한 기능을 사용할 수 있음. 차원을 축소하여 시각화 할 수 있도록 도와주는 PCA, t-SNE 등이 제공되고, 특정 단어의 코사인 유사도를 기준으로 가장 유사한 상위 n개의 벡터를 표시할 수도 있음.

09-11 문서 벡터를 이용한 추천 시스템 (Recommendation System using Document Embedding)

- 문서들을 고정된 길이의 벡터로 변환한다면, 벡터 간의 비교로 문서들을 서로 비교할 수 있음.
- 각 문서를 문서 벡터로 변환하는 방법은 이미 구현된 패캐지인 Doc2Vec이나 Sent2Vec 등을 사용하여 학습할 수도 있지만 단어 벡터를 얻은 뒤 문서에 존재하는 단어 벡터들의 평균을 문서 벡터로 간주할 수도 있음.
- 이번에는 문서 내 각 단어들을 WordVec을 통해 단어 벡터로 변환하고, 이들의 평균으로 문서 벡터를 얻어 선호하는 도서와 유사한 도서를 찾아주는 도서 추천 시스템을 만들어 보겠음.

참고한 논문이 많이 나와 있어서 그 논문들을 읽기 시도 중! 논문을 다 읽게 되면 리뷰 한 번 올려봐야지(‾◡◝)

[딥러닝을 이용한 자연어 처리 입문] Chapter 6. 머신 러닝 개요

빈이즈 — Fri, 26 Jul 2024 09:26:48 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/21669

06. 머신 러닝(Machine Learning) 개요

머신 러닝은 영상 처리, 번역기, 음성 인식, 스팸 메일 탐지 등 굉장히 다양한 분야에서 응용되고 있습니다. 특히 머신 러닝의 한 갈래인 딥 러닝은 자연어 처리 엔지니어에게 필수…

wikidocs.net

06. 머신 러닝 (Machine Learning) 개요

06-02. 머신 러닝 훑어보기

> 자기지도 학습

- 레이블이 없는 데이터가 주어지면, 모델이 학습을 위해서 스스로 데이터로부터 레이블을 만들어서 학습하는 경우
- EX) Word2Vec (워드 임베딩 알고리즘), BERT (언어 모델의 학습 방법)

> 혼동 행렬

- True Positive (TP) : 실제 True인 정답을 True라고 예측 (정답)
- False Positive (FP) : 실제 False인 정답을 True라고 예측 (오답)
- False Negative (FN) : 실제 True인 정답을 False라고 예측 (오답)
- True Negative (TN) : 실제 False인 정답을 False라고 예측 (정답)
- 정밀도 : 모델이 True라고 예측한 것 중 실제 True인 것의 비율
- 재현율 : 실제 True인 것 중 모델이 True라고 예측한 것의 비율
- 정확도 = 전체 예측 데이터 중 정답을 맞춘 것에 대한 비율

06-03 선형 회귀

> 옵티마이저 : 경사하강법

- 비용함수를 최소화하는 매개 변수를 찾기 위해 사용하는 알고리즘
- 접선의 기울기가 0이 되는 지점 (=미분값이 0이 되는 지점)을 찾는 것.
- learning rate (학습률) : 가중치의 값을 변경할 때, 얼마나 크게 변경할지를 결정하며 0과 1 사이의 값을 가짐.

06-08 벡터와 행렬 연산

>텐서 (Tensor)

- 0차원 텐서 (스칼라) : 하나의 실수값으로 이루어진 데이터
- 1차원 텐서 (벡터) : 숫자를 배열한 것.
- 2차원 텐서 (행렬) : 행과 열이 존재하는 벡터의 배열.
- 3차원 텐서 (다차원 배열) : 행렬 또는 2차원 텐서를 단위로 한 번 더 배열하면 3차원 텐서라고 부름. 3차원 이상의 텐서부터 본격적으로 텐서라고 부름.
시퀀스 데이터를 표현할 때 자주 사용됨. 여기서 시퀀스 데이터는 주로 단어의 시퀀스를 의미하며, 문장이나 문서 뉴스 기사 등의 텍스트가 될 수도 있음. 이 경우 3D 텐서는 (samples, timesteps, word_dim)이 됨. 또는 일괄로 처리하기 위해 데이터를 묶는 단위인 배치의 개념을 사용하면 (batch_size, timesteps, word_dim)이라고 볼 수 있음.

> 케라스에서의 텐서

- input_shape : 신경망의 층에 입력의 크기를 인자로 줄 때 사용. 배치크기를 제외하고 차원을 지정함. 예를 들어, input_shape(6,5)라는 인자값을 사용하면 텐서의 크기는 (?, 6,5)을 의미함. 배치크기는 지정하기 전까지 알 수 없음. 만약 배치 크기까지 지정해주고 싶다면, batch_input_shape = (8,2,10)과 같이 인자를 주면 텐서의 크기는 (8, 2, 10)을 의미함.

06-09 소프트맥스 회귀

> 소프트맥스 함수

- 선택해야 할 선택지의 개수가 k개라면, k차원의 벡터를 입력받아 각 클래스에 대한 확률을 추정함.

> 원-핫 벡터의 무작위성.

- 대부분의 다중 클래스 분류 문제가 각 클래스 간의 관계가 균등하다는 점에서 원-핫 벡터가 적절한 표현 방식임.
- 단어의 유사성을 구할 수 없다는 단점을 가짐

> 비용 함수

- 크로스 엔트로피 함수 : cost = -1/n * sigma(i=1->n)*sigma(j=1 -> k) yj(i) * log(pj(i))
(n : 데이터의 개수, yj : j번째 실제값, pj : j번째 클래스일 확률). 정확히 예측했을 경우 0이 됨. 이 값이 최소화되는 방향으로 학습해야 함.
- k=2로 둔다면, 로지스틱 회귀의 비용 함수와 같음

[딥러닝을 이용한 자연어 처리 입문] Chapter 4. 카운트 기반의 단어 표현 - Chapter 5. 벡터의 유사도

빈이즈 — Mon, 22 Jul 2024 10:16:53 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/24557

04. 카운트 기반의 단어 표현(Count based word Representation)

자연어 처리에서 텍스트를 표현하는 방법으로는 여러가지 방법이 있습니다. 이번 챕터에서는 그 중 정보 검색과 텍스트 마이닝 분야에서 주로 사용되는 카운트 기반의 텍스트 표현 방법인…

wikidocs.net

https://wikidocs.net/24602

05. 벡터의 유사도(Vector Similarity)

문장이나 문서의 유사도를 구하는 작업은 자연어 처리의 주요 주제 중 하나입니다. 사람들이 인식하는 문서의 유사도는 주로 문서들 간에 동일한 단어 또는 비슷한 단어가 얼마나 공통적…

wikidocs.net

04. 카운트 기반의 단어 표현

04-01 다양한 단어의 표현 방법

> 단어의 표현 방법

- 크게 국소 표현과 분산 표현 방법으로 나뉨
- 국소 표현 방법 : 해당 단어 그 자체만 보고 특정값을 맵핑하여 단어를 표현. 이산 표현이라고도 함.
- 분산 표현 방법 : 그 단어를 표현하고자 주변을 참고하여 단어를 표현, 연속 표현이라고도 함.
- EX. puppy, cute, lovely => 1,2,3으로 맵핑하는 것이 국소 표현 방법. puppy라는 단어 근처에 주로 cute, lovely한 느낌이다로 단어를 정의하는 것이 분산 표현 방식.

04-02 Bag of Words (BoW)

> Bag of Words

-단어들의 가방이라는 뜻으로, 가방에 텍스트 문서에 있는 단어들을 전부 넣고 흔들어 섞습니다. 만약, 해당 문서 내에서 특정 단어가 N번 등장했다면 이 가방에는 N개가 존재합니다. 섞었기 때문에 더이상 순서는 중요하지 않습니다.
- 단어들의 순서는 고려하지 않고, 단어들의 출현 빈도에만 집중하는 텍스트 데이터의 수치화 표현 방법.
- 과정 : 1) 각 단어에 고유한 정수 인덱스 부여 2) 각 인덱스의 위치에 단어 토큰의 등장 횟수를 기록한 벡터 만듦
- EX1. "정부가 발표하는 물가상승률과 소비자가 느끼는 물가상승률은 다르다.
=> '정부' : 0, '가' :1, '발표' : 2, ... 이런식으로 인덱스를 매키고, 각 인덱스별 빈도수 {1,2,1,1,...}를 구함
- 주로 어떤 단어가 얼마나 등장했는지를 기준으로 문서가 어떤 성격의 문서인지를 판단하는 작업에 쓰임. 즉 분류 문제, 여러 문서 간의 유사도 구하는 문제에 주로 쓰임. EX) '달리기', '체력', '근력'과 같은 단어가 자주 등장하면 해당 문서를 체육 관련 문서로 분류할 수 있을 것.

> 사이킷런 CountVectorizer 클래스로 BoW 만들기

- CountVectorizer : 단어의 빈도를 Count하여 Vector로 만드는 클래스.
- 기본적으로 길이가 2이상인 문자에 대해서만 토큰으로 인식. (영어는 주로 짧으면 불용어로 취급하기 때문)
- 띄어쓰기를 기준으로 단어를 자르기 때문에 한국어에 적용 X

> 불용어를 제거한 BoW 만들기

- CountVectorizer에서 stop_words = [] 라는 인수를 사용하여 불용어를 직접 지정할 수 있음
- stop_words = 'english'를 사용하여 자체적으로 제공하는 불용어 사용 가능
- NLTK에서 지원하는 불용어 사용방법 : stopwords.words("english")

04-03 문서 단어 행렬(Document-Term Matrix, DTM)

* 행과 열을 반대로 선택하면 TDM이라고 부르기도 함

> 문서 단어 행렬(DTM) 표기법

- 문서 단어 행렬 : 다수의 문서에서 등장하는 각 단어들의 빈도를 행렬로 표현한 것.
- BoW 표현을 다수의 문서에 대해서 행렬로 표현하고 부르는 용어.

> DTM의 한계

- 희소 표현 : 전체 코퍼스가 방대한 데이터라면, 문서 벡터의 차원은 수만 이상의 차원을 가질 수 있음. 또한 많은 문서 벡터가 대부분의 값이 0이 될 수 있음. => 구두점, 빈도수가 낮은 단어, 불용어 제거, 어간이나 표제어 추출을 통한 단어의 정규화를 통해 단어 집합의 크기를 줄이는 것이 중요.
- 단순 빈도 수 기반 접근 : 영어의 불용어인 the는 어떤 문서든 자주 등장하는데, 똑같이 the의 빈도수가 높다고 해서 유사한 문서라고 판단해서는 안됨.
- 불용와 중요한 단어에 대해서 가중치를 줄 수 있는 방법 => TF-IDF

04-04 TF-IDF (Term Frequency-Inverse Document Frequency)

: 각 단어에 대한 중요도를 계산할 수 있는 TF-IDF 가중치.

> TF-IDF(단어 빈도-역 문서 빈도)

-TF-IDF : 단어의 빈도와 역 문서 빈도(문서의 빈도에 특정 식을 취함)를 사용하여 DTM 내의 각 단어들마다 중요한 정도를 가중치로 주는 방법.
- TF와 IDF를 곱한 값을 의미.
- 문서를 d, 단어를 t, 문서의 총 개수를 n이라고 표현할 때, TF, DF, IDF는 다음과 같이 정의 가능
- tf(d,f) : 특정 문서 d에서의 특정 단어 t의 등장 횟수
- df(t) : 특정 단어 t가 등장한 문서의 수
- idf(t) : df(t)에 반비례하는 수. df(t)+1에 역수를 취하고 문서의 총개수 n을 곱한 값에 log를 취해줌
- 모든 문서에 자주 등장하는 단어는 중요도가 낮다고 판단, 특정 문서에만 자주 등장하는 단어는 중요도가 높다고 판단. => TF-IDF 값이 클수록 중요도가 큰 것.
- 전체 문서수 n이 4인데, df(t) 값이 3인 경우, df(t)에 1을 더한 값이 4가 되고, 4를 4로 나눈 값인 1에 log를 취하면 값이 0이 되면서 가중치 역할을 수행하지 못함. => 사이킷런의 TF-IDF는 조정된 식 사용

> 사이킷런 DTM, TF-IDF

- CountVectorizer : DTM 만들기
- TfidfVectorizer : TF-IDF 자동 계산. 조정된 식을 사용함. IDF의 로그 항의 분자에 1을 더하고 로그항에 1을 더해주고, TF-IDF에 L2 정규화라는 방법으로 값을 조정.

05. 벡터의 유사도

05-01 코사인 유사도 (Cosine Similarity)

> 코사인 유사도

- -1이상 1 이하의 값을 가지며, 1에 가까울 수록 유사도가 높다고 판단
- 벡터의 방향(패턴)에 초점을 두므로, 문서의 길이가 다른 상황에서 비교적 공정한 비교를 할 수 있음.

05-02 여러가지 유사도 기법

> 유클리드 거리

- 문서의 유사도를 구할 때, 자카드 유사도나 코사인 유사도만큼 유용하지는 않음
- 직전상의 거리 구하는 공식

> 자카드 유사도

- 합집합에서 교집합의 비율을 사용하여 유사도를 구함

[딥러닝을 이용한 자연어 처리 입문] Chapter 3. 언어 모델 (Language Model)

빈이즈 — Fri, 19 Jul 2024 12:13:50 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/21695

03. 언어 모델(Language Model)

언어 모델(Languagel Model)이란 단어 시퀀스(문장)에 확률을 할당하는 모델을 말합니다. 어떤 문장들이 있을 때, 기계가 이 문장은 적절해! 이 문장은 말이 안 돼! …

wikidocs.net

03-01 언어모델(Language Model)이란?

> 언어 모델을 만드는 방법

1) 통계를 이용하는 방법
2) 인공신경망을 이용하는 방법 : 더 좋은 성능을 보임 ex. GPT, BERT

> 언어 모델 (Language Model)

- 단어 시퀀스(문장)에 확률을 할당하는 일을 하는 모델로 가장 자연스러운 단어 시퀀스를 찾아냄.
- 보편적으로 사용되는 방법은 이전 단어들이 주어졌을 때 다음 단어를 예측하도록 하는 것이고, 그 외에도 양쪽의 단어로부터 가운데 비어있는 단어를 예측하는 언어 모델도 있음 (BERT)

> 단어 시퀀스의 확률 할당

(* P : 확률을 의미함)

a. 기계 번역(Machine Translation) :
P(나는 버스를 탔다) > P(나는 버스를 태운다)
: 언어 모델은 두 문장을 비교하여 좌측의 문장의 확률이 더 높다고 판단
b. 오타 교정 (Spell Correction)
선생님이 교실로 부리나케
P(달려갔다) > P(잘려갔다)
: 언어 모델은 두 문장을 비교하여 좌측의 문장의 확률이 더 높다고 판단
c. 음성 인식(Speech Recognition)
P(나는 메롱을 먹는다) < P(나는 메론을 먹는다)
: 언어 모델은 두 문장을 비교하여 우측의 문장의 확률이 더 높다고 판단

=> 언어 모델은 확률을 통해 보다 적절한 문장을 판단한다

03-02 통계적 언어 모델(Statistical Language Model, SLM)

> 문장에 대한 확률

- 조건부 확률을 사용하여 구함
- 각 단어들이 이전 단어가 주어졌을 때 다음 단어로 등장할 확률의 곱

> 카운트 기반의 접근

- 예를 들어 An adorable little boy 다음에 is가 나올 확률을 카운트 기반으로 구한다면 An adorable little boy is의 빈도수를 An adorable little boy의 빈도수를 나누어서 구함
- 한계 : 방대한 양의 데이터가 필요함. => 충분한 데이터를 관측하지 못하여 언어를 정확히 모델링하지 못하는 '희소 문제(sparsity problem)이 발생할 수 있음.
- 희소 문제를 완화하는 방법 : n-gram 언어 모델, 스무딩, 백오프 (희소문제에 대한 근본적인 해결책X)

03-03 N-grm 언어 모델 (N-gram Language Model)

: SLM의 일종. 일부 단어만 고려하는 접근 방법. 몇 개의 단어를 보느냐를 정해야 하는데, n-gram에서 n이 결정함.

>N-gram

- n=1일 때 유니그램(unigram), 2일 때, 바이그램(bigram), 3일 때, 트라이그램(trigram)이라고 하고 4 이상일 때는 4-gram, 5-gram, ... 라고 함.
- n-gram을 통한 언어 모델에서는 다음에 나올 단어를 예측할 때, n-1개의 단어에만 의존. 예를 들어, 'An adorable little boy is spreading' 다음에 올 단어를 예측하고자 하는데, 4-gram을 이용한 언어 모델을 사용한다면, boy is spreading (3개 단어) 만 고려.

> 한계점

- 희소문제(Sparsity problem)
- n을 선택하는 trade-off 문제 : n이 클수록 대부분의 경우에서 성능이 높아짐. 하지만 n이 커질수록 n-gram에서 카운트할 수 있는 확률이 적어지므로 희소문제가 심각해지고, 모델 사이즈가 커짐. n이 작을 수록 근사의 정확도는 현실의 확률분포와 멀어짐. => n은 최대 5를 넘게 잡아서는 안 된다고 권장.

03-04 한국어에서의 언어 모델

1) 한국어는 어순이 중요하지 않음
2) 한국어는 교착어 =>접사나 조사 등을 분리해야 함
3) 띄어쓰기가 제대로 지켜지지 않음

03-05 펄플렉서티(Perplexity, PPL)

: 모델 내에서 자신의 성능을 수치화하여 결과를 내놓음

> 언어 모델의 평가방법 : PPL

- 펄플렉서티(perplexity, PPL)는 '헷갈리는'과 유사한 의미를 가진 단어. PPL은 '헷갈리는 정도'로 이해하자.
- 수치가 낮을수록 언어 모델의 성능이 좋음
- PPL = 선택할 수 있는 가능한 경우의 수를 의미하는 분기계수(branching factor). 즉 이 언어 모델이 특정 시점에서 평균적으로 몇 개의 선택지를 가지고 고민하고 있는 지를 의미.

[딥러닝을 이용한 자연어 처리 입문] Chapter 2. 텍스트 전처리

빈이즈 — Thu, 18 Jul 2024 20:38:04 +0900

이 글은 [유원준, 상준]의 [딥러닝을 이용한 자영어 처리 입문]에서 가져온 내용이며, [크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스](https://creativecommons.org/licenses/by-nc-sa/2.0/kr/)에 따라 사용되었습니다.

https://wikidocs.net/21694

02. 텍스트 전처리(Text preprocessing)

텍스트 전처리는 풀고자 하는 문제의 용도에 맞게 텍스트를 사전에 처리하는 작업입니다. 요리를 할 때 재료를 제대로 손질하지 않으면, 요리가 엉망이 되는 것처럼 텍스트에 제대로 전…

wikidocs.net

2. 텍스트 전처리

02-01 토큰화

> Penn Treebank Tokenization

- 규칙 1. 하이푼으로 구성된 단어는 하나로 유지
- 규칙 2. doesn't와 같이 아포스트로피로 '접어'가 함께하는 단어는 분리해 준다.

> 문장 토큰화

- 영어 : NLTK (sent_tokenize)
- 한국어 : kss.
- 한국어는 교착어이기에 띄어쓰기 단위로 분류하기 어려움. => 형태소 토큰화가 필요함.

- 또한 띄어쓰기가 제대로 지켜지지 않은 경우가 많음.
- 언어는 품사에 따라 뜻이 달라짐 (fly: 날다, 파리/ 못 : 망치로 박을때 사용, 못 날다 못하다 의 못 => 품사태깅이 필요 (영어 : penn treebank pog tags, 한국어 : KoNLPy 패키지의 Okt, 메캅(속도 빠름), 코모란, 한나눔, 꼬꼬마..)

> KoNLPy 패키지의 형태소 분석기의 공통적인 메소드

- morphs : 형태소 추출
- pos : 품사 태깅
- nouns : 명사 추출

02-02 정제 and 정규화

> 불용어

- 대표적으로 빈도가 적은 단어, 길이가 짧은 단어를 불용어로 많이 지정.
- 짧은 단어는 영어의 경우 불용어로 지정하는 게 많고, 한국어는 짧은 단어로 불용어로 지정하는 것을 추천 X

02-03 어간추출 and 표제어 추출

> 표제어 추출

- 형태학적 파싱 : 어간과 접사를 분리하는 작업
- NLTK의 WordNetLemmatizer : 품사정보를 알려준다면, 정확한 Lemma 출력
- EX. (품사정보 안 알려줄 때) dies -> dy, 알려줄 때, die -> die (코드 : lemmatizer.lemmatize('dies','v')

> 어간추출

- 품사 정보가 보존되지 않음. 사전에 존재하지 않는 단어일 경우가 많은
- 알고리즘 : 포터 알고리즘 (PorterStemmer), 랭커스터 알고리즘(LancasterStemmer)

02-06 정수인코딩

> 정수인코딩

- Counter, FreqDist를 이용하여 단어의 빈도수 구함

- enumerate를 이용하여 인덱스부여하면 쉬움

- most_common을 이용하여 상위 빈도수를 가진 단어만을 리턴할 수 있음 (vocal.most_common(5) : 5개의 상위 단어만)
- keras.tokenizer : 빈도수 순으로 인덱스도 자동 부여됨. word_index를 사용하여 인덱스 확인가능. word_counts를 이용하여 빈도수 확인가능. test_to_sequences()를 이용하면 입력된 코퍼스에 대해 각 단어를 이미 정해진 인덱스로 반환. tokenizer = Tokenizer(num_words=n)와 같은 방법으로 빈도수가 높은 상위 n개의 단어만 사용 가능. oov_token = 'OOV'를 인자로 사용하면, 단어 집합에 없는 단어들을 OOV로 간주(인덱스 1)

02-07 패딩

> 패딩

- 가장 긴 길이를 가진 문서의 길이를 기준으로 패딩을 많이 하지만, 꼭 그럴 필요는 없음. ex. 한 개의 문서의 길이가 5000이고 나머지 문서 길이 평균이 20이라면, 굳이 5천으로 패딩을 하지 않아도 됨.
- 케라스 pad_sequences() : 기본적으로 인자 앞에 0을 채워 넣음. 뒤에 0을 넣고 싶다면, padding = 'post'를 인자로 두면 됨.
- maxlen 인자를 통해 모든 문서의 길이를 정할 수 있음. 기존의 길이가 maxlen 보다 길었던 문서들의 정보는 일부 손실됨. 길이에 맞춰 앞의 단어들이 없어짐. 뒤에 단어가 삭제되도록 하려면 truncating = 'post' 인자 사용.
- value 인자를 통해 패딩의 숫자를 결정할 수 있음. 기본 값은 0 (제로패딩)

02-08 원-핫 인코딩

> 케라스 원핫인코딩

- to_categorical() 사용
- 비효율적인 저장공간. 5000개의 단어가 있다면 5000개의 벡터가 필요.

- 단어의 잠재 의미를 반영하여 다차원 공간에 벡터화하는 기법을 사용하는 것이 좋음

- 1) 카운트 기반의 벡터화 방법 : LAS(잠재 의미 분석), HAL. 2) 예측 기반의 벡터화 방법 : NNLM, RNNLM, Word2Vec, FastText. 3) 카운트 기반과 예측 기반 모두 사용하는 방법 : GloVe

02-10 한국어 전처리 패키지

- 형태소와 문장 토크나이징 도구 : KoNLPy, KSS

> PyKoSpacing

: 띄어쓰기가 되지 않은 문장을 띄어쓰기해줌

> Py-Hanspell

: 맞춤법 검사. 띄어쓰기 또한 보정.

> SOYNLP

: 품사 태깅, 단어 토큰화 등을 지원하는 단어 토크나이저. 비지도 학습으로 단어 토큰화 수행. 내부적으로 단어 점수 표로 동작함. 이 점수는 응집 확률과 브랜칭 엔트로피를 활용

1) 신조어 문제 해결
: 기존의 형태소 분석기는 신조어나 형태소 분석기에 등록되지 않은 단어를 제대로 구분 못함 -> SOYNLP는 특정 문자 시퀀스가 빈도가 높고, 앞 뒤로 조사 또는 완전히 다른 단어가 등장한다면 한 단어로 취급함. 신조어를 그런 식으로 구분할 수도 있음.

2) 학습
- WordExtractor() : 전체 코퍼스에 대해 단어 점수표를 계산

3) 응집 확률 : 내부 문자열이 얼마나 응집하여 자주 등장하는 지를 판단하는 척도. 각 문자열이 주어졌을 때 그다음 문자가 나올 확률을 계산하여 누적곱을 한 것입니다. 이 값이 높을수록 전체 코퍼스에서 이 문자열 시퀀스는 하나의 단어로 등장할 확률이 높습니다.

4) 브랜칭 엔트로피 : 확률 분포에 엔트로피 값 사용. 주어진 문자 시퀀스에서 다음 문자 예측을 위해 헷갈리는 정도로 비유할 수도 있음. 하나의 완성된 단어에 가까워질수록 점수가 점점 줄어드는 양상을 보임. -> 이 값을 통해 단어를 판단할 수 있음

5) L tokenizer : 띄어쓰기 단위로 나는 어절 토큰은 주로 L 토큰 + R 토큰의 형식을 가질 때가 많음. 예를 들면 '공원에'는 공원 + 에. L토크나이저는 L토큰 + R토큰으로 나누되, 분리기준을 가장 높은 L 토큰을 찾아내는 원리를 갖고 있음.

6) 최대 점수 토크나이저 : 띄어쓰기가 되지 않은 문장에서 점수가 높은 글자 시퀀스를 순차적으로 찾아내는 토크나이저.

> Customized KoNLPY

- 형태소 분석기 Twitter을 사용하여 단어 토큰화
- Twitter에 add_dictionary('단어', '품사')와 같은 형식으로 사전을 추가할 수 있음.
- EX) twitter.add_dictionary('은경이','Noun') -> 은경이를 하나의 토큰으로 인식함. 띄어쓰기할 때 은경이를 붙여서 사용.

7월 말에 데이콘에 자연어 처리 질의 응답 공모전이 있어서 참가해 보고자 자연어 처리 공부 시작! 1-2일에 한 챕터씩 끝내보자. (●'◡'●)