[IMDB] Sentiment Analysis AI

# IMDB란

인터넷 영화 데이터베이스(Internet Movie Database, 약칭 IMDB)이다.

우리가 사용할 데이터는 영화 사이트 IMDB의 리뷰 데이터이다.

이 데이터는 리뷰에 대한 텍스트와 해당 리뷰가 긍정인 경우 1, 부정인 경우 0으로 표시한 레이블로 구성된 데이터이다.

이 데이터셋은 케라스에서 import하여 바로 사용할 수 있다.

 

이 데이터셋을 사용하여 머신러닝을 제작할 것이다.

목적은 텍스트 분류, 그 중에서도 감성 분류를 연습하기위함에 있다.

여기서 감성 분류(Sentiment Analysis)란, 텍스트 안에 들어있는 여러가지 주관적인 정보(의견, 감성, 평가, 태도 등)을 머신러닝을 돌려 분석하는 것이다.

 

#입력 데이터 불러오기

#케라스의 데이터셋에 있는 IMDB를 불러온다.
from keras.datasets import imdb 

(train_data, train_labels) , (test_data, test_labels) = imdb.load_data(num_words=5000)
#최대 5000개의 단어만을 허용함.

print(len(train_data))
print(len(train_labels))
print(len(test_data))
print(len(test_labels))
#각 25,000개씩 총 10만개의 데이터가 있음.

print("--------")
print(train_data[:3])
#학습데이터를 상위 3개 출력해서 확인

print("--------")
print(train_labels[:3])
#negative인지 positive인지 상위 3개 확인

확인을 위해 각 데이터를 확인해 본 결과, 각 변수에는 25,000 개의 데이터가 들어간 것을 확인할 수 있고, 학습데이터와 학습데이터의 label이 잘 들어있는 것을 확인할 수있다.

현재 샘플들이 이미 정수 인코딩까지 전처리가 된 것을 확인할 수 있었으나, 각 샘플들의 길이가 다르다는 것을 확인할 수 있었다. 따라서 모든 샘플의 길이를 맞추어야 한다.

 

print("max >> " ,max([max(sequnce) for sequnce in train_data]))
#num_words를 5000으로 설정했으니 5000을 넘는 index는 없음. 최대값 4999

word_index = imdb.get_word_index()
reverse_word_index = dict(
[(value, key) for (key, value) in word_index.items()])

# print("정렬안된 word_index 값들 확인 :")
# print(reverse_word_index.items())

print("정렬된 word_index 값들 확인 :")
print(sorted(reverse_word_index.items()))

최대값이 4999로 되어있는 것을 확인할 수 있다. 또한 word_index를 dict형식으로 만들고 sort를 하였더니 잘 정렬되있는 것을 확인할 수 있다.

 

# (0 = 패딩, 1=문서시작, 2=사전에 없음) 이 인덱스 안에 들어가야하니 3개를 뺌.
def decoded_review(text) :
    return ' '.join( [reverse_word_index.get(i-3, '?' ) for i in text])
    #찾는 인덱스가 없으면 ?를 출력함

# 예시로 아무거나 훈련 데이터의 값들을 출력해서 확인해봄.
print(train_data[3])
print(decoded_review(train_data[3]))
print()
print(train_data[11])
print(decoded_review(train_data[11]))

출력결과를 보면 기존에 1이 ‘the’이고, 13번이 was 였었는데, ‘패딩’과 ‘문서시작’, ‘사전에 없음’을 넣기위해 인덱스 3개를 추가하였더니 뒤로 밀려나서 현재 4번이 ‘the’이고, 13번이 원래 10번이었던 ‘i’로 바뀐 것을 확인할 수 있다.

 

이제 신경망에 넣기위해 정규화를 해주어야한다.

 

import numpy as np
def vectorize_sequences(sequences, dimension=5000): 
#신경망에 입력을 위해 5000개의 원소로 이루어진 벡터로 변환해줌.
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results

print(len(train_data))#train_data는 현재 25000개가 있음.

x_train = vectorize_sequences(train_data) 
x_test = vectorize_sequences(test_data)

y_train = np.asarray(train_labels).astype('float32')
#float 데이터 형태를 원소로 가지는 배열을 만드니 np.asarray() 함수를 사용
y_test = np.asarray(test_labels).astype('float32')

print(x_train[0])
print(x_test[0])
print(y_train[0])
print(y_test[0])

값을 변환해주고 확인을 위해 print를 해보니 25000개의 train_data를 확인하고, 각 데이터들을 출력하니 float 형식의 0과 1로 변환이 되었고, labels 또한 float형식으로 잘 바뀐 것을 확인할 수 있다.

이제 입력 데이터의 정규화도 어느정도 마쳤으니 모델을 제작해야한다.

 

#모델 제작

from keras import models 
from keras import layers
#모델제작
model = models.Sequential()
model.add(layers.Dense(32, activation='relu', input_shape = (5000,)))
model.add(layers.Dense(16, activation = 'relu'))
model.add(layers.Dense(1, activation = 'sigmoid'))
#모델 컴파일
model.compile(optimizer= 'Adam', loss = 'binary_crossentropy', metrics=['accuracy'])
#모델 확인
model.summary()

케라스를 import 하여 모델은 Sequential 모델로 설정해 주었고, 첫번째 레이어는 32개의 노드이고,

활성화함수는 relu를 사용하며, 입력데이터는 5000개씩 배열형식으로 입력받는다.

5000개의 입력층에서 32개의 은닉층으로 각각 연결되었기에 가중치는 5000*32 해서 160000이 나왔고,

각 노드 수만큼 편향이 있기에 편향은 32이다.

따라서 파라미터는 160032인 것을 확인해 볼 수 있다.

같은 방식으로 두번째 레이어도 16개의 노드로 설정하였고 같은 렐루함수를 사용하였다.

마지막 출력층은 시그모이드함수를 이용하여 0 or 1이 나와야하니 1개의 노드로 설정하였다.

 

#모델 훈련

# 검증데이터는 25000개 중에 5천개로 검증, 나머지 2만개로 훈련
x_val = x_train[:5000]
partial_x_train = x_train[5000:]
y_val = y_train[:5000]
partial_y_train = y_train[5000:]

history = model.fit(partial_x_train, partial_y_train, epochs=20, batch_size=512, validation_data=(x_val, y_val))

훈련에 앞서 데이터 25000개 중에 5천개는 검증, 나머지 2만개로 훈련을 하기 위해 나누어 주었고,

2만개로만 훈련을 하였다.

Epochs를 20으로 설정하였으니 이런식으로 20번 도는 것을 확인할 수 있다.

한번에 512개씩 훈련을 하도록 batch_size를 조정해 주었고, 검증데이터셋을 x_val, y_val로 설정하고 훈련을 시작하였다.

이 과정에서 나오는 값들을 history에 저장을 하여 과적합(overfitting)이 일어나는 구간을 찾아 볼 것이다.

 

history_dict = history.history
print(history_dict.keys())

각 키의 값이 나왔으니 이를 이용해서 시각적으로 보기 편하게 그래프를 그려볼 것이다.

import matplotlib.pyplot as plt

acc = history_dict['loss']
loss_values = history_dict['loss'] 
val_loss_values = history_dict['val_loss']
epochs = range(1, len(acc) + 1) #20번

plt.plot(epochs, loss_values, 'bo', label='Training loss') 
plt.plot(epochs, val_loss_values, 'b', label='Validation loss')
plt.title('Training and validation loss') 
plt.xlabel('Epochs')
plt.ylabel('Loss') 
plt.legend()
plt.show()

훈련데이터의 loss와 검증데이터의 loss를 그래프로 표현하여 확인해 보니 epochs가 3정도 이후부터는 훈련데이터의 loss는 점점 줄어들지만, 그에 반대로 검증데이터의 오류는 점점 증가하는 것을 볼 수 있다.

이 말은 즉슨, 과적합 현상이 일어난 것이다.

정확도를 그래프로 그려봐도 똑같은 현상이 일어날 것이다.

Loss가 낮다는 것은 그만큼 정확도도 높다는 뜻이니 같은 의미의 그래프라고 보아도 무방하다.

 

plt.clf() # 생성한 그래프를 clear
acc = history_dict['accuracy'] 
val_acc = history_dict['val_accuracy']
plt.plot(epochs, acc, 'bo', label='Training acc') 
plt.plot(epochs, val_acc, 'b', label='Validation acc') 
plt.title('Training and validation accuracy') 
plt.xlabel('Epochs')
plt.ylabel('Acc') 
plt.legend()
plt.show()

Epochs가 3일 때 검증데이터의 정확도가 87%정도 되는 것을 볼 수 있다.

그럼 이제 epochs를 4정도로수정하여 과적합현상이 일어나지 않게 훈련을 시켜주어야 한다.

그리고 정확도를 평가해본다.

 

scores = model.evaluate(x_val, y_val, verbose=0)
# 텍스트 데이터에 대해서 정확도 평가
print('정확도 : %.2f%%' % (scores[1]*100))

Epochs를 4로 설정하고 4번을 돌린 뒤 새로운 데이터의 정확도가 88.22%가 나왔다.

90%이상 나오기를 기대하였지만 살짝 아쉬움이 느껴진다.

다시 모델을 확인해보니 레이어층을 3개로 만들었었는데, 2개나 4개로도 만들어보고 활성화함수도 여러가지를 사용해보면 그 중에서 잘 만들어진 모델은 정확도가 90% 이상 나올 것 같다.

일단 88.22%도 높은 수치이니 이 모델을 가지고 실제로 적용해 보고 싶었다.

 

# AI 사용

IMDB 홈페이지에 내가 좋아하는 아이언맨을 검색하여 평점을 확인해 보았다.

역시 평점이 높은 편이였다.

유저 리뷰중에 평점이 좋은 대표 리뷰를 하나 가지고 왔다.

이 리뷰를 내가 만든 모델에 집어 넣어보고, 긍정적인 리뷰인지 부정적인 리뷰인지 확인을 하였다.

import re
from tensorflow.keras.preprocessing.sequence import pad_sequences

model.evaluate(x_val,y_val)[1]
def sentence(new_sentence):
  # 알파벳과 숫자를 제외하고 모두 제거 및 알파벳 소문자화
  new_sentence = re.sub('[^0-9a-zA-Z ]', '', new_sentence).lower()

  # 정수 인코딩
  encoded = []
  for word in new_sentence.split():
 
    try :   # 단어 집합의 크기를 제한.
      if reverse_word_index[word] <= 5000:
        encoded.append(reverse_word_index[word]+3)
      else:
    #  설정한 숫자 이상의 숫자는 <unk> 토큰으로 취급.
        encoded.append(2)
    # 단어 집합에 없는 단어는 <unk> 토큰으로 취급.
    except KeyError:
      encoded.append(2)

  pad_new = pad_sequences([encoded], maxlen = 5000) # 문장의 길이를 maxlen으로 맞추어줌.
  score = float(model.predict(pad_new)) # 예측
  if(score > 0.5):
    print("{:.2f}% 확률로 긍정 리뷰입니다.".format(score * 100))
  else:
    print("{:.2f}% 확률로 부정 리뷰입니다.".format((1 - score) * 100))

temp = "When it comes to ranking the Marvel superhero(live action) films,
Iron Man is for me up there with the better ones. It looks fabulous,
the whole film …" #너무길어서 중략하였음. (코드에는 전체로 들어감)
sentence(temp)

re 라이브러리를 이용하여 정규표현식을 사용하여 다른 특수문자들을 제거하였고,

모델에 넣을 수 있게 pad_sequences를 사용하여 문장의 길이를 설정해 주었고,

이를 float형으로 predict 하였다.

그리고 내가 찾은 리뷰를 가져와서 temp 변수에 넣어주고 이를 돌려보았다.

이렇게 내가 아는 영화들의 부정적, 긍정적 리뷰를 돌려보니 별점에 비슷하게 꽤 괜찮게 예측을 하는 것을 확인하였다.

 

#후기

처음부분에 IMDB를 사용하여 얻고싶은 목적이었던 ‘텍스트 분류’ , ‘감성 분류’에 대해 분류하는 방법을 익히는데 도움이 되었다.

모델을 완성해보고, 다른 사람들의 모델들이나, 케라스 공식홈페이지에서 보여주는 모델을 확인해보니, 확실히 여러가지 활성화 함수를 사용해 보고, 노드나 배치사이즈 등을 계속 수정해보면서 다양한 모델을 만들어 보아야 되겠다고 생각하였다.

인공지능이라는 것이 모델을 제작하는 것 보다, 데이터들을 깔끔하고 정규화되게 다듬는 작업의 비중이 훨씬 높고 중요하다.

IMDB를 사용하여 텍스트 분류를 해보았으니, 이번에는 다른 데이터셋을 가지고 모델을 다시 제작하여 적용해보아야겠다.