RNN - 딥러닝을 이용한 문서 분류(2)

💡(1)편에서는 RNN에 대해서 알아봤습니다. 이 글에서는 이를 활용해 문서를 분류하는 과정을 살펴보도록 하겠습니다.
실습 데이터로는 NLTK 영화 리뷰를 사용하도록 하겠습니다.
(1)편 링크 : https://jungnerd.tistory.com/4

NLTK 영화 리뷰 감성 분석

워드 임베딩을 위한 데이터 준비

from nltk.corpus import movie_reviews
fileids = movie_reviews.fileids() #movie review data에서 file id를 가져옴
reviews = [movie_reviews.raw(fileid) for fileid in fileids] #file id를 이용해 raw text file을 가져옴
categories = [movie_reviews.categories(fileid)[0] for fileid in fileids] 
#file id를 이용해 label로 사용할 category 즉 positive와 negative 정보를 순서대로 가져옴

print('Reviews count:', len(reviews))
print('Length of the first review:', len(reviews[0]))
print('Labels:', set(categories))

Reviews count: 2000
Length of the first review: 4043
Labels: {'neg', 'pos'}

먼저 NLTK 데이터를 불러와서 리뷰는 reviews에, 긍정 부정에 대한 라벨은 categories에 저장합니다.

결괏값을 보면, 총 리뷰의 개수는 2,000개이고 첫 번째 리뷰는 4043개의 단어로 이루어져 있음을 알 수 있습니다.

 

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
np.random.seed(7)
tf.random.set_seed(7)

max_words = 10000 #사용할 단어의 수

# 빈도가 높은 10000개의 단어를 선택하도록 객체 생성
tokenizer = Tokenizer(num_words=max_words, oov_token='UNK') 

tokenizer.fit_on_texts(reviews) #단어 인덱스 구축

#만들어진 단어 인덱스를 이용해 문서들을 변환
X = tokenizer.texts_to_sequences(reviews) 

print('Lengths of first 10 documents:', [len(doc) for doc in X[:10]])

Lengths of first 10 documents: [710, 240, 486, 479, 733, 671, 550, 584, 702, 776]

먼저 Numpy와 Tensorflow를 임포트 합니다.

 

뒤에서 RNN 모형을 케라스를 이용해서 구축할 것이기 때문에 Keras가 제공하는 토크나이저를 사용해

RNN 모형에 적합한 형태로 입력 데이터를 변환하겠습니다.

Tokenizer 객체를 생성할 때, num_words를 이용해서 모형에 사용할 단어 수를 결정할 수 있습니다. 여기에서는 사용할 단어의 수를 10,000개로 설정하겠습니다. 이때, 실제 말뭉치에 사용된 단어 수가 10,000개 보다 큰 경우에는 사전에 없는 단어를 빼고 시퀀스를 생성하게 됩니다. 이런 사전에 없는 단어들을 생략하고 싶지 않다면, oov_token을 이용해 이 단어들을 변환할 문자열을 할당할 수 있습니다.

여기서는 사전에 없는 단어들을 모두 unknown의 약자인 UNK로 변환시키겠습니다. 

 

fit_on_texts를 수행하면 reviews에 있는 단어들에 대해 단어 인덱스 사전이 생성됩니다.

그 후에 texts_to_sequence를 수행하면 이 단어 인덱스 사전을 이용해 문서들을 인덱스의 시퀀스로 변환합니다.

print("Index of 'the':", tokenizer.word_index["the"])
print("Index of 'review':", tokenizer.word_index["two"])
print("Index of out-of-vocabulary words:", tokenizer.word_index["UNK"])

Index of 'the': 2
Index of 'review': 77
Index of out-of-vocabulary words: 1

토크나이저가 생성한 사전에서 단어의 인덱스를 확인해보겠습니다.

위의 코드에서 보시면 단어 'the'의 인덱스가 '2'인 것을 볼 수 있습니다.

실제로 확인해보면, 문서의 'the' 부분이

이렇게 2로 나타낸 것을 볼 수 있습니다.

 

from tensorflow.keras.preprocessing.sequence import pad_sequences

maxlen = 500 #문서의 단어 수를 제한

# 문서의 단어 수가 500보다 작으면 0을 채우고, 크면 잘라냄
# 잘라낼 때, 앞을 자를 지, 뒤를 자를 지 선택할 수 있음. 앞을 자르고 뒷부분을 쓰고자 하면 'pre' 선택. 
# 뒷부분을 자르고 싶으면 'post' 선택
X = pad_sequences(X, maxlen=maxlen, truncating='pre')

import numpy as np

# label을 0, 1의 값으로 변환
label_dict = {'pos':1, 'neg':0}
y = np.array([label_dict[c] for c in categories])
print(set(y))

{0, 1}

신경망 모형의 입력은 길이가 일정해야 하는데 각 리뷰의 길이가 다르므로 pad_sequence를 이용해 모든 입력 시퀀스의 길이를 매개변수 maxlen의 인수만큼 동일하게 변환합니다. 이 실습에서는 시퀀스의 길이를 500으로 하겠습니다. 

만약 입력 데이터의 길이가 500보다 크다면 남는 부분을 잘라내야 하는데, 앞을 자르고 뒤를 사용하고 싶으면 truncating의 값을 'pre'로, 끝을 자르고 앞을 사용하고 싶다면 'post'를 선택하면 됩니다. 

그리고 출력 데이터도 Keras의 이진 분류 모형은 0과 1의 값을 요구하기 때문에 positive를 1로, negative를 0으로 변환합니다.

 

from sklearn.model_selection import train_test_split 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=10)

print('Train set count:', len(X_train))
print('Test set count:', len(X_test))
print('Test samples:', y_test[:20])

Train set count: 1600
Test set count: 400
Test samples: [0 1 1 0 1 1 0 0 0 0 1 1 0 0 1 0 0 1 1 1]

모형을 검증하기 위해 다음과 같이 test_size를 0.2로 설정해 총 데이터셋 2,000개 중에서 학습 데이터셋을 1,600개, 테스트 데이터셋을 400개로 분류합니다. 

 

RNN이 아닌 일반적인 신경망 모형을 이용한 분류

단어 임베딩에 대해 RNN의 성능을 비교하기 위해 먼저 Rogistic 회귀 모형을 구현해서 시퀀스 정보 없이 예측을 수행해보겠습니다.

Keras가 제공하는 Sequential 모형은 단순하게 순차적으로 층을 쌓아서 신경망 모형을 구성하는데 활용할 수 있는, 쉽고 단순한 도구입니다. 이 실습에서는 Embedding 레이어, Flatten 레이어, 그리고 Dense 레이어를 쌓아서 신경망 모형을 만들겠습니다.

 

먼저, Embedding 레이어는 입력 데이터를 받아서 원-핫 인코딩과 워드 임베딩을 수행하는 레이어입니다. 

현재 문서는 500개의 단어로 이루어져 있고 단어 사전의 단어 개수는 10,000개이므로 하나의 문서는 (500, 10000) 크기의 2차원 행렬로 표현할 수 있습니다. 이 2차원 행렬을 밀집 벡터로 변환해야 하는데 이 실습에서는 밀집 벡터의 크기를 32로 지정하겠습니다. 따라서 1 X 10,000 크기의 벡터를 1 X 32 크기의 벡터로 만들기 위해서는 10,000 X 32 크기의 벡터를 곱해야 하기 때문에 10,000 X 32 만큼의 가중치 변수가 필요합니다.

 

Flatten 레이어는 2차원 행렬을 1차원 벡터로 쭉 펼치는 역할을 합니다. 

 

마지막으로 Dense 레이어는 모든 노드들이 연결되는 밀집 층을 생성해 은닉층을 만듭니다. 이 실습에서는 감성 분석을 위해 이진 분류를 해야 하므로 출력값을 계산할 때 Sigmoid 함수를 사용합니다.

 

# 케라스 모형 생성 및 학습
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense, Embedding

model = Sequential([ #순차적 모형
    Embedding(max_words, 32, input_length=maxlen), #word embedding layer 생성
    # max_words는 one-hot encoding을 할 때의 vector 크기가 됨 - 사용된 단어의 수만큼
    # 각 단어는 32 크기의 dense vector로 embedding 됨
    # input_length는 한 document의 단어 수로 표현
    # 이 과정을 거치면 각 document는 (maxlen, 32)의 2차원 행렬이 됨 - 즉 word의 sequence가 됨

    Flatten(), # 2차원 행렬을 1차원으로 펼침
    Dense(1, activation='sigmoid') #binary logistic regression을 수행
])

model.summary() #모델의 요약정보 출력

Metal device set to: Apple M1 Pro

systemMemory: 16.00 GB
maxCacheSize: 5.33 GB

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 500, 32)           320000    
                                                                 
 flatten (Flatten)           (None, 16000)             0         
                                                                 
 dense (Dense)               (None, 1)                 16001     
                                                                 
=================================================================
Total params: 336,001
Trainable params: 336,001
Non-trainable params: 0
_________________________________________________________________

코드를 보시면, 밀집 벡터의 크기를 32로 지정한 것을 볼 수 있고 Dense 레이어의 활성화 함수를 Sigmoid로 설정한 것을 확인할 수 있습니다. 

 

그리고 모델의 요약 정보를 보시면 한 단어를 크기 32의 밀집 벡터로 변환했기 때문에 Embedding 레이어의 결괏값이 '한 문장 단어 개수' = 500 곱하기 '한 단어의 크기' = 32, 즉 (500, 32)  크기의 벡터가 되는 것을 볼 수 있습니다.

그리고 Flatten 레이어의 결괏값은 500 X 32 크기의 2차 벡터를 1차원으로 만들어주기 때문에, 500 X 32 = 16,000 크기의 1차 벡터가 됩니다. 

마지막으로, Dense 레이어는 0 또는 1의 값을 주기 때문에 크기가 1인 벡터를 결괏값으로 줍니다.

 

이제 이 모형을 가지고 학습을 진행하겠습니다.

# 모형의 optimizer와 loss function 등을 지정
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
# 학습을 수행
history = model.fit(X_train, y_train, 
                    epochs=10,
                    verbose=1,
                    validation_split=0.2)

학습을 하려면 loss 함수와 optimizer를 설정해야 합니다. 위 코드와 같이 compile 메서드를 통해 이 둘을 지정할 수 있습니다. 

이진 분류 문제이므로 loss 함수는 'binary_crossentropy'를 사용하고 optimizer는 많이 사용되는 'rmsprop'를 사용합니다.

추가로 학습별로 정확도를 알아보기 위해 metrics에 정확도('acc')를 추가했습니다.

 

그리고 학습할 때 반복 횟수는 10번, 그리고 매 학습마다 학습 현황을 출력하고 학습을 하면서 사용할 검증 데이터셋의 비율은 0.2로 설정했습니다. 검증 데이터셋은 모형의 학습 현황을 파악함으로써 과대 적합의 여부를 판단하고, 이를 기반으로 매개변수를 결정하는 데 사용됩니다.

 

%matplotlib inline
import matplotlib.pyplot as plt

def plot_results(history, metric):
    plt.plot(history.history[metric], 'b', label='Training '+metric)
    plt.plot(history.history['val_'+metric], 'r--', label='Validation '+metric)
    plt.title('Training vs. Validation '+metric)
    plt.xlabel('Epochs')
    plt.ylabel(metric)
    plt.legend()
    plt.show()

plot_results(history, 'acc')

위 코드를 통해 학습이 잘되었는지 그래프로 확인해보면

 

일반적인 신경망 모형을 이용한 분류 학습 결과

정확도는 4번째 반복 때 이미 최대치에 도달하고 검증 데이터셋에 대한 정확도는 4번째 반복 이후에도 조금씩 증가하지만 큰 차이는 없는 것을 볼 수 있습니다. 또한 검증 데이터셋과 학습 데이터셋에 대한 정확도 격차가 꽤 큰 편이기 때문에 과대 적합의 가능성이 있어 보입니다.

 

#테스트 셋으로 학습된 모형의 성능을 평가
score = model.evaluate(X_test, y_test)
print(f'#Test accuracy:{score[1]:.3f}')

13/13 [==============================] - 0s 7ms/step - loss: 0.5641 - acc: 0.7200
#Test accuracy:0.720

마지막으로 테스트 데이터셋에 대해 모형의 최종 성능을 확인해보면, 최종 성능은 72%가 나옵니다. 

정확도가 기대보다 높지 않은데 그 이유로는

1. 단어를 500개로 제한하면서 문서가 잘려나간 것

2. 검증 데이터셋으로 인해 학습 데이터셋의 20%가 학습에 사용되지 못한 것

3. 과대 적합

4. 단어 순서 정보가 사라진 것

등을 원인으로 생각할 수 있습니다. 

 

문서의 순서 정보를 활용하는 RNN 기반 문서 분류

이제 RNN 모형을 사용해서 문서 분류를 해보겠습니다.

앞서 사용한 모형과 가장 큰 차이점은 Flatten 레이어 대신 SimpleRNN 레이어를 사용해서 RNN 층을 추가하는 것입니다.

여기서는 SimpleRNN의 인수에 32를 입력했는데, 이것은 은닉 노드의 크기입니다. 

 

그리고 이전 모형과 다르게 SimpleRNN 레이어 뒤에 Dense 레이어를 추가했는데 최종 노드에 대해 은닉층 하나를 추가해 모형의 성능을 높인 것입니다. 또한 optimizer를 아까와 다르게 Adam을 사용했는데 성능을 위해서라기보다는 다양한 optimizer를 사용해 실습을 하기 위한 것입니다. 

 

제 랩탑에서는 코드를 실행시키면 계속 오류가 나서 참고하며 공부한 책의 실행 결괏값을 그대로 들고왔습니다. 

결과를 보시면 학습이 거의 이뤄지지 않을 것을 볼 수 있습니다.

학습 데이터셋에 대한 정확도는 1.0까지 올라갔지만 검증 데이터셋과 테스트 데이터셋에 대한 정확도는 0.5 정도밖에 안됩니다.

이렇게 학습이 안된 이유는 딥러닝의 가장 큰 문제점인 경사 소실 때문입니다.

앞에서부터 순서에 따라 다음 단어에 미치는 영향을 축적해서 학습하는데 경사 소실로 인해 학습이 잘 되지 못하고, 따라서 우리가 원하는 정보가 제대로 축적되지 못했습니다. 이런 현상을 Long-term dependency, 장기간에 걸친 시간의존성이 학습되지 못하는 현상이라고 하고 RNN의 가장 큰 문제점입니다. 이를 해결하기 위해 LSTM 모형을 사용합니다.

 

LSTM, Bi-LSTM과 GRU를 이용한 성능 개선

LSTM의 목적은 앞부분의 정보가 뒤로 갈수록 소실되는 것을 방지하기 위해 장기 의존성과 단기 의존성을 모두 표현하고 학습하는 것입니다.

 

GRU는 LSTM을 간소화한 모형으로 LSTM에 비해 계산량이 적고 속도가 빠르면서도 좋은 성능을 내는 것으로 알려져 있습니다.

 

Bi-LSTM은 RNN을 개선하기 위해 양방향으로 모형을 구축한 것입니다.

 

LSTM, Bi-LSTM, 그리고 GRU를 이용해 마찬가지로 NLTK 감성 분석 실습을 해보겠습니다.

 

SimpleRNN에서 사용했던 코드와 모두 동일하지만 'SimpleRNN' 대신, LSTM을 사용하고 싶다면 LSTM, GRU를 사용하고 싶다면 GRU, Bi-LSTM을 사용하고 싶다면 Bidirectional로 LSTM을 감싸서 사용하면 됩니다.

위 그림에서는 Bi-LSTM을 사용했습니다.

위 결과를 보면, 검증 데이터셋과 테스트 데이터셋에 대한 정확도가 SimpleRNN을 사용했을 때보다 확실히 좋아진 것을 알 수 있습니다. 

하지만 SimpleRNN을 사용한 결과보다는 나아졌지만 우리가 기대한, 문맥에 대한 학습을 통해 더 좋은 성능을 보이지는 못했습니다. 

그 이유로는 아까와 같이, 

1. 단어를 500개로 제한하면서 문서가 잘려나간 것

2. 검증 데이터셋으로 인해 학습 데이터셋의 20%가 학습에 사용되지 못한 것

3. 과대 적합

4. 딥러닝은 학습에 많은 데이터를 요구하는데 NLTK의 학습 데이터는 2,000개 밖에 안되기 때문에

입니다. 

 

y_pred = np.round(model.predict(X_test[:10]))
for pred, y_t in zip(y_pred, y_test[:10]):
    print(f'predicted value: {pred[0]}, true value: {y_t}, so the prediction is {pred[0] == y_t}')

마지막으로, 학습된 모형을 이용해 결과를 예측하고 싶다면 model의 predict 메서드를 이용하면 됩니다. 

여기서는 그냥 반올림을 해서 예측 결과와 실제값을 비교했고 정답 여부를 출력했습니다.