만년필잉크의 데이터 분석 지식 저장소

 이전 포스트에서 변수가 1개인 Input이 들어가 Output이 1개인 모델을 만들어보았다. 이번 포스트에서는 Input이 2개고, Output이 1개인 모델을 만들어보도록 하겠다.

학습 목표

• 이전 패턴보다 컴퓨터가 인지하기 어려운 패턴을 컴퓨터가 찾아내도록 해보자.
• 패턴: $ f(x)=\frac{1}{2}x_1^2-3x_2+5 $

1. 이전 방식대로 모델을 만들고 평가해보자.

• 이전 모델을 생성했던 방법대로 데이터셋을 생성하고 학습을 시켜서 패턴을 찾는지 확인해보자.

# Import Module
import pandas as pd
import numpy as np
from tensorflow import keras
from tensorflow.keras.layers import Dense

# Dataset 만들기
np.random.seed(1234)

def f2(x1, x2):
    
    return 0.5*x1**2 - 3*x2 + 5

X0_1 = np.random.randint(0, 100, (1000))
X0_2 = np.random.randint(0, 100, (1000))
X_train = np.c_[X0_1, X0_2]
y_train = f2(X0_1, X0_2)

X1_1 = np.random.randint(100, 200, (300))
X1_2 = np.random.randint(100, 200, (300))
X_test = np.c_[X1_1, X1_2]
y_test = f2(X1_1, X1_2)

# make model
model = keras.Sequential()
model.add(Dense(16, activation = 'relu'))
model.add(Dense(32, activation = 'relu'))
model.add(Dense(16, activation = 'relu'))
model.add(Dense(1, activation = 'linear'))


# Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt, loss='mse')


# Standardization
mean_key = np.mean(X_train)
std_key = np.std(X_train)

X_train_std = (X_train - mean_key)/std_key
y_train_std = (y_train - mean_key)/std_key

X_test_std = (X_test - mean_key)/std_key

>>> model.fit(X_train_std, y_train_std, epochs = 100)

Epoch 1/100
32/32 [==============================] - 1s 972us/step - loss: 4486.5587
Epoch 2/100
32/32 [==============================] - 0s 1ms/step - loss: 2577.3394
Epoch 3/100
32/32 [==============================] - 0s 974us/step - loss: 135.0658
Epoch 4/100
32/32 [==============================] - 0s 1ms/step - loss: 39.6805
Epoch 5/100
32/32 [==============================] - 0s 1ms/step - loss: 26.0182
Epoch 6/100
32/32 [==============================] - 0s 1ms/step - loss: 23.2357

...

Epoch 96/100
32/32 [==============================] - ETA: 0s - loss: 0.870 - 0s 730us/step - loss: 0.9306
Epoch 97/100
32/32 [==============================] - 0s 835us/step - loss: 0.4291
Epoch 98/100
32/32 [==============================] - 0s 792us/step - loss: 0.5671
Epoch 99/100
32/32 [==============================] - 0s 856us/step - loss: 0.3809
Epoch 100/100
32/32 [==============================] - 0s 708us/step - loss: 0.4041
<tensorflow.python.keras.callbacks.History at 0x21cdb6c0b80>

>>> pred = (model.predict(X_test_std) * std_key) + mean_key
>>> pred = pred.reshape(pred.shape[0])
>>> print("Accuracy:", np.sqrt(np.sum((y_test - pred)**2))/len(y_test))
Accuracy: 209.2436541220142

• 이전 포스트처럼 시험 데이터 셋과 학습 데이터 셋을 전혀 겹치지 않는 영역으로 만들어보았다.
• 손실 값은 0에 가깝게 줄어들었으나, 정확도(Accuracy)가 209.243으로 매우 낮은 것을 알 수 있다.
• 예측값과 라벨의 차이가 어느 정도인지 확인해보자.

result_DF = pd.DataFrame({"predict":pred, "label":y_test})
result_DF["gap"] = result_DF["label"] - result_DF["predict"]
result_DF

• 위 데이터를 보면, 실제(label)와 예측값(predict)의 차이가 매우 크게 나는 것을 볼 수 있다.
• 대체 왜 이런 현상이 발생한 것일까?

2. 학습에 맞는 데이터셋 만들기

• 이전 학습에서 숨겨져 있던 패턴은 다음과 같다.
• $h(x) = x + 10 $
• 위 패턴은 아주 단순한 선형 함수이므로, 학습 데이터 셋과 거리가 있는 데이터라 할지라도, 쉽게 예측할 수 있다.
• 그러나, 이번에 숨겨진 패턴인 $f(x)=\frac{1}{2}x_1^2-3x_2+5$은 $x^2$의 존재로 인해 선형 함수가 아니며, 해가 2개이므로, 이전에 비해 꽤 복잡해졌다.
• 이번엔 train Dataset에서 test Dataset을 분리해서 학습해보자.
• 단, train Dataset과 test Dataset은 절대 중복되선 안 된다.

# Dataset 만들기
np.random.seed(1234)

def f2(x1, x2):
    
    return 0.5*x1**2 - 3*x2 + 5

X1 = np.random.randint(0, 100, (1000))
X2 = np.random.randint(0, 100, (1000))
X = np.c_[X1, X2]
y = f2(X1, X2)

# 데이터셋을 중복되지 않게 만든다.
Xy = np.c_[X, y]
Xy = np.unique(Xy, axis = 0)
np.random.shuffle(Xy)
test_len = int(np.ceil(len(Xy)*0.3))
X = Xy[:, [0,1]]
y = Xy[:, 2]

# test Dataset과 train Dataset으로 나누기
X_test = X[:test_len]
y_test = y[:test_len]

X_train = X[test_len:]
y_train = y[test_len:]

• np.c_[array1, array2]: 두 array를 열 기준으로 붙인다.
• np.unique(array, axis = 0): array에서 unique 한 값만 추출한다(axis를 어떻게 잡느냐에 따라 다른 결과를 가지고 올 수 있다).
• np.random.shuffle(array): array를 랜덤 하게 섞는다
• np.ceil(float): float을 올림 한다.
• 데이터셋을 중복되지 않게 만들어, test set과 train set이 중복되어 Accuracy가 낮게 나오는 현상을 피한다.

# make model
model = keras.Sequential()
model.add(Dense(16, activation = 'relu'))
model.add(Dense(32, activation = 'relu'))
model.add(Dense(16, activation = 'relu'))
model.add(Dense(1, activation = 'linear'))


# Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt, loss='mse')


# Standardization
mean_key = np.mean(X_train)
std_key = np.std(X_train)

X_train_std = (X_train - mean_key)/std_key
y_train_std = (y_train - mean_key)/std_key

X_test_std = (X_test - mean_key)/std_key

# Model Learning
>>> model.fit(X_train_std, y_train_std, epochs = 100)

Epoch 1/100
139/139 [==============================] - 1s 912us/step - loss: 2999.6784
Epoch 2/100
139/139 [==============================] - 0s 943us/step - loss: 26.4051
Epoch 3/100
139/139 [==============================] - 0s 1ms/step - loss: 14.5395
Epoch 4/100
139/139 [==============================] - 0s 1ms/step - loss: 9.9778
Epoch 5/100
139/139 [==============================] - 0s 814us/step - loss: 7.2809
Epoch 6/100
139/139 [==============================] - 0s 777us/step - loss: 5.1137
Epoch 7/100

...

Epoch 96/100
139/139 [==============================] - 0s 1ms/step - loss: 0.0378
Epoch 97/100
139/139 [==============================] - 0s 931us/step - loss: 0.0468
Epoch 98/100
139/139 [==============================] - 0s 821us/step - loss: 0.0808
Epoch 99/100
139/139 [==============================] - 0s 745us/step - loss: 0.1535
Epoch 100/100
139/139 [==============================] - 0s 793us/step - loss: 0.0493
<tensorflow.python.keras.callbacks.History at 0x260b7b33c70>

>>> pred = (model.predict(X_test_std) * std_key) + mean_key
>>> pred = pred.reshape(pred.shape[0])
>>> print("Accuracy:", np.sqrt(np.sum((y_test - pred)**2))/len(y_test))
Accuracy: 0.9916198414587479

• 데이터 셋만 바꿨는데, 이전 데이터 셋의 정확도(Accuracy)가 209.243에서 0.9916으로 큰 폭으로 떨어진 것을 볼 수 있다.
• 실제 예측 결과가 어떻게 생겼는지 확인해보자.

result_DF = pd.DataFrame({"predict":pred, "label":y_test})
result_DF["gap"] = result_DF["label"] - result_DF["predict"]
result_DF

• 차이가 있긴 하지만, 실제 데이터와 상당히 가까워졌다.
• 이번엔 데이터의 양을 늘려서 학습시켜보자.

3. 데이터의 양을 늘려보자.

# Import Module
import pandas as pd
import numpy as np
from tensorflow import keras
from tensorflow.keras.layers import Dense




# Dataset 만들기
np.random.seed(1234)

def f2(x1, x2):
    
    return 0.5*x1**2 - 3*x2 + 5

X1 = np.random.randint(0, 100, (30000))
X2 = np.random.randint(0, 100, (30000))
X = np.c_[X1, X2]
y = f2(X1, X2)

# 데이터셋을 중복되지 않게 만든다.
Xy = np.c_[X, y]
Xy = np.unique(Xy, axis = 0)
np.random.shuffle(Xy)
test_len = int(np.ceil(len(Xy)*0.2))
X = Xy[:, [0,1]]
y = Xy[:, 2]

# test Dataset과 train Dataset으로 나누기
X_test = X[:test_len]
y_test = y[:test_len]

X_train = X[test_len:]
y_train = y[test_len:]




# make model
model = keras.Sequential()
model.add(Dense(32, activation = 'elu'))
model.add(Dense(32, activation = 'elu'))
model.add(Dense(1, activation = 'linear'))


# Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt, loss='mse')


# min-max scaling
min_key = np.min(X_train)
max_key = np.max(X_train)

X_train_std = (X_train - min_key)/(max_key - min_key)
y_train_std = (y_train - min_key)/(max_key - min_key)

X_test_std = (X_test - min_key)/(max_key - min_key)

>>> model.fit(X_train_std, y_train_std, epochs = 100)

Epoch 1/100
238/238 [==============================] - 1s 970us/step - loss: 168.8257
Epoch 2/100
238/238 [==============================] - 0s 1ms/step - loss: 4.6773A: 0s - loss: 5.8
Epoch 3/100
238/238 [==============================] - 0s 821us/step - loss: 1.2054
Epoch 4/100
238/238 [==============================] - 0s 842us/step - loss: 0.4222
Epoch 5/100
238/238 [==============================] - 0s 781us/step - loss: 0.1056
Epoch 6/100
238/238 [==============================] - 0s 851us/step - loss: 0.0459

...

Epoch 96/100
238/238 [==============================] - 0s 736us/step - loss: 4.2894e-04
Epoch 97/100
238/238 [==============================] - 0s 741us/step - loss: 5.0023e-04
Epoch 98/100
238/238 [==============================] - 0s 720us/step - loss: 0.0046
Epoch 99/100
238/238 [==============================] - 0s 749us/step - loss: 0.0036
Epoch 100/100
238/238 [==============================] - 0s 812us/step - loss: 0.0189
<tensorflow.python.keras.callbacks.History at 0x24611ae5910>

>>> pred = (model.predict(X_test_std) * (max_key - min_key)) + min_key
>>> pred = pred.reshape(pred.shape[0])
>>> print("Accuracy:", np.sqrt(np.sum((y_test - pred)**2))/len(y_test))
Accuracy: 0.03539701825569002

result_DF = pd.DataFrame({"predict":pred, "label":y_test})
result_DF["gap"] = result_DF["label"] - result_DF["predict"]
result_DF

• 중복을 제거하여 데이터의 양을 953개에서 9,493개로 늘렸다.
• 그로 인해 Accuracy가 0.9916에서 0.0353으로 감소하여, 정확도가 보다 올라갔다.
• 이상치가 존재하지 않는 데이터이므로, 최소-최대 스케일 변환(min-max scaling)을 이용해 표준화를 시켰다. 그로 인해, Accuracy가 크게 변하지는 않았으나, 이전에 비해 손실 값이 빠르게 0에 수렴하는 것을 볼 수 있다.
• 활성화 함수를 relu가 아닌 elu를 사용하였다. 성능 차이가 그리 크지는 않으나, 손실 값과 Accuracy에 긍정적인 영향을 미쳤다.
• 네트워크의 노드 수와 Layer의 수를 바꿨다.

 지금까지 변수가 2개인 데이터 셋을 학습시키는 과정을 해보았다. 숨어있는 패턴이 복잡하고 변수의 수가 늘어났더니, 처음 보는 영역에 있는 데이터를 제대로 분류하지 못하는 현상이 발생하였다.

 이 때는 학습 데이터셋에 시험 데이터셋과 유사한 데이터 셋을 포함시키는 것이 가장 좋은 해결 방법이다. 위처럼 시험 데이터 셋과 학습 데이터 셋이 중복되지 않는다 할지라도, 유사한 영역에 있는 경우 제대로 예측하는 것을 볼 수 있다.

인공신경망(ANN)과 다층 퍼셉트론(MLP)

 이전 포스트에서 단층 퍼셉트론이 행렬 연산을 통해 다음 노드로 정보를 전달하는 과정을 살펴보았다. 이전에 학습했었던 퍼셉트론과의 차이점은 활성화 함수로 계단 함수가 아닌 시그노이드 함수를 사용한 것이다.

 이렇게 활성화 함수에 정보를 전달하느냐 마느냐인 계단 함수를 넣는 것이 아니라, 시그노이드, 소프트맥스, 하이퍼볼릭 탄젠트, 렐루 등 다양한 활성화 함수를 넣고, 단층 퍼셉트론이 아닌, 다층 퍼셉트론을 만들고, 가중치를 인간이 수동으로 만드는 것이 아닌, 자동으로 가장 적합한 값을 찾아내는 것이 바로 인공 신경망이다.

1. 신경망의 구조

• "입력층 - 출력층"만 존재하는 단층 퍼셉트론(Single Layer Perceptron, SLP)과 달리 "입력층 - m개의 은닉층 - 출력층"이 존재하는 다층 퍼셉트론(Multi Layer Perceptron)은 "n-층 신경망"이라고도 부르며, 일반적으로 단층 퍼셉트론처럼 입력층을 제외하고 부르거나, 입력층을 0층으로 생각하고 "n = m + 1"로 은닉층의 개수 + 출력층 1개로 명명한다.
• 즉, 아래 다층 퍼셉트론은 3-층 신경망이라고 부른다.
• 이렇게 은닉층이 2개 이상인 신경망을 심층 신경망(Deep Neural Network)라 한다.
• 그러나, 간혹 다른 책에선 입력층까지 포함하여 m+2 층 신경망, 아래 예시에선 4-층 신경망이라 부르는 경우도 있다. 본, 블로그에서는 "은닉층의 수(m) + 출력층 1개"인 m+1층 신경망이라 부르도록 하겠다.

• 입력층(Input Layer): 
  파란색 노드로, 학습 데이터셋(Train dataset)이 입력되는 곳이다. 학습 데이터의 Feature의 차원 수만큼의 뉴런 개수를 가진다. 입력층은 단 한층만 존재한다.

• 은닉층(Hidden Layer):
  연두색 노드로, 입력층과 출력층 사이의 모든 층이다. 은닉층이라 불리는 이유는 입력층과 출력층은 Input 되는 Dataset과 Output 된 Dataset을 눈으로 확인할 수 있지만, 은닉층은 보이지 않기 때문이다.

• 출력층(Output Layer):
  주황색 노드로, 출력하고자 하는 데이터의 형태에 따라 노드의 수가 바뀐다. 예를 들어, 0부터 9까지 10 종류의 숫자가 있다고 할 때, 이를 분류하고자 한다면, 출력층의 노드 수는 10개가 되며, 시그모이드 함수를 사용하여, 이진 분류를 하고자 하는 경우엔 노드의 수가 1개가 된다.

2. 다층 퍼셉트론의 연산

• 다층 퍼셉트론의 연산 방식은 앞서 다뤘던 단층 퍼셉트론의 연산 방식과 동일하나, 더 많이 실시하게 된다.
• 가중치를 알아서 찾아내는 방식은 뒤에서 다루도록 하고, 이번에는 가중치를 임의로 만들어보자.

$$ X = (x_1, x_2, x_3) = (10, 2) $$

$$ W_1=
\begin{pmatrix}
w_{11}^{(1)} & w_{21}^{(1)} & w_{31}^{(1)}\\ 
w_{12}^{(1)} & w_{22}^{(1)} & w_{32}^{(1)}
\end{pmatrix}
=
\begin{pmatrix}
0.1 & 0.3 & 0.5\\ 
0.6 & 0.4 & 0.2 
\end{pmatrix} $$

$$W_2=
\begin{pmatrix}
w_{11}^{(2)} & w_{21}^{(2)}\\ 
w_{12}^{(2)} & w_{22}^{(2)}\\ 
w_{13}^{(2)} & w_{23}^{(2)}
\end{pmatrix}
=
\begin{pmatrix}
0.1 & 0.2\\ 
0.2 & 0.4\\
0.3 & 0.6
\end{pmatrix}$$

$$W_3=
\begin{pmatrix}
w_{11}^{(3)} & w_{21}^{(3)}\\ 
w_{12}^{(3)} & w_{22}^{(3)}\\ 
\end{pmatrix}
=
\begin{pmatrix}
0.2 & 0.4\\ 
0.4 & 0.8
\end{pmatrix}$$

$$B_1 = (b_{1}^{(1)}, b_{2}^{(1)}, b_{3}^{(1)})=(0.7, 0.6, 0.5)$$

$$B_2 = (b_{1}^{(2)}, b_{2}^{(2)})=(0.6, 0.4)$$

$$B_3 = (b_{1}^{(3)}, b_{2}^{(3)})=(0.5, 0.6)$$

• 활성화 함수는 은닉층에서는 렐루 함수를 사용하고, 출력층에서는 시그모이드 함수를 사용해보자.
• 즉, $f()$는 렐루 함수, $h()$는 시그모이드 함수이다.

3. 구현해보자.

• 먼저 데이터를 생성하고, 데이터의 모양을 봐야 한다.
• 기계학습에선 행렬곱이 주를 이르므로, 행렬의 모양을 파악하는 것이 최우선이다.

>>> X = np.array([10, 2])

>>> W1 = np.array([[0.1, 0.3, 0.5], [0.6, 0.4, 0.2]])
>>> W2 = np.array([[0.1, 0.2],[0.2, 0.4],[0.3, 0.6]])
>>> W3 = np.array([[0.2, 0.4],[0.4, 0.8]])

>>> B1 = np.array([0.7, 0.6, 0.5])
>>> B2 = np.array([0.6, 0.4])
>>> B3 = np.array([0.5, 0.6])

>>> print("X Shape:", X.shape)
>>> print("----"*20)
>>> print("W1 Shape:", W1.shape)
>>> print("W2 Shape:", W2.shape)
>>> print("W3 Shape:", W3.shape)
>>> print("----"*20)
>>> print("B1 Shape:", B1.shape)
>>> print("B2 Shape:", B2.shape)
>>> print("B3 Shape:", B3.shape)

X Shape: (2,)
--------------------------------------------------------------------------------
W1 Shape: (2, 3)
W2 Shape: (3, 2)
W3 Shape: (2, 2)
--------------------------------------------------------------------------------
B1 Shape: (3,)
B2 Shape: (2,)
B3 Shape: (2,)

• 중요한 것은 노드와 가중치 엣지의 모양이다.
• 편향은 위 노드와 가중치 엣지의 모양만 제대로 맞게 이루어져 있다면, 벡터 합이 당연히 되므로, 신경 쓰지 않아도 된다.

>>> def ReLU(x):
>>>     return np.maximum(0, x)

>>> def sigmoid(x):
>>>     return 1 / (1 + np.exp(-x))


# 입력층에서 출력층 방향으로 계산된다.
>>> A1 =  np.dot(X, W1) + B1
>>> Z1 = ReLU(A1)

>>> A2 = np.dot(Z1, W2) + B2
>>> Z2 = ReLU(A2)

>>> A3 = np.dot(Z2, W3) + B3
>>> Y = sigmoid(A2)

>>> Y

array([0.97180471, 0.9981301 ])

• 위 코드를 보면, 입력층 X에서 출발한 데이터가 "행렬곱 > 활성화 함수 > 행렬곱 > 활성화 함수 > 행렬곱 > 활성화 함수 > 출력"의 형태로 진행된 것을 알 수 있다.
• 이를 보면, 단층 퍼셉트론을 활성화 함수만 바꾸면서 층을 쌓듯 여러 번 수행된 것을 알 수 있다.

4. 순전파(Forward Propagation)

• 위 신경망에서 데이터의 흐름은 입력층에서 출력층의 방향으로 전달되었는데, 이를 순전파라고 한다.
• 위에서 인공 신경망은 스스로 가장 적합한 가중치를 찾아간다고 하였는데, 이를 우리는 학습이라고 하며, 이 학습은 역전파(Back Propagation) 과정을 통해 이루어진다.
• 만약 내가 신경망의 틀을 만들고, 그 신경망에서 가장 적합한 가중치를 찾는 것을, 이는 학습을 한다고 하며, 모델을 만든다라고 한다. 지금 같이 이미 가중치를 알고 있는 상태는 학습이 끝난, 모델이 완성된 상태이며, 이 모델에 데이터를 집어넣어, 그 결과를 확인하는 것은 순전파 되어 실행된다.

 지금까지 이미 가중치가 얻어진 다층 퍼셉트론(MLP)을 이용해, 신경망이 어떻게 연산되는지를 알아보았다. 신경망의 연산은 행렬곱과 활성화 함수 이 두 가지를 통해서 구해지는, 생각보다 단순한 알고리즘인 것을 알 수 있다. 

 다음 포스트에서는 그렇다면 대체 그 학습이라는 과정은 어떻게 이루어지는 지에 대해 알아보도록 하겠다.