합성곱 신경망(CNN; Convolutional Neural Network)

합성곱 신경망이란?

합성곱 신경망(Convolutional neural network, CNN)은 시각적 영상을 분석하는 데 사용되는 다층의 피드-포워드적인 인공신경망의 한 종류이다. 딥 러닝에서 심층 신경망으로 분류되며, 시각적 영상 분석에 주로 적용된다. 또한 공유 가중치 구조변환 불변성 특성에 기초하여 변이 불변 또는 공간 불변 인공 신경망 (SIANN)으로도 알려져 있다. 영상 및 동영상 인식, 추천 시스템, 영상 분류, 의료 영상 분석 및 자연어 처리 등에 응용된다.

- 위키백과 (합성곱 신경망)

합성곱 신경망은 주로 영상 분석에서 많이 사용되는 신경망 구조이다.
(여기서 영상은 picture, image만을 의미한다. video는 동영상이라고 해야 한다.)

합성곱 신경망이니 합성곱이라는 것의 원리를 사용할텐데, 이게 뭘까?
합성곱을 검색해보면 두 함수가 있고, 둘 중 하나를 뒤집은 후에 곱한 결과를 적분한다고는 하는데...

$$(f*g)(t) = \int_{-\infty}^{\infty} {f(\tau)g(t-\tau)d\tau} \\무슨\ 말인고?$$

그러나 이는 함수에 들어가는 값들이 연속적인 경우이고, 합성곱 신경망에서의 합성곱은 각각의 값이 따로 따로, 즉 이산적이다.
따라서 위 식은 아래와 같이 표현할 수 있을 것이다.

$$(f*g)(t) = \sum_{\tau} {f(\tau)g(t-\tau)}$$

결론적으로 간단히 말하면 짝이 맞는 숫자 둘($f(\tau)$와 $g(t-\tau)$)이 만나 곱해진 값들을 한 곳에 모아 합을 구해준다고 생각하면 된다.

아래 합성곱 신경망의 구조 및 작동 방식을 통해서 이게 구체적으로 어떻게 돌아가는 시츄에이션인지 알아보자.

합성곱 신경망의 구조 및 작동 방식

합성곱 신경망 구조

전체적인 합성곱 신경망의 구조는 위와 같다.

입력 데이터(이미지)가 들어오면 특징 추출 부분에서 합성곱 연산 및 풀링 등의 과정을 거쳐 이미지의 특징을 잡아낸다.
신경망의 초기에는 저수준, 즉 이미지의 아주 작고 세부적인 특징부터 찾는다. 그리고 층이 깊어질수록 고수준, 즉 이미지의 전체적인 특징을 찾아낸다.

특징 추출 과정

처음에는 가로, 세로, 대각선 정도의 특징부터 잡기 시작해서 점차 (사람 얼굴인 경우) 눈, 코, 입 등을 구분하고, 마지막에는 전체적인 얼굴 윤곽을 추출하는 것을 볼 수 있다.

합성곱(Convolution)

위에서 합성곱 신경망에서의 합성곱은 결국 눈이 맞아 서로 곱해진 두 숫자의 커플들을 한데 모아 합한 것이라고 하였다. 이 발칙한 상황(?)이 어떤 것인지 눈으로 확인(?)해보자.

인풋&필터

우선 5X5 사이즈의 그레이 스케일(흑백) 이미지가 있다고 해보자. 이 이미지 위를 2X2 사이즈의 필터(Convolution Filter)$^*$$^1$가 왼쪽 위부터 시작해서 몇 칸 단위$^*$$^2$로 차례차례 돌아다닌다. 한 칸씩 움직인다고 하면 가로로 네 번, 세로로 네 번 해서 총 16번 훑을 것이다.

이때 매번 움직일 때마다 필터 위의 숫자와 이들 각각의 위치에 해당하는 이미지 위의 숫자를 곱한 후, 결과를 전부 합한다.
이렇게 해서 각 결과를 계산된 자리대로 배치해서 내놓은 것을 Feature Map이라고 한다.
(이 과정에서 Filter의 가중치가 학습이 된다.)

Feature Map계산 과정

Feature Map에 활성화 함수를 적용한 결과를 Activation Map이라 하고, 여기에 편향(bias)까지 합해준 것이 합성곱 층의 최종 결과물(Output)이다.

*1 필터(Filter)와 커널(Kernel)의 차이

이미지가 그레이 스케일(채널(Channel)이 1개)인 경우 필터(Filter)는 커널(Kernel)과 같다.

1 channel input

이미지가 컬러(RGB -> 채널이 3개)인 경우 하나의 필터 안에 3개의 커널이 있다.
즉, 각 채널마다 1개의 커널이 있고, 필터는 커널의 집합이다.

3 channels input

※ 위 이미지를 보면 들어올 때(input)는 RGB의 3개 채널이지만, 나갈 때(output)는 1개의 채널로 통합된다.
여기서 주의할 것은 각 필터별로 채널이 1개씩 산출된다는 점이다.
즉, 합성곱 층에 지정된 필터가 32개라면 Feature Map의 채널은 32개가 되는 것이다.
이는 그레이 스케일도 동일하다.

*2 스트라이드(Stride)

이 '몇 칸 단위'를 의미하는 말이 스트라이드(Stride) 이다.
이는 영어로 걸음, 보폭이라는 의미를 갖고 있다.
실제 코드 작성 시 이 값을 지정하여 몇 칸 단위로 필터가 돌아다니게 할지 정한다.

패딩(Padding)

패딩

패딩은 이미지의 외곽을 어떤 값으로 둘러싸는 것을 말한다.
사람이 겨울에 패딩 점퍼를 입듯, 이미지도 패딩을 입었다고 생각하면 된다.
이미지를 우리의 몸으로, 패딩은 패딩 점퍼로 비유해보겠다.

패딩은 왜 해줄까?
만약 패딩을 해주지 않고 그대로 합성곱을 진행하면 이미지의 테두리 부분은 안쪽에 비해 연산 과정에 덜 포함된다.
이는 달리 말하면 해당 부분의 정보가 제대로 반영되지 못한다는 의미와도 같다.
겨울에 패딩을 입지 않아 차가워진 우리의 피부를 상상해보자.

여기서 패딩을 통해 바깥을 감싸면 기존에 연산에 덜 포함된 부분이 보다 많이 반영된다. 한 번 되던 것이 두 번 이상 들어오니 이전보다 훨씬 낫다고 볼 수 있다.
패딩 점퍼를 입어서 피부가 따뜻해진 듯하다.

결국 패딩은 전체 이미지의 값을 충분히 활용하기 위해서 사용한다.
이와 더불어 입력 데이터의 크기가 패딩에 의해 변하게 되면서 Feature Map의 크기도 조절 가능하다.

위 움짤을 보자. 만약 5X5 사이즈 이미지에 3X3 필터를 적용하면 3X3 Feature Map이 나올 것이다.
여기서 이미지에 패딩을 적용하여 7X7 사이즈가 되게끔 하였고, 여기에 3X3 필터를 적용하니 5X5 사이즈의 Feature Map이 나왔다.
즉, 원본 이미지의 사이즈 5X5와 동일한 크기의 Feature Map을 출력으로 얻을 수 있다.

패딩의 값으로는 보통 0을 사용하는데, 이를 제로 패딩(Zero-Padding)이라고 한다.
이렇게 이미지를 패딩으로 씌움으로써 인공 신경망이 이미지의 외곽을 인식하게끔 만드는 효과도 있다.

※ 필터 크기(Filter Size), 패딩(Padding), 스트라이드(Stride)와 Feature Map 크기의 관계

$$
N_{\text{out}} = \bigg[\frac{N_{\text{in}} + 2p - k}{s}\bigg] + 1
$$

$N_{\text{in}}$ : 입력되는 이미지의 크기(=특성 수)
$N_{\text{out}}$ : 출력되는 이미지의 크기(=특성 수)
$k$ : 합성곱에 사용되는 필터(=커널)의 크기
$p$ : 합성곱에 적용한 패딩 값
$s$ : 합성곱에 적용한 스트라이드 값

풀링(Pooling)

Pooling

풀링(pooling)을 찾아보면 일단 swimming pool의 pool이 제일 먼저 나온다.
여기서 좀 더 들어가면 웅덩이, 그리고 공동으로 이용하기 위한 자금을 모은다는 의미도 나온다.

그럼 결국 CNN에서의 풀링은 무엇일까?
CNN에서 풀링을 거치면 이미지의 주요한 특징이 갈무리된 결과를 얻을 수 있다.
위 그림에서 보여지듯 일정한 간격으로 영역을 나눈 후, 그 영역의 특징을 가장 잘 설명하는 값을 가져온다.
여기서 이 값으로 영역 내 최댓값을 갖고 올지 평균값을 갖고 올지에 따라 Max Pooling과 Average Pooling으로 구분한다.
(주로 Max Pooling이 사용된다.)

또한 풀링을 통해 결과물, 즉 다음 층으로 향하는 데이터의 입력 크기(input size)가 작아진다. 크기가 작아진 만큼 데이터가 차지하는 메모리 크기도 작아지는 효과가 있다.
동시에 파라미터 수를 줄여주는 효과도 있어 과적합을 방지할 수도 있다(Dropout 같은 느낌).

풀링 층은 따로 학습되는 가중치가 없고, 채널 수도 변하지 않는다.

완전 연결 신경망(Fully Connected Layer)

특징 추출 부분에서 충분히 특징을 추출했다면 이를 토대로 분류를 해야 한다.

분류 문제 해결을 위해서 다층 퍼셉트론 신경망으로 구성된 신경망을 구축하고, 이진 분류인지 다중 분류인지에 따라 마지막 출력층까지 만들어주면 된다.

코드 예시(Tensorflow & Keras)

(Github 통해서 확인하시려면 클릭)

10개의 클래스로 분류되는 이미지 데이터셋인 CIFAR-10을 사용하여 CNN을 어떻게 구현하는지 알아보자.

  1. 패키지 및 라이브러리 불러오기
from tensorflow.keras.datasets import cifar10
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.models import Sequential
from tensorflow.keras.datasets import cifar10

from sklearn.model_selection import train_test_split

import numpy as np
import tensorflow as tf
  1. 시드(seed) 고정하기
np.random.seed(42)
tf.random.set_seed(42)
  1. 데이터셋 불러오기 & 훈련 / 검증 / 테스트셋으로 나누기 & 이미지 픽셀값 정규화
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=.2)
X_train.shape

(40000, 32, 32, 3)

훈련 데이터셋으로 가로 32, 세로 32 픽셀의 컬러(RGB, 3개 채널) 이미지 40000개가 있다.

  1. CNN 모델 구축
model = Sequential()

# 특징 추출 부분
# 합성곱 층(Conv2D)와 풀링 층(MaxPooling2D)를 번갈아가며 사용
model.add(Conv2D(32, (3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(2,2))
model.add(Conv2D(32, (3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(2,2))
model.add(Conv2D(32, (3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(2,2))

# 분류기 역할의 완전 연결 신경망
# 특징 추출 부분을 거쳐온 데이터를 신경망에 입력할 수 있도록 1차원으로 변환
model.add(Flatten())
model.add(Dense(128, activation='relu'))
# 10개의 클래스 분류이므로 출력층에 10개의 노드를, 활성화 함수로 softmax를 지정
model.add(Dense(10, activation='softmax'))

Conv2D에서 반드시 지정해야 하는 첫 번째 파라미터는 필터의 수(filters), 두 번째는 필터(커널)의 크기(kernel_size)이다.
padding은 'valid' 또는 'same'로 지정 가능하다.
'valid'는 패딩을 적용하지 않아 Conv2D를 지나면 입력된 이미지의 shape이 작아진다.
'same'은 패딩을 적용하여 Conv2D 전후의 이미지 shape이 동일하게 만든다.

MaxPooling2D에서 풀링할 영역의 크기(pool_size)는 (2, 2)가 기본값이다.
strides 파라미터를 지정하여 몇 칸 단위로 움직이며 풀링을 할지 지정할 수 있다. 기본값은 None으로, 이대로 두면 pool_size와 동일하게 설정된다. 즉, 풀링 영역이 겹치지 않게 된다.

※ 한 개 층에 큰 필터 쓰기 vs. 여러 개 층에 작은 필터 쓰기

큰 필터 1개를 쓰기보다는 작은 필터 여러 개를 쓰는 것이 낫다.
학습되어야 할 가중치 파라미터의 수가 적어지고 일반적으로 더 나은 성능을 보이기 때문이다.

예를 들어 5X5와 3X3 크기 필터가 있다고 해보자.
입력 이미지의 크기가 5X5라고 했을 때 5X5 필터는 1개 층, 3X3 필터는 2개 층을 거치면 같은 결과를 얻게 된다.

5X5 vs. 3X3


그런데 5X5 필터는 학습되어야 할 가중치 파라미터의 수가 25개이고, 3X3 필터는 2개 층이므로 3 X 3 X 2 = 18개이다.
필터의 크기를 작게, 그리고 여러 층으로 만든 것이 큰 필터를 사용하는 것보다 적은 비용이 드는 것을 알 수 있다.

예외적으로 첫 번째 합성곱 층에서는 큰 크기의 필터(5X5 이상)과 2 이상의 스트라이드를 사용한다. 왜냐하면 필터 크기가 커져도 입력 이미지의 채널은 컬러인 경우 3개, 흑백인 경우 1개뿐이므로 비용이 크지 않다.
이렇게 하면 너무 많은 정보를 잃지 않고서 이미지의 차원을 줄일 수 있다.

model.summary()

model summary

Output Shape은 (행 수, 가로 픽셀 수, 세로 픽셀 수, 채널 수) 라고 생각하면 쉽다.
여기서 행(row) 수는 None으로 표시되어 있는데, 이는 특정한 숫자로 지정되지 않았음을 의미한다. 배치 사이즈처럼 32, 64 등 다양한 숫자가 올 수도 있기 때문이다.
채널 수는 각 Conv2D에서 지정한 filters의 값에 맞춰 나온 것을 볼 수 있다.

MaxPooling2D는 입력으로 들어온 이전의 Conv2D의 shape을 줄였다.
채널의 수는 입력 데이터와 동일하며, 학습되는 가중치가 없기 때문에 Param #도 0으로 표기되었다.

Flatten에서는 (4, 4, 32)의 데이터가 1차원으로 변환되었기 때문에 4 * 4 * 32=512의 shape을 갖게 되었다.

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

10개 클래스의 다중 분류 문제이므로 'loss'를 'sparse_categorical_crossentropy'로 지정했다.

model.fit(X_train, y_train,
          batch_size=128,
          validation_data=(X_val, y_val),
          epochs=10)
  1. 모델 평가
model.evaluate(X_test, y_test, verbose=2)

313/313 - 4s - loss: 0.9526 - accuracy: 0.6713 - 4s/epoch - 13ms/step
[0.9525882601737976, 0.6712999939918518]


전이 학습(Transfer Learning)이란?

MMORPG 게임을 해본 사람이라면 알겠지만, 한 계정 내에 있는 캐릭터들 간에 아이템을 옮길 수 있는 기능이 있다(없는 게임도 있다).
이를 통해 무엇을 할 수 있는가? 일단 주 캐릭터를 초집중하여 강력하게 성장시킨다. 그 과정에서 다른 클래스의 장비나 잡화소모품 등을 상당수 얻게 된다.
이렇게 주 캐릭터를 충분히 성장시킨 후, 새로운 캐릭터를 시작한다고 해보자. 여기서 새로운 캐릭터는 제로(0)부터 시작할 필요가 없다. 왜냐하면 주 캐릭터를 키우면서 쌓아 놓은 수많은 물품들이 있기 때문이다.

전이 학습도 이와 같다.
기존에 훌륭하신 교수님들이나 연구원분들께서 연구 개발하여 발표하신 모델이 있으면(주 캐릭터), 우리는 이를 그대로 가져온 후에 우리에게 필요한 부분만 붙여서 쓰면 된다(부 캐릭터).

작동 방식

일반적으로 전이 학습은 대량의 데이터를 학습해놓은 사전 학습 모델(Pre-trained Model)의 가중치를 그대로 가져온 후, 분류기(완전 연결 신경망)만 필요에 따라 추가로 설계하여 붙이는 식으로 한다.

아래는 전이 학습을 나타낸 이미지이다.

전이 학습


위쪽이 사전 학습 모델이고 아래가 새롭게 구축한 모델이다.
새로운 모델을 보면 사전 학습 모델의 'Common inner layers'는 그대로 사용하되, 기존의 분류기 부분은 떼어낸 후 용도에 맞게 새로운 분류기를 붙여주었다.

특징

1) 어떠한 데이터에도 준수한 성능
사전 학습 모델의 가중치는 대량의 데이터를 학습하여 얻어진다.
즉, 여러 데이터의 일반적인 특징을 많이 학습하였으므로 아무 데이터나 넣어도 쓸만한 성능을 보인다.

2) 좋은 결과를 신속하게 도출
일반적으로 사전 학습 가중치는 학습되지 않고 고정(freeze)한 채로 진행되기 때문에 빠르게 좋은 결과를 얻을 수 있다.

이외에도 학습 데이터의 수가 적을 때도 효과적이며, 전이 학습 없이 학습하는 것보다 훨씬 높은 정확도를 제공한다는 장점도 있다.

이미지 분류를 위한 주요 사전 학습 모델

다음은 이미지 분류를 위해 사용할 수 있는 대표적인 사전 학습 모델들이다.

1. VGG

VGG는 2014년 ILSVRC 대회에서 2등을 한 모델이다.
VGG의 구조는 2개 또는 3개의 합성곱 층 뒤에 풀링 층이 나오고 다시 2개 또는 3개의 합성곱 층과 풀링 층이 등장하는 식이다.
VGG의 종류에 따라 총 16개 또는 19개의 합성곱 층이 있고, 이 갯수에 따라 VGG-16 또는 VGG-19라고 부른다.
마지막 분류기(완전 연결 신경망) 부분은 2개의 은닉층과 출력층으로 이루어진다.

VGG

VGG의 특징은 아래와 같다.

  • 모든 합성곱 층에서 3X3 크기 필터 사용
  • 활성화 함수로 ReLU 사용하고, 가중치 초기화는 He 초기화를 사용
  • 완전 연결 신경망에서 드롭아웃(Dropout)을 사용하여 과적합 방지 & 옵티마이저로 Adam 사용

2. ResNet

ResNet은 2015년 ILSVRC 대회에서 우승한 모델이다.
우승한 모델의 신경망 층 수는 152개였고, 이외에 34개, 50개, 101개 층 등의 변종도 있다.

ResNet

ResNet의 특징은 잔차 연결(Residual Connection; Skip Connection)이다. 이는 어떤 층을 거친 출력값에 그 층에 들어왔던 입력값을 그대로 더해주는 것을 말한다.
이를 통해 깊은 층의 신경망을 훈련시킬 수 있었다.

Residual Connection

3. Inception

Inception은 2014년 ILSVRC 대회에서 우승한 모델이다.
Inception 모델의 구조에서 주목할 부분은 Inception Module인데, 이는 가로 방향으로 신경망의 층을 넓게 구성한 구조를 말한다.
이를 활용하여 크기가 다른 필터와 풀링을 병렬적으로 적용한 뒤 결과를 조합한다.

Inception

이후 Inception-v3, Inception-v4 등 여러 변종이 나왔다.

4. EfficientNet

2019년에 발표된 모델로, Compound Scaling이란 방식을 통해서 기존의 모델보다 뛰어난 성능을 끌어냈다.

먼저 Scaling이란 합성곱 신경망 모델의 깊이나 너비, 또는 입력 이미지의 크기를 조절하는 것을 뜻한다.
이들 간의 균형을 맞추는 것이 모델 성능 향상에 중요하다는 생각을 바탕으로 이들 간의 균형을 나타내보니 간단한 상수비로 구할 수 있었다고 한다. 이를 토대로 나온 것이 Compound Scaling이다.

EfficientNet

코드 예시(Tensorflow & Keras)

위의 CNN 코드 예시에서 사용된 CIFAR-10 데이터셋을 그대로 사용하되, 모델은 사전 학습 모델(VGG16)을 이용한 전이 학습 모델로 구축하는 코드이다.

  1. 패키지 및 라이브러리 불러오기
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.layers import GlobalAveragePooling2D
  1. 사전 학습 모델 불러오기
pretrained_model = VGG16(weights='imagenet', include_top=False)
  1. 사전 학습 모델 위에 분류기 추가하기

아래에 추가된 GlobalAveragePooling2d() 층은 데이터 Shape을 (None, None, None, 512) 에서 (None, 512)로 변환하는 역할을 한다.

model = Sequential()
model.add(pretrained_model)
model.add(GlobalAveragePooling2D())
model.add(Dense(128,activation='relu'))
model.add(Dense(10,activation='softmax'))
model.summary()

transfer model summary

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(X_train, y_train,
          batch_size=128,
          validation_data=(X_val, y_val),
          epochs=10)
model.evaluate(X_test, y_test, verbose=2)

313/313 - 2s - loss: 0.7755 - accuracy: 0.7828 - 2s/epoch - 7ms/step
[0.7754948139190674, 0.782800018787384]


<참고 자료>

자연어 처리 기본 지식 및 텍스트 전처리(NLP Basic Knowledges & Text Preprocessing)

자연어 처리란?

자연어 & 자연어 처리(NLP; Natural Language Processing)

자연어(自然語, 영어: natural language 또는 ordinary language) 혹은 자연 언어는 사람들이 일상적으로 쓰는 언어를 인공적으로 만들어진 언어인 인공어와 구분하여 부르는 개념이다.

- 위키백과 (자연어)

자연어 처리(自然語處理) 또는 자연 언어 처리(自然言語處理)는 인간의 언어 현상을 컴퓨터와 같은 기계를 이용해서 묘사할 수 있도록 연구하고 이를 구현하는 인공지능의 주요 분야 중 하나다.

- 위키백과 (자연어 처리)

간단히 말하면 먼 옛날부터든 언제부터든 사람들의 의사소통을 위해 자연스럽게 형성된 언어이다. 영어, 한국어 등을 예로 들 수 있다.
반대로 인공어는 특정한 누군가가 어떤 목적을 갖고 인공적으로 만든 것이라고 볼 수 있다. 여기에는 에스페란토어, 프로그래밍 언어 등이 포함된다.

이러한 자연어를 컴퓨터로 처리하는 기술을 자연어 처리(NLP; Natural Language Processing) 라고 한다.

자연어 처리 용어

  • 말뭉치(Corpus; 코퍼스) : 자연어 연구를 위해 특정한 목적을 갖고 언어의 표본을 추출한 집합(텍스트 데이터)
  • 문장(Sentence) : 여러 개의 토큰(단어, 형태소 등)으로 구성된 문자열. 마침표, 느낌표 등의 기호로 구분
  • 문서(Document) : 문장들의 집합
  • 어휘집합(Vocabulary) : 말뭉치에 있는 모든 문장 및 문서를 토큰화한 후 중복을 제거한 토큰의 집합

토큰(token) 및 토큰화(tokenization)가 구체적으로 무엇인지는 아래 텍스트 전처리 부분에서 다루겠다.

자연어 처리로 할 수 있는 것

  1. 자연어 이해(NLU; Natural Language Understanding)
    • 분류(Classification) : 뉴스 기사 분류, 감성 분석(Positive/Negative)
    • 자연어 추론(NLI; Natural Language Inference)
    • 기계 독해(MRC; Machine Reading Comprehension), 질의 응답(QA; Question&Answering)
    • 품사 태깅(POS(Part of Speech) tagging), 개체명 인식(Named Entity Recognition) 등
  2. 자연어 생성(NLG; Natural Language Generation)
    • (특정 도메인의) 텍스트 생성
  3. NLU & NLG
    • 기계 번역(Machine Translation)
    • 요약(Summerization)
      • 추출 요약(Extractive summerization) : 문서 내에서 해당 문서를 가장 잘 요약하는 부분을 찾아내는 것 (NLU에 가까움)
      • 생성 요약(Absractive summerization) : 해당 문서를 요약하는 요약문을 생성 (NLG에 가까움)
    • 챗봇(Chatbot)
      • 특정 업무를 처리하기 위한 챗봇(TOD; Task Oriented Dialog)
      • 정해지지 않은 주제를 다루는 일반 대화 챗봇(ODD; Open Domain Dialog)
  4. 기타
    • TTS(Text to Speech) : 텍스트를 음성으로 읽기
    • STT(Speech to Text) : 음성을 텍스트로 쓰기
    • Image Captioning : 이미지를 설명하는 문장 생성

벡터화(Vectorization)

자연어와 자연어 처리가 무엇인지 알았고 무슨 일을 할 수 있는지도 알았다. 그럼 어떻게 하는 것일까?

우선 뭘 하려고 하기 전에 컴퓨터가 자연어를 이해할 수 있도록 우리 인간(human)이 친절하게 바꿔주어야 하는데, 자연어는 벡터로 만들어준다. 이를 벡터화(Vectorization) 라고 한다.

자연어를 어떤 방식으로 벡터화할지는 자연어 처리 모델 성능에 큰 영향을 미친다.
자연어를 벡터화하는 방법은 다음과 같은 것들이 있다. (자세한 내용은 각각 별도의 글에서 다룰 예정)

  • 등장 횟수 기반 단어 표현(Count-based Representation)
    • Bag of Words
    • TF-IDF
  • 분포 기반 단어 표현(Distributed Representation)
    • Word2Vec
    • fastText
    • GloVe

자, 이제 벡터화가 뭔지도 알았으니 어떻게 하는지만 알면 바로 자연어 처리를 진행할 수 있을 것만 같다!

... 그럴 것 같지만 그렇지 않다.
데이터 분석을 하고, 머신 러닝 모델을 만들고 그러기 전에 무엇을 해야 했는가? 그렇다. 데이터 전처리를 '반드시' 해야 했다.
텍스트 데이터도 그렇다.


텍스트 전처리

데이터 전처리의 중요성은 아무리 강조해도 지나치지 않을 것이다. 그런 만큼 다양한 이유가 있을 것인데, 그 중에서도 텍스트 데이터의 전처리가 필요한 이유는 무엇일까?

차원의 저주(Curse of Dimensionality)

차원의 저주란 데이터셋의 차원이 커질수록 기존의 데이터가 갖고 있는 설명력이 줄어드는 문제를 말한다.
간단하게 말하면, 데이터 개수는 그대로이고 데이터셋의 차원만 늘어나면 데이터의 밀도가 떨어져서 의미 도출이 어려워질 수도 있다.
아래 그림들을 보자.

1차원(직선) 위에 4개의 점(데이터)가 있다고 해보자.

이 상태에서 차원을 하나 올려 2차원(평면)이 되면 점 사이의 거리가 멀어진다.
(물론 데이터에 따라 차원이 올라가도 거리가 그대로일 수도 있음)

3차원이 되면 거리는 더더욱 멀어지게 된다.

물론 데이터셋의 차원이 올라간다고 해서 무조건 데이터의 의미가 줄어드는 것은 아니다. 데이터셋에 따라서 차원을 올리면 오히려 폭넓은 설명이 가능한 경우도 있다.
그러나 이 차원이 과하게 크면? 그러면 위 그림을 통해서 설명한 것처럼 데이터셋의 설명력이 떨어질 것이다.

자연어 처리에서는 전체 말뭉치에 존재하는 단어의 종류가 데이터셋의 특성, 즉 차원이 된다. 그러므로 단어의 종류를 줄여야 차원의 저주 문제를 어느 정도 해결할 수가 있다.

아래의 다양한 텍스트 전처리 방법들을 통해서 불필요하거나 중복되는 단어 제거를 통해 차원을 줄이거나, 모델의 효율적인 연산을 위해 데이터를 가공할 수 있다.

그럼 이제 텍스트 전처리 방법들에 대해서 살펴보자.

1) 토큰화(Tokenization)

토큰(token), 그리고 토큰화(Tokenization)란?

(이런게 토큰...?)

자연어 처리에서 토큰이란 주어진 말뭉치를 특정한 단위(보통 단어)로 조각조각 나눈 것을 말한다. 쉽게 말하면 말뭉치를 부숴서 얻은 조각들이다. 부수는 방식은 대충 뭉텅뭉텅 부술 수도(문장 이상의 단위), 아니면 아주 가루를 내버릴 수도 있다(철자 단위).
여기서 단어를 기준으로 말뭉치를 나누면 이를 단어 토큰화라 하고, 문장 단위면 문장 토큰화라고 한다.

전통적인 자연어 처리 방식인 횟수 기반 단어 표현(Count-based Word Representation)부터 RNN, LSTM, Transformer와 같은 진보된 신경망 기반 방식 모두 이 토큰을 이용하여 모델 학습이 이루어진다.
따라서 토큰화는 자연어 처리에서 필수적이라고 할 수 있다.

토큰화 방법

단어 토큰화라면 띄어쓰기를 기준으로 단어를 구분할 수 있을 것이고,
문장 토큰화라면 구두점이나 물음표, 느낌표 등으로 구분할 수 있을 것이다.
그러나 이런 경우는 아주 단순한 경우이고, 실제는 그리 간단하지 않다.

주의사항

  • 토큰화 기준

단어 토큰화를 한다고 했을 때, 어떤 단어 사이에 특수문자(아포스트로피('), 대시(-) 등)가 포함된 경우는 어떻게 토큰화를 해야 할까?

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.preprocessing.text import Tokenizer

sentences = [
  'I love you',
  'I love myself'
]

tokenizer = Tokenizer(num_words = 100)
tokenizer.fit_on_texts(sentences)
word_index = tokenizer.word_index
print(word_index)

{'i': 1, 'love': 2, 'you': 3, 'myself': 4}
이렇게 별다른 특수문자가 없으면 띄어쓰기만 갖고서 잘 구분이 되지만,

sentences = [
  "I'm a student",
  'Fu-sion!',
  "Don't panic!"
]

tokenizer = Tokenizer(num_words = 100)
tokenizer.fit_on_texts(sentences)
word_index = tokenizer.word_index
print(word_index)

{"i'm": 1, 'a': 2, 'student': 3, 'fu': 4, 'sion': 5, "don't": 6, 'panic': 7}
이렇게 아포스트로피나 대시가 있으면 결과가 의도와 다르게 나올 수도 있다.

따라서 이런 경우에는 어떤 기준으로 토큰화를 할지 선택해야 한다.
(Keras Tokenizer의 경우 filters 파라미터를 통해서 어떤 특수문자를 제거할지 안 할지 직접 지정할 수 있음)

  • 구두점, 특수 문자의 단순 제외

구두점이나 특수 문자를 단순히 제거해버리면 무의미한 토큰이 만들어질 수도 있다.
M.Sc(Master of Science) 또는 Ratchet&Clank(비디오 게임 제목) 같이 하나의 토큰으로 분류해야 하는 경우가 있기 때문이다.

2) 정제(Cleaning) 및 정규화(Normalization) by 내장 메소드

정제 및 정규화란?

정제는 주어진 말뭉치에서 지저분한(노이즈) 데이터를 제거하는 것이다.
정규화는 같은 의미임에도 모양이 다른 단어들을 하나의 형태로 통일시켜주는 작업이다.
쉽게 말해 불필요한 군더더기를 제거하여 데이터의 살을 빼는 작업이다.

같은 의미지만 다른 형태인 단어 통일시키기

우리나라를 영어로 표기하면 다양한 방식이 나올 수 있다. Korea, KOR, ROK 등등. 그러나 결국 이들이 의미하는 것은 대한민국이다.
이런 경우 한 가지를 딱 정해서 통일을 시켜준다.

대소문자 통합

위에서 우리나라를 표현하는 말 중 KOR이 있었다. 그런데 여기서는 KOR이라 하고, 저기서는 kor이라고 할 수도 있다.
이런 경우도 대소문자 둘 중 하나로 딱 정해서 통합시킨다.

불필요한 단어 제거(통계적 트리밍(Trimming))

머신 러닝 모델을 만들기 전에 보통 데이터 전처리를 한다.
이때 평균에 비해 과도하게 높거나 낮은 수치들을 이상치로 간주하여 제거할 때가 있다.

이와 비슷하게 텍스트 전처리에서는 말뭉치 내에서 너무 많거나 적게 등장하는 단어들은 별 의미가 없는 것으로 간주하여 제거한다.
등장 횟수가 너무 많으면 여러 문장(또는 문서)에 걸쳐서 나오는 단어이므로 문장 분류 등에 별다른 도움이 되지 않을 것이고, 너무 적으면 적은 대로 영향력이 없기 때문이다.

3) 어간 추출(Stemming) 혹은 표제어 추출(Lemmatization)

어간과 표제어란?

  • 어간(stem) : 단어의 의미가 포함된 부분으로 접사(affix) 등이 제거된 형태(어근 또는 단어 원형과 다를 수 있음)
    • 접사(affix) : 단어에 붙어 추가적인 의미를 더하는 부분
  • 표제어(Lemma) : 단어의 기본 사전형 형태

간단하게 예를 들면 wolves의 어간은 wolv이고 표제어는 wolf이다.
또 다른 예로 leaves의 어간은 leav, 표제어는 leaf이다.

즉, 어간은 단어에서 접사같은 부수적인 부분만 딱 떼어낸 것이고,
표제어는 그 단어의 근본 형태(또는 사전에서 찾을 수 있는 형태)라고 할 수 있다.

어간 추출

# NLTK 라이브러리 데이터를 다운로드받아야 아래 코드들이 실행 가능
# 이미 있는 경우는 생략해도 됩니다.
import nltk
nltk.download()
from nltk.stem import PorterStemmer

ps = PorterStemmer()
words = ["wolf", "wolves", "leaf", "leaves"]

print([ps.stem(word) for  word  in  words])

['wolf', 'wolv', 'leaf', 'leav']
보이는 것처럼 군더더기 부분만 딱 자르고 남은 부분 그대로 내보낸다.

표제어 추출

from nltk.stem import WordNetLemmatizer

lt= WordNetLemmatizer()
words = ["wolf", "wolves", "leaf", "leaves"]

print([lt.lemmatize(word) for word in words])

['wolf', 'wolf', 'leaf', 'leaf']
보이는 것처럼 단어의 사전형 형태를 찾아서 내보낸다.

주의사항

  • 다양한 라이브러리, 다양한 알고리즘

자연어 처리에 쓰이는 다양한 라이브러리가 있고, 각각의 내부에는 다양한 어간 추출 및 표제어 추출 알고리즘이 있다.
따라서 사용 전에 작동 방식을 이해하고 사용해야 할 것이다.

  • 연산 속도 : 어간 추출 > 표제어 추출

어간 추출은 단순한 꼬리 자르기이고, 표제어 추출은 근본을 찾아오는 작업이므로 일반적으로 어간 추출이 더 빠르다.
그러나 어간 추출의 결과는 실제로 존재하지 않는 단어일 수도 있으므로 상황에 맞게 어간 추출 또는 표제어 추출을 선택해야 한다.

4) 불용어(Stopword) 처리

불용어란?

불용-어 不用語

인터넷 검색 시 검색 용어로 사용하지 않는 단어. 관사, 전치사, 조사, 접속사 등은 검색 색인 단어로 의미가 없는 단어이다. 그러나, 각 검색 엔진마다 그 내용은 다를 수도 있다.

- 네이버 국어사전

위에서 불필요한 단어 중 말뭉치에서 너무 많이 등장하는 단어들도 제거 대상이라고 하였다. 여기에 대부분 포함되는 것이 바로 불용어이다.

영어에서는 a, the 및 in, on, at 등의 전치사 등등이 해당된다.
아래 링크를 통해서 각 언어별 불용어 목록을 확인할 수 있다.
언어별 불용어 목록

불용어 확인

자연어 처리 라이브러리를 통해서 불용어를 확인 및 처리할 수 있다.
여기서는 spaCy 라이브러리를 사용해보겠다.

import spacy
from spacy.tokenizer import Tokenizer

nlp = spacy.load("en_core_web_sm")

# 불용어 10개만 확인
print([stopword  for  stopword  in  nlp.Defaults.stop_words][:10])

['along', 'using', 'hence', 'serious', 'see', 'yours', 'beyond', 'myself', 'is', 'yourselves']

불용어 처리

text = "I'm the best. You're the best. We're the best."

sentence = nlp(text)

token_list = []
for token in sentence:
    # 토큰이 불용어와 구두점이 아니면 저장
    if (token.is_stop == False) & (token.is_punct == False):
        token_list.append(token.text)

token_list

['best', 'best', 'best']

sws  =  nlp.Defaults.stop_words
sw  = ["i", "'m", "the", "you", "'re", "we" ]
is_sw  = [word  in  sws  for  word  in  sw]

is_sw

[True, True, True, True, True, True]

불용어를 제외하고 남은 토큰('best')만 출력된 것을 볼 수 있다.


<참고 자료>

인공 신경망(ANN; Artificial Neural Network)

인공 신경망이 뭐지?

인공신경망(人工神經網, 영어: artificial neural network, ANN)은 기계학습과 인지과학에서 생물학의 신경망(동물의 중추신경계중 특히 뇌)에서 영감을 얻은 통계학적 학습 알고리즘이다. 인공신경망은 시냅스의 결합으로 네트워크를 형성한 인공 뉴런(노드)이 학습을 통해 시냅스의 결합 세기를 변화시켜, 문제 해결 능력을 가지는 모델 전반을 가리킨다. 좁은 의미에서는 오차역전파법을 이용한 다층 퍼셉트론을 가리키는 경우도 있지만, 이것은 잘못된 용법으로, 인공신경망은 이에 국한되지 않는다.

- 위키백과 (인공 신경망)

인공 신경망은 생물의 신경계가 작동하는 방식을 모방하여 만든 머신 러닝 모델이라고 볼 수 있다.

우리의 신경계는 수많은 신경 세포, 즉 뉴런(neuron)으로 이루어져 있다. 일반적인 뉴런의 구조는 아래와 같이 생겼다.

일반적인 뉴런의 구조


간단하게 설명하자면, 뉴런은 수상돌기를 통해 신호를 받아들인 후 신경세포체와 축삭을 거쳐서 다른 뉴런으로 신호를 전달한다.

우리 몸의 신경계가 뉴런으로 구성되듯이 인공 신경망을 이루는 가장 작은 단위가 있는데, 이를 퍼셉트론(perceptron)이라고 한다.

퍼셉트론(perceptron)

위에서 뉴런이 '수상돌기 -> 신경세포체/축삭 -> 다음 뉴런의 수상돌기'라는 과정을 거쳐서 신호를 전달하는 것을 보았다. 퍼셉트론도 이와 비슷한 구조를 갖고 있다.

먼저 여러 개의 입력값을 받는다. 각각의 입력값에는 신호의 세기, 즉 가중치가 부여되어 있다. 각각의 입력값과 가중치가 곱해진 값을 합한 후, 이에 편향을 더해준다(가중치-편향 연산). 이를 식으로 나타내면 아래와 같다.
$$w_1x_1 + w_2x_2+ b$$
위에서는 입력값이 2개뿐이다. 만약 입력값이 n개라고 하면 식이 어떻게 될까?
$$\sum_{k=1}^{n}w_kx_k + b\\
= (w_1x_1+w_2x_2+...+w_nx_n) + b\\
= \begin{bmatrix}w_1&w_2&\cdots&w_n\end{bmatrix}\begin{bmatrix}x_1\\x_2\\...\\x_n\end{bmatrix} + b\\
=Wx + b$$
각각의 입력값과 가중치가 곱해지는 연산을 벡터로 표현하였고, 그 결과 $Wx+b$와 같은 형태가 되었다(여기서 $W$는 가중치 행렬$^*$$^1$이라고 함).
어디서 많이 보던 모양이다. 그렇다. 일차 함수, 직선이다!

그렇다. 직선이다. 그게 뭐 특별한건가?
특별하다. 왜냐하면 이대로는 복잡한 문제 해결이 불가능하다.
어떤 복잡한 문제인가? XOR 이라고 하는 문제가 있다.

XOR (배타적 논리합)

XOR을 알기 위해서는 먼저 AND, NAND, OR와 같은 논리 게이트가 어떻게 작동하는 것들인지 이해해야 한다.

1) AND
두 명의 사람이 있고, 저녁에 치킨을 먹을지 말지 고민 중이다.
둘 모두 치킨을 먹는다고 할 때에만 먹는(1) 경우다.

AND GATE

2) NAND
이는 AND의 반대, Not AND라서 NAND이다.

NAND GATE

2) OR
이는 둘 중 한 명이라도 치킨 먹자! 라고 하면 치킨을 먹는 경우다.

OR GATE

3) XOR
둘 다 먹자고 하면 안 먹고, 둘 다 안 먹자고 하면 안 먹는데 둘 중 하나만 먹자고 하면 먹는 이상한 경우다. 둘 모두 먹으면 둘 다 살이 찌니까 한 명만 먹기로 하는 결정인걸까? 확실히 단순하지는 않다.

XOR GATE

XOR이 어떤 식으로 작동하는지 보았다. 이번에는 위 논리 게이트의 Output들이 직선을 통해 어떤 식으로 분류되는지 보자.

논리 게이트 Output 분류


AND와 OR의 경우 하나의 직선으로 0과 1의 Output들이 깔끔하게 분류가 된다. 그런데 XOR은? 이래서 아까 위에서 나온 Wx+b의 직선 형태로는 XOR 문제를 해결할 수가 없다.

자, 직선으로는 답이 안나온다. 그럼 어떻게 하지?
일단 휘게 만든다. 뭘로? 활성화 함수로.

활성화 함수(Activation Function)

활성화 함수. 이름대로 자기가 받은 신호를 잘 살려서 내보내주는 역할을 한다. 마치 아이돌 연습생을 잘 트레이닝해서 데뷔를 시키는 프로듀서와도 같다.

잘 살려서 내보내주는 역할이란 무엇인가? 여기에는 두 가지가 있다.

1) 가중합(가중치*입력값 들의 합, Wx)이 계산되고 나면 값이 너무 커지거나 작아질 수가 있다. 이때 활성화 함수를 통해서 이 값을 0에서 1 또는 -1에서 1 사이의 값 등으로 바꿔준다(활성화 함수 유형에 따라 다름. 전부 다 상하한의 제한이 있는 것은 아님).
아이돌 연습생의 과도한 똘끼(?)를 진정시켜 마음을 가다듬게 해준다고 보면 되겠다.

2) 비선형성을 가진 활성화 함수를 통해서 Wx+b를 휘게 만들어준다.
연습생이 이상한 고집 부리지 않게끔 유연한 사고방식을 심어준다고 생각하면 될 것 같다.

(구체적인 활성화 함수 내용은 다음 링크 참고 : 활성화 함수)

자, 우리 연습생의 똘끼도 진정시켰고, 이상한 고집도 안 부리게끔 만들었다. 이제 세상으로 내보내보려고 한다.
잠깐, 그 전에 잘 하는지 한번 보자.

### XOR 문제 구성 ###
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)

x11 = np.random.uniform(low=0, high=5, size=(50,))
x12 = np.random.uniform(low=10, high=15, size=(50,))
x21 = np.random.uniform(low=0, high=5, size=(50,))
x22 = np.random.uniform(low=10, high=15, size=(50,))


x1 = np.append(x11, x12)
x2 = np.append(x21, x22)

y11 = np.random.uniform(low=10, high=15, size=(50,))
y12 = np.random.uniform(low=0, high=5, size=(50,))
y21 = np.random.uniform(low=0, high=5, size=(50,))
y22 = np.random.uniform(low=10, high=15, size=(50,))

y1 = np.append(y11, y12)
y2 = np.append(y21, y22)

x_1 = np.vstack([x1, y1]).T
x_2 = np.vstack([x2, y2]).T
y_1 = np.ones_like(x_1[:, 0])
y_2 = np.zeros_like(x_2[:, 0])
x = np.vstack([x_1, x_2])
y = np.hstack([y_1, y_2])


fig, ax = plt.subplots(figsize = (12,5))
ax.plot(x_1[:, 0], x_1[:,1], 'bo')
ax.plot(x_2[:,0], x_2[:,1], 'ro')
ax.grid()

XOR problem

### XOR 문제 해결시켜보기(단층 퍼셉트론) ###
import tensorflow as tf

model = tf.keras.models.Sequential([
    # 한 개의 층으로만 구성
    tf.keras.layers.Dense(1, input_dim=2, activation='sigmoid')
])

model.compile(optimizer='sgd',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(x, y, epochs=1000, verbose=0)

preds = model.predict(x)
preds_1d = preds.flatten()
pred_class = np.where(preds_1d > 0.5, 1 , 0)

y_true = x[pred_class==1]
y_false = x[pred_class==0]

fig, ax = plt.subplots(figsize = (12,5))
ax.plot(y_true[:, 0], y_true[:,1], 'bo')
ax.plot(y_false[:,0], y_false[:,1], 'ro')
ax.grid()

XOR problem solution failed

큰일이다. 이 친구가 혼자서 해내지 못한다.
솔로 데뷔가 힘들 것 같은데... 그렇다면 다른 연습생들과 묶어서 그룹으로 데뷔를 시켜야 할까?

### XOR 문제 해결시켜보기(다층 퍼셉트론) ###
model = tf.keras.models.Sequential([
    # 여러 개의 층으로 구성
    tf.keras.layers.Dense(8, input_dim=2, activation='sigmoid'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

model.compile(optimizer='sgd',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(x, y, epochs=1000, verbose=0)

preds = model.predict(x)
preds_1d = preds.flatten()
pred_class = np.where(preds_1d > 0.5, 1 , 0)

y_true = x[pred_class==1]
y_false = x[pred_class==0]

fig, ax = plt.subplots(figsize = (12,5))
ax.plot(y_true[:, 0], y_true[:,1], 'bo')
ax.plot(y_false[:,0], y_false[:,1], 'ro')
ax.grid()

XOR problem solution successed

다른 연습생들과 함께 그룹으로 묶으니 이제 복잡한 문제도 자기들끼리 척척 잘 해결한다!
이제는 믿고 데뷔를 시킬 수 있을 것 같다.

이렇게 여러 층의 퍼셉트론으로 구축한 신경망을 다층 퍼셉트론 신경망(MLP; Multi Layer Perceptron)이라고 한다.


인공 신경망은 어떻게 생긴 것이지?

인공 신경망의 가장 기본이 되는 단위인 퍼셉트론 하나부터 시작해서 퍼셉트론 여러 개가 여러 층으로 모인 다층 퍼셉트론 신경망까지 살펴봤다.
이번에는 인공 신경망의 전체적인 그림을 보자.

인공 신경망

인공 신경망은 위 그림처럼 생겼다. 그림 속 각각의 원은 노드(node)라고 하며, 전체는 크게 세 부분 - 입력층(Input Layer), 은닉층(Hidden Layers), 출력층(Output Layer)으로 나누어진다.

1) 입력층(Input Layer)

  • 데이터셋이 입력되는 층
  • 데이터셋의 특성(feature) 개수에 맞춰 입력층의 노드 수가 결정됨
  • 어떤 계산 없이 입력값의 전달만 수행 -> 신경망 층수(깊이, depth)에 포함되지 않음

2) 은닉층(Hidden Layers)

  • 입력층에서 들어온 값이 가중치-편향 연산 및 활성화 함수를 거쳐가는 층
  • 일반적으로 입력층과 출력층 사이에 있는 층임
  • 사용자가 계산 결과를 볼 수 없으므로 은닉(hidden)층이라 함
  • 입력 데이터셋의 특성 수와 관계없이 노드 수 구성 가능
    ※ 딥 러닝 : 2개 이상의 은닉층을 가진 신경망

3) 출력층(Output Layer)

  • 은닉층의 연산을 마친 값이 출력되는 층
  • 해결할 문제에 따라 출력층의 노드 수가 결정됨
  노드 수 결과 값 활성화 함수
이진 분류 1
(∵0 또는 1의
값 1개)
0~1 사이의 확률값 Sigmoid
다중 분류 레이블(타겟)
클래스 수
각 클래스별 0~1
사이의 확률값
Softmax
회귀 출력값의
특성(타겟) 수
타겟 값 일반적으로는
지정 X

 

인공 신경망 구현 예시(Tensorflow & Keras)

1) 데이터 불러오기

입력 데이터 샘플과 Features : 1077 샘플 x 69 Features (변수)
데이터 label: 다운증후군 (1), 정상군 (2)

(데이터는 다운증후군과 정상군 마우스 피질의 핵 분획에서 검출 가능한 신호를 생성하는 69 개 단백질의 발현 수준으로 구성되어 있습니다.
라벨로는 다운증후군 1, 정상군 2로 할당되어 있습니다.)

import pandas as pd
df = pd.read_excel("https://ds-lecture-data.s3.ap-northeast-2.amazonaws.com/MouseProtein/mouse_protein_X.xls", header=None)
df_label = pd.read_excel("https://ds-lecture-data.s3.ap-northeast-2.amazonaws.com/MouseProtein/mouse_protein_label.xls", header=None)

2) 라벨 값 변경

# 기존에 다운증후군(1), 정상군(2)였던 값을 정상군(0), 다운증후군(1)로 변경
df_label = df_label.replace(2, 0).iloc[:, 0].values
df_label.astype(object)

3) 훈련 / 테스트 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(df, df_label, test_size=0.2, random_state=42)

4) 신경망 모델 구성

# 모델 초기화
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(128, input_dim=69, activation='relu'),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])
# Dense : 각각의 신경망 층을 나타냄
# 맨 처음과 마지막이 입력층과 출력층, 그 사이는 은닉층
# 각 층 맨 앞의 숫자(128, 128, 1)는 해당 층의 노드 수임
# input_dim : 입력 데이터 특성 수(input_shape=(69,) 이렇게도 입력 가능)
# activation : 해당 층의 노드들이 사용할 활성화 함수 지정
# keras 모델 초기화 후에는 compile 과정을 거쳐야 함
model.compile(optimizer='sgd',
              loss='binary_crossentropy',
              metrics=['accuracy'])
# optimizer : 손실 함수의 최소값을 찾는 방법 지정
# loss : 손실 함수 종류 지정
# metrics : 훈련 시 평가 지표 지정
# 모델 훈련시키기
model.fit(X_train, y_train, epochs=500)
# epochs : 전체 데이터셋을 한 번 훈련한 것이 1 epoch임
# epochs=500 이라는 것은 전체 데이터셋에 대해 훈련을 500번 진행한다는 의미

Epoch 1/500
27/27 [==============================] - 0s 876us/step - loss: 0.6981 - accuracy: 0.5017
Epoch 2/500
27/27 [==============================] - 0s 778us/step - loss: 0.6906 - accuracy: 0.5296
Epoch 3/500
27/27 [==============================] - 0s 815us/step - loss: 0.6804 - accuracy: 0.5935
...
Epoch 499/500
27/27 [==============================] - 0s 852us/step - loss: 0.0252 - accuracy: 0.9988
Epoch 500/500
27/27 [==============================] - 0s 852us/step - loss: 0.0287 - accuracy: 0.9954

# 테스트셋을 통한 모델 평가
model.evaluate(X_test, y_test, verbose=2)
# verbose : 결과 출력의 단계 설정
# auto - 대부분 1로 지정됨
# 0 - 출력 없음
# 1 - 진행 상황 출력(프로그레스바 포함)
# 2 - 진행 상황 출력(프로그레스바 제외, 1에 비해 간소화)

7/7 - 0s - loss: 0.0478 - accuracy: 0.9861
[0.04781070724129677, 0.9861111044883728]


*1 가중치 행렬(Weight Matrix)
위에서는 퍼셉트론 하나라서 행렬이라기보다는 벡터였다.
하지만 아래와 같이 퍼셉트론 여러 개로 구성된 신경망이라면?

가중치 행렬


이렇게 되면 가중치 연산은 (편향은 없다 하면)
$$(w_1x_1+w_3x_1+w_5x_1+w_2x_2+w_4x_2+w_6x_2)\\
= \begin{bmatrix}x_1&x_2\end{bmatrix}\begin{bmatrix}w_1&w_3&w_5\\w_2&w_4&w_6\end{bmatrix} = \begin{bmatrix}y_1&y_2&y_3\end{bmatrix}$$
이렇게 되고, 결과를 정리해서 표현하면 $y = Wx$ 라고 할 수 있다.
여기서 입력값의 벡터 $x$와 출력값의 벡터 $y$를 이어주는 행렬 $W$를 가중치 행렬이라고 한다.

코드 상에서 가중치 행렬의 형태는 어떻게 알 수 있을까?

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=100), # 은닉층
    tf.keras.layers.Dense(1, activation='sigmoid') # 출력층
])

입력 데이터의 특성이 100개이므로 입력층 노드 수는 100, 은닉층의 노드 수는 10이므로 둘 사이의 가중치 행렬 형태는 (100, 10)이다.
같은 원리로 은닉층과 출력층 사이에서는 (10, 1)이 된다.


<참고 자료>

+ Recent posts