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

 이전 포스트에서 데이터 셋을 표준 정규분포로 만들어 더 쉽게 데이터셋을 모델에 학습시켜보았다. 그러나, 패턴의 단순함에 비해 여전히 정확도(Accuracy)가 원하는 수준까지 나오질 않는다. 대체 왜 그럴까?

 이번 포스트에서는 경험적 하이퍼 파라미터 튜닝 방법을 사용하여, 하이퍼 파라미터를 튜닝해보도록 하겠다. 제대로 된 하이퍼 파라미터 튜닝은 추후 자세히 다루도록 하겠다.

하이퍼 파라미터 튜닝(HyperParameter Tuning)

• 머신러닝을 공부하다 보면 하이퍼 파라미터라는 단어와 파라미터라는 단어가 반복해서 등장하는 것을 볼 수 있다. 
• 파라미터(Parmeter)라는 단어는 코딩을 하다 보면 자주 보이는, 수정할 수 있는 값인데, 갑자기 왜 하이퍼 파라미터라는 값이 등장할까? 또, 왜 파라미터는 수정할 수 없는 값이라고 할까?
• 머신러닝에서의 파라미터는 가중치(Weight), 편향(Bias) 같은 학습 과정에서 모델이 자동으로 업그레이드하며 갱신하는 값을 가리킨다.
• 파라미터는 학습 도중 머신이 알아서 바꿔가는 것이므로, 연구자가 손 델 수 있는 값이 아니다.
• 머신러닝에서 하이퍼 파라미터는 그 외 연구자가 수정할 수 있는 값으로, 학습률, Optimizer, 활성화 함수, 손실 함수 등 다양한 인자들을 가리킨다.
• 이 값들을 손보는 이유는 모델이 학습에 사용한 데이터 셋의 형태를 정확히 알지 못하고, 데이터 셋의 형태에 따라 이들을 사용하는 방법이 바뀌기 때문이다.

1. 하이퍼 파라미터 튜닝을 해보자.

• 우리는 이미 우리가 만들어낸 데이터 셋의 형태를 알고 있다.
• 우리가 만들어낸 데이터셋은 선형 데이터셋인데, 우리는 활성화 함수로 은닉층에서 ReLU를 사용하였다.
• 이번엔 모든 활성화 함수를 linear로 만들어 학습시켜보자.

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



# Dataset Setting
def f(x):
    return x + 10
    
# Data set 생성
np.random.seed(1234)   # 동일한 난수가 나오도록 Seed를 고정한다.
X_train = np.random.randint(0, 100, (100, 1))
X_test = np.random.randint(100, 200, (20, 1))

# Label 생성
y_train = f(X_train)
y_test = f(X_test)


# Model Setting
model = keras.Sequential()
model.add(Dense(16, activation='linear'))
model.add(Dense(1, activation='linear'))


# Compile: 학습 셋팅
opt = keras.optimizers.Adam(learning_rate=0.01)
model.compile(optimizer=opt, loss = 'mse')


# 특성 스케일 조정
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
4/4 [==============================] - 0s 2ms/step - loss: 2.5920
Epoch 2/100
4/4 [==============================] - 0s 997us/step - loss: 1.5766
Epoch 3/100
4/4 [==============================] - 0s 2ms/step - loss: 0.7499
Epoch 4/100
4/4 [==============================] - 0s 2ms/step - loss: 0.3371
Epoch 5/100
4/4 [==============================] - 0s 2ms/step - loss: 0.0817
Epoch 6/100
4/4 [==============================] - 0s 2ms/step - loss: 0.0059

...

Epoch 95/100
4/4 [==============================] - 0s 1ms/step - loss: 6.0676e-15
Epoch 96/100
4/4 [==============================] - 0s 1ms/step - loss: 6.2039e-15
Epoch 97/100
4/4 [==============================] - 0s 2ms/step - loss: 6.4773e-15
Epoch 98/100
4/4 [==============================] - 0s 2ms/step - loss: 5.6185e-15
Epoch 99/100
4/4 [==============================] - 0s 1ms/step - loss: 6.5939e-15
Epoch 100/100
4/4 [==============================] - 0s 1ms/step - loss: 6.7939e-15
<tensorflow.python.keras.callbacks.History at 0x26e75c29e80>

# label과 test set을 비교해보자.
pred = model.predict(X_test_std.reshape(X_test_std.shape[0]))
pred_restore = pred * std_key + mean_key
predict_DF = pd.DataFrame({"predict":pred_restore.reshape(pred_restore.shape[0]), "label":y_test.reshape(y_test.shape[0])})
predict_DF["gap"] = predict_DF["predict"] - predict_DF["label"]
predict_DF

# 정확도(Accuracy)를 보자
>>> print("Accuracy:", np.sqrt(np.mean((pred_restore - y_test)**2)))
Accuracy: 1.0789593218788873e-05

• 고작, 은닉층의 활성화 함수만 바꿨을 뿐인데, 이전보다 훨씬 좋은 결과가 나왔다.
• 패턴을 거의 완벽하게 찾아내었으며, 정확도(Accuracy) 역시 0.000010789(e-05는 $10^{-5}$을 하라는 소리다.)로 거의 0에 근사하게 나왔다.

2. 정리

• 위 결과를 보면, 아무리 단순한 패턴이라 할지라도, 그 데이터 셋의 형태를 반영하지 못한다면, 정확히 그 결과를 찾아내지 못할 수 있다는 것을 알 수 있다.
• 인공지능은 흔히들 생각하는 빅데이터를 넣으면, 그 안에 숨어 있는 패턴이 자동으로 나오는 마법의 상자가 아니라, 연구자가 그 데이터에 대한 이해를 가지고 여러 시도를 해, 제대로 된 설계를 해야만 내가 원하는 제대로 된 패턴을 찾아낼 수 있는 도구다.
• 그러나, 실전에서는 지금처럼 우리가 이미 패턴을 알고 있는 경우는 없기 때문에 다양한 도구를 이용해서, 데이터를 파악하고, 적절한 하이퍼 파라미터를 찾아낸다.
• 넣을 수 있는 모든 하이퍼 파라미터를 다 넣어보는 "그리드 서치(Greed search)"나 랜덤 한 값을 넣어보고 지정한 횟수만큼 평가하는 "랜덤 서치(Random Search)", 순차적으로 값을 넣어보고, 더 좋은 해들의 조합에 대해서 찾아가는 "베이지안 옵티마이제이션(Bayesian Optimization)" 등 다양한 방법이 있다.
• 같은 알고리즘이라 할지라도, 데이터를 어떻게 전처리하느냐, 어떤 활성화 함수를 쓰느냐, 손실 함수를 무엇을 쓰느냐 등과 같은 다양한 요인으로 인해 다른 결과가 나올 수 있으므로, 경험을 많이 쌓아보자.

 이전 포스트에서 만든 모델의 결과는 그리 나쁘진 않았으나, 패턴이 아주 단순함에도 쉽게 결과를 찾아내지 못했고, 학습에 자원 낭비도 많이 되었다.

 왜 그럴까?

특성 스케일 조정

• 특성 스케일 조정을 보다 쉽게 말해보면, 표준화라고 할 수 있다.
• 이번에 학습한 대상은 변수(다른 정보에 대한 벡터 성분)가 1개밖에 없어서 그나마 나았으나, 만약, 키와 몸무게가 변수로 주어져 벡터의 원소로 들어갔다고 생각해보자.
• 키나 몸무게는 그 자리 수가 너무 큰 값이다 보니, 파라미터 역시 그 값의 변화가 지나치게 커지게 되고, 그로 인해 제대로 된 결과를 찾지 못할 수 있다.
• 또한 키와 몸무게는 그 단위마저도 크게 다르다 보니, 키에서 160이 몸무게에서의 160과 같다고 볼 수 있다. 그러나 모두가 알다시피 키 160은 대한민국 남녀 성인 키 평균에 못 미치는 값이며, 몸무게 160은 심각한 수준의 비만이다. 전혀 다른 값임에도 이를 같게 볼 위험이 있다는 것이다.
• 이러한 표준화가 미치는 영향은 손실 함수에서 보다 이해하기 쉽게 볼 수 있는데, 이로 인해 발생하는 문제가 바로 경사 하강법의 zigzag 문제다.

• $w_1$과 $w_2$의 스케일 크기가 동일하다면(값의 범위가 동일), 손실 함수가 보다 쉽게 최적해에서 수렴할 수 있다.

• $w_1$과 $w_2$의 스케일 크기가 많이 다르다면, 손실 함수는 쉽게 최적해에 수렴하지 못한다.

1. 특성 스케일 조정 방법

• 특성 스케일 조정 방법은 크게 2가지가 있다.
• 첫 번째는 특성 스케일 범위 조정이고, 두 번째는 표준 정규화를 하는 것이다.

A. 특성 스케일 범위 조정

• 특성 스케일 범위 조정은 말 그대로, 값의 범위를 조정하는 것이다.
• 바꿀 범위는 [0, 1]이다.
• 이 방법에는 최솟값과 최댓값이 사용되므로 "최소-최대 스케일 변환(min-max scaling)"이라고도 한다.
• 공식은 다음과 같다.

$$ x_{norm} = \frac{x_i-x_{min}}{x_{max}-x_{min}} $$

• 위 공식에서 $x_i$는 표준화를 할 대상 array다.
• 범위 축소에 흔히들 사용되는 해당 방법은, 가장 쉽게 표준화하는 방법이지만, 값이 지나치게 축소되어 존재하던 이상치가 사라져 버릴 수 있다.
• 특히나, 이상치가 존재한다면, 이상치보다 작은 값들을 지나치게 좁은 공간에 모아버리게 된다.

B. 표준 정규분포

• 표준 정규분포는 평균 = 0, 표준편차 = 1로 바꾸는 가장 대표적인 표준화 방법이다.
• 공식은 다음과 같다.

$$ x_{std} = \frac{x_i - \mu_x}{\sigma_x} $$

• 위 공식에서 $x_i$는 표준화 대상 array다.
• 표준 정규분포로 만들게 되면, 평균 = 0, 표준편차 = 1로 값이 축소되게 되지만, 여전히 이상치의 존재가 남아 있기 때문에 개인적으론 표준 정규분포로 만드는 것을 추천한다.

 특성 스케일 조정에서 가장 중요한 것은, 조정의 기준이 되는 최솟값, 최댓값, 평균, 표준편차는 Train Dataset의 값이라는 것이다. 해당 방법 사용 시, Train Dataset을 기준으로 하지 않는다면, Test Dataset의 값이 Train Dataset과 같아져 버릴 수 있다.

2. 표준 정규분포를 이용해서 특성 스케일을 조정해보자.

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



# Dataset Setting
def f(x):
    return x + 10
    
# Data set 생성
np.random.seed(1234)   # 동일한 난수가 나오도록 Seed를 고정한다.
X_train = np.random.randint(0, 100, (100, 1))
X_test = np.random.randint(100, 200, (20, 1))

# Label 생성
y_train = f(X_train)
y_test = f(X_test)


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


# Compile: 학습 셋팅
opt = keras.optimizers.Adam(learning_rate=0.01)
model.compile(optimizer=opt, loss = 'mse')

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

• 앞의 모델 생성 및 Compile 단계까진 동일하나, 뒤에 표준화 과정이 추가된다.
• Train Dataset의 평균과 표준편차는 test의 Dataset이 나중에 주어져 현재 할 수 없거나, predict의 결과 원상 복귀에 사용되므로, 따로 Scalar 값을 빼놓자.

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

Epoch 1/100
4/4 [==============================] - 0s 1ms/step - loss: 0.5749
Epoch 2/100
4/4 [==============================] - 0s 1ms/step - loss: 0.2483
Epoch 3/100
4/4 [==============================] - 0s 3ms/step - loss: 0.0814
Epoch 4/100
4/4 [==============================] - 0s 2ms/step - loss: 0.0217
Epoch 5/100
4/4 [==============================] - 0s 2ms/step - loss: 0.0378
Epoch 6/100
4/4 [==============================] - 0s 1ms/step - loss: 0.0402

...

Epoch 95/100
4/4 [==============================] - 0s 2ms/step - loss: 4.5394e-06
Epoch 96/100
4/4 [==============================] - 0s 1ms/step - loss: 5.2252e-06
Epoch 97/100
4/4 [==============================] - 0s 2ms/step - loss: 5.7370e-06
Epoch 98/100
4/4 [==============================] - 0s 2ms/step - loss: 5.9242e-06
Epoch 99/100
4/4 [==============================] - 0s 2ms/step - loss: 5.8228e-06
Epoch 100/100
4/4 [==============================] - 0s 2ms/step - loss: 5.6276e-06
<tensorflow.python.keras.callbacks.History at 0x234ff82a520>

• 이전에 비해 적은 epochs(=100)로 빠르게 손실 값이 0에 수렴하는 것을 볼 수 있다.
• 결과를 보도록 하자.

pred = model.predict(X_test_std.reshape(X_test_std.shape[0]))

# 원상복구
pred_restore = pred * std_key + mean_key
predict_DF = pd.DataFrame({"predict":pred_restore.reshape(pred_restore.shape[0]), "label":y_test.reshape(y_test.shape[0])})
predict_DF["gap"] = predict_DF["predict"] - predict_DF["label"]
predict_DF

# RMSE로 Accuracy를 확인해보자.
>>> print("Accuracy:", np.sqrt(np.mean((pred_restore - y_test)**2)))
Accuracy: 0.07094477537881977

• 이전에 비해 확실히 빠르게 최적화가 되었으나, 여전히 예측값은 원하는 수준에 미치지 못한다.
• 굉장히 단순한 패턴임에도 불구하고, 아직까지 약간 다르다.

  이 정도로 단순한 패턴이라면, 예측값과 실제값의 차이가 거의 없어야 하나, 아직까지 차이가 크다는 생각이 든다. 다음 포스트에서는 최종적으로 한 가지를 수정하고, 해당 코드를 최종적으로 정리해보도록 하자.

 지난 포스트에서 작성한 코드들을 간략히 정리해보고, 본격적으로 학습 및 결과 평가를 해보자.

학습 목표

• 분석가가 알고 있는 패턴$f(x) = x + 10$에 대한 데이터를 생성하고, 그 패턴을 찾아내는 모델을 만들어보자.
• Input은 Node 1개, Output도 Node 1개인 연속형 데이터를 생성한다.

1. 지난 코드 정리

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



# Dataset Setting
def f(x):
    return x + 10
    
# Data set 생성
np.random.seed(1234)   # 동일한 난수가 나오도록 Seed를 고정한다.
X_train = np.random.randint(0, 100, (100, 1))
X_test = np.random.randint(100, 200, (20, 1))

# Label 생성
y_train = f(X_train)
y_test = f(X_test)



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



# Compile: 학습 셋팅
opt = keras.optimizers.Adam(learning_rate=0.01)
model.compile(optimizer=opt, loss = 'mse')

2. 학습 시작

>>> model.fit(X_train, y_train, epochs = 100)

• model.fit(): model에 대해 학습을 시작한다.
• fit() 안에는 train dataset, train data label, validation dataset 등이 들어갈 수 있다.
• validation dataset은 성능 향상에 도움이 되나, 꼭 필요한 것은 아니다.
• epochs은 전체 train set을 몇 번 학습할 것인가를 의미한다.
• 해당 코드를 실행하면 다음과 같은 문자들이 출력된다.

Epoch 1/100
4/4 [==============================] - 0s 2ms/step - loss: 955.4686
Epoch 2/100
4/4 [==============================] - 0s 998us/step - loss: 342.0951
Epoch 3/100
4/4 [==============================] - 0s 2ms/step - loss: 51.7757
Epoch 4/100
4/4 [==============================] - 0s 1ms/step - loss: 43.6929
Epoch 5/100
4/4 [==============================] - 0s 2ms/step - loss: 95.3333
Epoch 6/100
4/4 [==============================] - 0s 2ms/step - loss: 76.1808
Epoch 7/100
4/4 [==============================] - 0s 1ms/step - loss: 29.2552
Epoch 8/100
4/4 [==============================] - 0s 2ms/step - loss: 21.1532

...

Epoch 94/100
4/4 [==============================] - 0s 2ms/step - loss: 4.9562
Epoch 95/100
4/4 [==============================] - 0s 1ms/step - loss: 5.3142
Epoch 96/100
4/4 [==============================] - 0s 996us/step - loss: 5.0884
Epoch 97/100
4/4 [==============================] - 0s 2ms/step - loss: 4.9754
Epoch 98/100
4/4 [==============================] - 0s 2ms/step - loss: 5.3013
Epoch 99/100
4/4 [==============================] - 0s 1ms/step - loss: 5.0656
Epoch 100/100
4/4 [==============================] - 0s 1ms/step - loss: 4.4677
<tensorflow.python.keras.callbacks.History at 0x12fe8f0f520>

• 위 내용을 history라고 하며, 따로 history를 지정하지 않아도 출력된다.
• loss는 손실 값을 의미하며, 해당 값이 최소화되는 위치를 찾는 것이 목적이다.
• 일반적으로 loss가 0에 근사 해지는 것을 목적으로 한다.
• 만약 loss가 0에서 지나치게 먼 값에서 수렴한다면, 모델에 들어간 인자들(HyperParameter)이 잘못 들어간 것일 가능성이 매우 높으므로, 모델을 수정하길 바란다.
• loss가 지금처럼 0에 가깝게 내려 가긴 했으나, 그 정도가 0에 미치지 못한 경우 단순하게 epoch를 늘려보자.

>>> model.fit(X_train, y_train, epochs = 500)

Epoch 1/500
4/4 [==============================] - 1s 2ms/step - loss: 9528.2801
Epoch 2/500
4/4 [==============================] - 0s 2ms/step - loss: 7191.2032
Epoch 3/500
4/4 [==============================] - 0s 2ms/step - loss: 4662.3104
Epoch 4/500
4/4 [==============================] - 0s 1ms/step - loss: 2927.8638
Epoch 5/500
4/4 [==============================] - 0s 2ms/step - loss: 1738.3485
Epoch 6/500
4/4 [==============================] - 0s 2ms/step - loss: 877.1409

...

Epoch 495/500
4/4 [==============================] - 0s 2ms/step - loss: 0.0126
Epoch 496/500
4/4 [==============================] - 0s 1ms/step - loss: 0.0139
Epoch 497/500
4/4 [==============================] - 0s 1ms/step - loss: 0.0183
Epoch 498/500
4/4 [==============================] - 0s 1ms/step - loss: 0.0180
Epoch 499/500
4/4 [==============================] - 0s 2ms/step - loss: 0.0168
Epoch 500/500
4/4 [==============================] - 0s 2ms/step - loss: 0.0229

• Epochs를 500까지 올렸으나, loss 값이 원하는 만큼 나오지 않는 것을 볼 수 있다.

3. 결과를 확인해보자.

• 결과 확인은 상당히 단순하면서도 새로운 알고리즘을 만들어내야 할 필요성이 있는 영역이다.

>>>  model.predict(X_test.reshape(X_test.shape[0]))

array([[195.04504 ],
       [151.02899 ],
       [111.01437 ],
       [124.019135],
       [113.015114],
       [140.02496 ],
       [122.0184  ],
       [183.04066 ],
       [129.02095 ],
       [136.02351 ],
       [206.04909 ],
       [178.03883 ],
       [174.03737 ],
       [132.02205 ],
       [166.03447 ],
       [194.0447  ],
       [118.01694 ],
       [154.03008 ],
       [134.02278 ],
       [204.04832 ]], dtype=float32)

• model.predict(array): 들어간 array에 대하여 모델의 파라미터(가중치)들이 순방향으로 연산되어 나온 결과가 출력된다.
• 모델에 Input되는 데이터와 predict에 들어가는 데이터의 모양은 조금 다르다.

# 모델 Input 시
>>> X_test.shape
(20, 1)

# Predict Input 시
>>> X_test.reshape(X_test.shape[0]).shape
(20,)

• 모델 학습 시엔 데이터를 행 단위로 떨어뜨려 넣었다면, predict에선 위와 같이 넣어줘야 한다.

test set의 Label과 비교해보자.

• predict 결과와 Label 데이터인 y_test를 비교해보자.

pred = model.predict(X_test.reshape(X_test.shape[0]))
predict_DF = pd.DataFrame({"predict":pred.reshape(pred.shape[0]), "label":y_test.reshape(y_test.shape[0])})
predict_DF["gap"] = predict_DF["predict"] - predict_DF["label"]
predict_DF

• predict와 label이 어느 정도 근사하게 나오긴 하였으나, 얼마나 근사하게 나왔는지 보기가 어렵다.
• 모델을 평가하기 쉽도록, RMSE를 사용하여 Scalar값(숫자 1개)으로 바꿔주자.

>>> print("Accuracy:", np.sqrt(np.mean((pred - y_test)**2)))
Accuracy: 0.10477323661232778

• 0.1047로 나름 나쁘지 않은 결과가 나오긴 하였으나, $f(x) = x + 10$ 같이 굉장히 단순한 패턴을 만족스러운 수준으로 찾아내지 못했다.
• 게다가 패턴도 지나치게 단순한데, epochs가 500이나 사용되어, 생각보다 많은 자원이 낭비되었다.

 이번 포스트에서는 널리 알려진 방식대로 학습을 시켜보았다. 그러나, 아주 단순한 패턴임에도 불구하고, 쉽게 찾아내질 못하였으며, 그 결과도 원하는 것에 미치지 못했다.

 다음 포스트에서는 어디가 잘못되었는지 찾아내 이를 수정해보도록 하자.

 지난 포스트에서 데이터 셋에 대해 간략히 설명해보았다. 이번 포스트부터 본격적으로 텐서플로우를 사용해서, 내가 찾아내고 싶은 알고리즘을 찾아내 보자.

학습 목표

• 분석가가 알고 있는 패턴으로 데이터를 생성하고, 그 패턴을 찾아내는 모델을 만들어보자.
• Input이 1개, Output이 1개인 연속형 데이터에서 패턴을 찾아보자.

1. 데이터 셋 생성

• 패턴: $f(x) = x + 10$

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

def f(x):
    return x + 10
    
# Data set 생성
np.random.seed(1234)   # 동일한 난수가 나오도록 Seed를 고정한다.
X_train = np.random.randint(0, 100, (100, 1))
X_test = np.random.randint(100, 200, (20, 1))

# Label 생성
y_train = f(X_train)
y_test = f(X_test)

데이터 셋 생성 코드의 함수 설명

1. np.random.seed(int):  난수(랜덤 한 데이터) 생성 시, 그 값은 생성할 때마다 바뀌게 된다. 데이터 셋이 바뀌게 되면, 일관된 결과를 얻기가 힘들어, 제대로 된 비교가 힘들어지므로, 난수를 생성하는 방식을 고정시킨다. 이를 시드 결정(Set seed)이라 하며, 숫자는 아무 숫자나 넣어도 상관없다.
2. np.random.randint(시작 int, 끝 int, shape): 시작 숫자(포함)부터 끝 숫자(미포함)까지 shape의 형태대로 array를 생성한다.

데이터 셋 생성 코드 설명

1. Train set은 0~100까지의 숫자를 랜덤으로 (100, 1)의 형태로 추출하였다.
2. Test set은 100~200까지의 숫자로 랜덤으로 (20, 1)의 형태로 추출했다. 여기서 값은 Train set과 절대 겹쳐선 안된다.
3. Label 데이터인 y_train과 y_test는 위에서 설정된 함수 f(x)에 의해 결정되었다.

• train 데이터 생김새(가시성을 위해 10개까지만 출력)

# train Dataset을 10개까지만 가져와보자
>>> X_train[:10]

array([[47],
       [83],
       [38],
       [53],
       [76],
       [24],
       [15],
       [49],
       [23],
       [26]])
       
>>> X_train.shape
(100, 1)

• 생성된 데이터 셋의 형태는 "(데이터 셋 수, 변수의 수)"라고 인지해도 좋다.
• 여기서 "변수의 수"는 "데이터 하나의 벡터 크기"라고 생각하는 것이 더 적합하다.
• 기본적으로 Tensorflow에 Input 되고 Output 되는 데이터의 형태는 이렇다고 생각하자.

2. 모델 생성하기

• tensorflow를 사용해 모델을 생성하는 경우, tensorflow가 아닌 keras를 사용하게 된다.
• 위에서 tensorflow의 기능을 가져올 때, 아래와 같은 코드로 가져왔다.
• from tensorflow import keras
• 이는, tensorflow라는 프레임워크에서 keras라는 모듈을 가지고 온다는 의미이다.
• keras는 추후 설명하게 될지도 모르지만, 모델 생성 및 학습에 있어 직관적으로 코드를 짤 수 있게 해 주므로, 쉽게 tensorflow를 사용할 수 있게 해 준다.
• 물론, keras와 tensorflow는 태생적으로 서로 다른 프레임워크이므로, 이 둘이 따로 에러를 일으켜, 에러 해결을 어렵게 한다는 단점이 있긴 하지만, 그걸 감안하고 쓸만한 가치가 있다.

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

• keras를 사용해서 모델을 만드는 방법은 크게 2가지가 있다.
• 하나는 위 같이 add를 이용해서 layer를 하나씩 추가해 가는 방법이 있고

model = keras.Sequential([
    Dense(16, activation='relu'),
    Dense(1, activation='linear')
])

• 이렇게 keras.Sequential([]) 안에 층(layer)을 직접 넣는 방법이 있다.
• 처음 방법처럼 add를 사용하는 방법은 API 사용 방법이고, 아래와 같이 층을 Sequential([])에 직접 넣는 방식은 Layer 인스턴스를 생성자에게 넘겨주는 방법이라 하는데, 전자인 API를 사용하는 방법을 개인적으로 추천한다.
• 그 이유는 다중-아웃풋 모델, 비순환 유향 그래프, 레이어 공유 모델 같이 복잡한 모델 정의 시, 매우 유리하기 때문으로, 이는 나중에 다루겠으나, 이 것이 Tensorflow의 장점이다.

모델 생성 코드 함수 설명

1. keras.Sequential(): 순차 모델이라 하며, 레이어를 선형으로 연결해 구성한다. 일반적으로 사용하는 모델로 하나의 텐서가 입력되고 출력되는 단일 입력, 단일 출력에 사용된다. 다중 입력, 다중 출력을 하는 경우나, 레이어를 공유하는 등의 경우엔 사용하지 않는다.
2. model.add(layer): layer를 model에 층으로 쌓는다. 즉, 위 모델은 2개의 층을 가진 모델이다.
3. Dense(노드 수, 활성화 함수): 완전 연결 계층으로, 전, 후 층을 완전히 연결해주는 Layer다. 가장 일반적으로 사용되는 Layer다.

모델 생성 코드 설명

1. 해당 모델은 Input 되는 tensor도 1개 Output 되는 tensor도 1개이므로, Sequential()로 모델을 구성했다.
2. 은닉층에는 일반적으로 ReLU 활성화 함수가 사용된다고 하니, ReLU를 넣었다.
3. 출력층에는 출력 결과가 입력 값과 같은 노드 1개이므로, 노드 1개로 출력층을 만들었다. 
4. 일반적으로 Node의 수를 $2^n$으로 해야 한다고 하지만, 크게 상관없다는 말이 있으므로, 굳이 신경 쓰지 않아도 된다. 처음엔 자기가 넣고 싶은 값을 넣다가, 성능이 안 나온다 싶으면 바꿔보는 수준이니 크게 신경 쓰지 말자.
5. 사용된 활성화 함수(activation)는 일반적으로 은닉층에 ReLU를 넣고, 연속형 데이터이므로 출력층에 Linear를 넣어보았다.

• 해당 활성화 함수에 대해 궁금증이 들면, 다음 포스트(계단함수와 선형함수, 렐루 함수)를 확인하길 바란다.

3. 모델 컴파일하기

• 컴파일은 모델을 학습시키기 전에 어떤 방식으로 학습을 시킬지를 설정하는 과정이다.

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

코드 설명

1. keras.optimizers.Adam(): 최적화에 사용할 함수를 위처럼 외부에서 만들어서 넣는 경우, 학습률, 모멘텀 같은 인자들을 입맛에 맞게 바꿀 수 있다.
2. model.complie(): 학습 방식을 설정한다.

compile은 기본적으로 3가지 인자를 입력으로 받는다.

1. optimizer: 최적화하는 방법으로, 경사 하강법(GD)을 어떤 방법을 통해 사용할지를 결정한다. 일반적으로 Adam이 많이 사용된다.
2. loss: 손실 함수를 설정한다. 일반적으로 연속형 데이터라면 제곱 오차 시리즈를, 분류 데이터라면 교차 엔트로피 오차 시리즈를 사용한다.
3. metric: 기준이 되는 것으로, 분류를 할 때 주로 사용한다.

• 손실 함수와 최적화에 관심이 있다면 다음 포스트(손실 함수, 최적화)를 참고하길 바란다.

 자, 지금까지 학습을 위한 모델 세팅을 완료하였다. 다음 포스트에서는 위 코드들을 깔끔하게 정리하고, 실제 학습을 해보겠다.

 이전 포스트에서 확률적 경사 하강법(SGD)에 대해 알아보았다. 해당 포스트에서 경사 하강법 함수 자체는 단순하므로, 이것만 구현하는 것은 쉬우나, 그 성능을 시각적으로 보기 위해선 학습에 대한 모든 알고리즘을 넣어야 하기 때문에 코드가 꽤 어려워지므로, 시간 낭비라고는 하였다.

 그러나, 이에 대하여 관심 있는 사람이 있을 수 있고, 눈으로 직접 코드가 돌아가는 과정을 본다면, 내용을 이해하기 더 쉬울 수 있으므로, 이를 다룬 책을 찾아 코드를 약간 수정하여, 이해하기 쉽도록 풀어보도록 하겠다. 딥러닝에서 사용되는 다층 퍼셉트론을 사용한 예시는 아니지만, 시각적으로 결과를 볼 수 있으므로 좋은 예시라고 생각한다.

 이번 포스트는 세바스찬 라시카, 바히드 미자리의 "머신러닝 교과서 with 파이썬, 사이킷런, 텐서플로"를 참고하여 작성하였다. 해당 책은 딥러닝을 구성하는 알고리즘에 대해 하나하나 다루고 있는 아주 좋은 책이므로, 꼭 읽어보기 바란다.

아달린 확률적 경사 하강법(AdalineSGD)

1. 아달린(ADAptive LInear NEuron, ADALINE)이란?

• 스탠퍼드의 Bernard Widrow가 개발한 초기 신경망 모델 중 하나인 아달린은 적응형 선형 뉴런이라고 불리며, 연속 함수(Continous Function)로 손실 함수를 정의하고 최소화한다.
• 아달린과 퍼셉트론의 차이는 가중치 업데이트를 위한 활성화 함수가 다르다.
  • A. 퍼셉트론: 실제값과 예측값의 활성 함수 출력 값이 다르면, 가중치 업데이트
  • B. 아달린: 실제값과 예측값이 다르면 경사 하강법으로 가중치 업데이트
• Adaline은 퍼셉트론과 달리 선형 활성화 함수라는 것을 통해, 가중치를 업데이트하는 과정이 들어 있다. 활성화 함수는 초기 퍼셉트론과 마찬가지로 계단 함수를 사용한다.

선형 활성화 함수: $ \phi(w^Tx)=w^Tx $

• 그러나, Adaline 역시 선형 분리가 가능한 논리 함수(AND, NAND, OR)는 실현할 수 있으나, 비선형 논리 함수(XOR)는 실현 불가능하다.
• 다층 퍼셉트론처럼 다량의 Adaline으로 네트워크를 구성하는 Madaline을 사용하여 이를 해결하긴 하였으나, 계단 함수를 사용하기 때문에 미분이 불가능해 학습이 불가능하다는 단점이 있어, 다층 퍼셉트론(Multilayer Perceptron)에 밀려 요즘은 쓰지 않는다.
  (선형 분리 문제를 해결한 다층 퍼셉트론이 나오기 전엔 Madaline이 최고의 신경망 모델이었다고 한다.)
  
  
• 아달린은 손실 함수로 앞서 학습하였던 제곱 오차합(SSE)을 사용한다.
  2021/01/29 - [Machine Learning/Basic] - 머신러닝-5.0. 손실함수(1)-제곱오차(SE)와 오차제곱합(SSE)

2. 구현해보자!

import numpy as np


class AdalineSGD(object):
    """ADAptive LInear NEuron 분류기
    
    매개변수
    -----------------------
    eta : float
    >>> 학습률 (0.0과 1.0 사이)
    n_iter : int
    >>> 훈련 데이터셋 반복 횟수
    shuffle : bool (default: True)
    >>> True로 설정하면 같은 반복이 되지 않도록 에포크마다 훈련 데이터를 섞는다.
    random_state : int
    >>> 가중치 무작위 초기화를 위한 난수 생성기 시드
    
    속성
    -----------------------
    w_ : 1d-array
    >>> 학습된 가중치
    cost_ : list
    >>> 모든 훈련 샘플에 대해 에포크마다 누적된 평균 비용 함수의 제곱합
    """
    def __init__(self, eta=0.01, n_iter=10, shuffle=True, random_state=None):
        self.eta = eta
        self.n_iter = n_iter
        self.w_initialized = False
        self.shuffle = shuffle
        self.random_state = random_state
        
    def fit(self, X, y):
        """훈련 데이터 학습
        
        매개변수
        -----------------------
        X : {array-like}, shape = [n_samples, n_features]
        >>> n_samples개의 샘플과 n_features개의 특성으로 이루어진 훈련 데이터
        y : array-like, shape = [n_samples]
        >>> 타깃 벡터
        
        
        반환값
        -----------------------
        self : object
        """
        self._initialize_weights(X.shape[1])
        self.cost_ = []
        for i in range(self.n_iter):
            if self.shuffle:
                X, y = self._shuffle(X, y)
            cost = []
            for xi, target in zip(X, y):
                cost.append(self._update_weights(xi, target))
            avg_cost = sum(cost) / len(y)
            self.cost_.append(avg_cost)
        return self
    
    def partial_fit(self, X, y):
        """가중치를 다시 초기화하지 않고 훈련 데이터를 학습"""
        if not self.w_initialized:
            self._initialize_weights(X.shape[1])
        if y.ravel().shape[0] > 1:
            for xi, target in zip(X, y):
                self._update_weights(xi, target)
        else:
            self._update_weights(X, y)
        return self
    
    def _shuffle(self, X, y):
        """훈련 데이터를 섞는다."""
        r = self.rgen.permutation(len(y))
        return X[r], y[r]
    
    def _initialize_weights(self, m):
        """랜덤한 작은 수로 가중치를 초기화합니다."""
        self.rgen = np.random.RandomState(self.random_state)
        self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=1+m)
        self.w_initialized = True
        
    def _update_weights(self, xi, target):
        """아달린 학습 규칙을 적용해 가중치 업데이트"""
        output = self.activation(self.net_input(xi))
        error = (target - output)
        self.w_[1:] += self.eta * xi.dot(error)
        self.w_[0] += self.eta * error
        cost = 0.5 * error**2
        return cost
    
    def net_input(self, X):
        """최종 입력 계산"""
        return np.dot(X, self.w_[1:]) + self.w_[0]
    
    def activation(self, X):
        """선형 활성화 계산"""
        return X
    
    def predict(self, X):
        """단위 계단 함수를 사용하여 클래스 레이블을 반환"""
        return np.where(self.activation(self.net_input(X)) >= 0.0, 1, -1)

• 위 코드는 아달린으로 SGD를 구현한 것이다.
• 아달린은 역전파를 통해 가중치 업데이트가 이루어지는 다층 퍼셉트론과 달리 층 자체에서 가중치를 업데이트하므로, 다층 퍼셉트론에 비해 개념이 단순하므로, 아달린을 사용했다.

# iris Data Import
from sklearn.datasets import load_iris
import pandas as pd

# Data Handling
X = pd.DataFrame(load_iris()["data"]).iloc[0:100, [0,2]].values
y = load_iris()["target"][0:100]
y = np.where(y==0, -1, 1)

# 변수 2개만 분석의 대상으로 사용할 것이므로, 이 2개만 표준화시키자.
X_std = np.copy(X)
X_std[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()
X_std[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()

• 학습에 사용될 데이터 셋은 붓꽃에 대한 정보가 담긴 iris로 데이터 분석을 해본 사람이라면 꽤 친숙한 데이터일 것이다.
• 해당 데이터에 대한 자세한 내용을 보고 싶다면, load_iris().keys()를 입력하여, dictionary에 있는 key들을 확인하고, 데이터를 살펴보도록 하자.

# 시각화 함수
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

def plot_decision_regions(X, y, classifier, resolution=0.02):
    
    # 마커와 컬러맵 설정
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])
    
    # 결정 경계를 그린다.
    x1_min, x1_max = X[:,0].min() - 1, X[:,0].max() + 1
    x2_min, x2_max = X[:,1].min() - 1, X[:,1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.xlim(xx2.min(), xx2.max())
    
    # 샘플의 산점도를 그린다.
    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0],
                    y=X[y == cl, 1],
                    alpha = 0.8,
                    c=colors[idx], 
                    marker=markers[idx], 
                    label=cl,
                    edgecolor='black')

• 위 학습 코드만으로는 그 결과를 인지하기 어려우므로, 그 과정을 시각화해주는 코드를 생성하였다.

ada = AdalineSGD(n_iter=15, eta=0.01, random_state=1)
ada.fit(X_std, y)

plot_decision_regions(X_std, y, classifier=ada)
plt.title('Adaline - Stochastic Gradient Descent')
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.legend(loc='upper left')
plt.show()
plt.plot(range(1, len(ada.cost_) + 1), ada.cost_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('Average Cost')
plt.show()

• 출력된 결과를 보면, 두 집단(-1, 1)을 선으로 잘 분리한 것을 볼 수 있다(아달린은 선형 분리에 특화되어 있다.)
• Epoch별 평균 비용(미니 배치 손실 함수의 평균값)이 빠르게 최솟값에 수렴하는 것을 볼 수 있다.

 이번 포스트는 어떤 주제에 대해 설명하기보다는 소개를 목적으로 글을 적었다 보니, 내용상 부족함이 많다. 위 코드는 꽤나 복잡하고, 이해하기가 힘든데, 개인적으로는 굳이 이해하려고 노력하지 않기를 바란다.

 머신러닝에서 굉장히 많이 사용되는 프레임워크인 텐서플로우의 케라스를 사용하여 코드를 작성하면, 코드가 보다 직관적이고, 내가 원하는 형태로 수정하기도 쉽기 때문에 굳이 위 코드를 이해하려 시간을 낭비할 필요는 없다.

 다만, 인공지능 역사에서 아달린이 차지했던 비중이 꽤 되고, 확률적 경사 하강법을 가장 손쉽게 실제 학습에 적용하여, 그 효과를 볼 수 있는 예시로는 위 코드가 가장 좋다고 생각되어 소개해보았다. 

 다음 포스트에서는 이전에 말했던 모멘텀(Momentum)에 대해 다뤄보도록 하겠다.

[ 참고 자료 ]

www.aistudy.com/neural/model_kim.htm#_bookmark_1a77358

blog.naver.com/samsjang/220959562205

 이전 포스트에서는 경사 하강법의 한계점에 대해 학습해보았다. 이번 포스트에서는 경사 하강법의 실행 과정을 살펴보고, 기본 사용 방법인 배치 경사 하강법(Batch Gradient Descent)이 어떤 단점을 가지고 있기에 최적화 기법의 기반이 되는 경사 하강법인 확률적 경사 하강법(Stochastic Gradient Descent, SGD)이 나오게 되었는지를 알아보고자 하였으나, 이 과정을 쉽게 이해하려면 먼저 학습이 일어나는 구조와 학습 단위에 대한 개념을 알아야 한다.

1. 학습의 구조

• 학습은 기본적으로 다음과 같은 구조로 움직인다.

1. 임의의 매개변수(가중치)를 정한다.
2. 선택된 매개변수로 손실 값을 구하고, 손실 함수의 기울기(Gradient)를 계산한다.
3. 계산된 기울기와 학습률(Learning Rate)을 이용해 다음 가중치의 위치로 이동하여, 파라미터를 업데이트한다.
   이때, 이동 거리는 경사 하강법 공식을 통해 구해진다.
   $$ \theta_{n+1} = \theta_n - \eta \bigtriangledown f(\theta_n) $$
4. 이동된 지점에서 손실 함수의 기울기(Gradient)를 계산하고, 3.과정을 다시 실시한다.
5. 손실함수의 기울기가 최솟값에 도달하면, 파라미터 업데이트를 멈춘다.

2. 학습 단위

• 그런데, 위 과정을 보다 보면 한 가지 의문이 든다.
• 바로, 기울기 계산이 엄청 많이 일어난다는 것인데, 우리가 기계를 학습시킬 때 사용하는 빅 데이터는 일반적으로 최소 1,000만 건 이상을 가리키며, 1억, 10억 건 이상 데이터도 심심치 않게 등장한다는 것이다.
• 이렇게 많은 데이터를 한 번에 모델에 태우게 된다면, 아무리 좋은 컴퓨터라도 버티지 못할 것이다.
• 한 번의 학습에 모든 학습 데이터셋을 사용한다면, 여러 문제를 일으킨다.

1. 데이터의 크기가 너무 큰 경우, 메모리가 너무 많이 필요해진다.
2. 학습 한 번에 계산돼야 할 파라미터(가중치) 수가 지나치게 많아지므로 계산 시간이 너무 오래 걸린다.

• 여기서 Epoch, Batch size, iteration라는 개념이 등장하게 된다.

3. Epoch(에포크)

• Epoch의 네이버 영어 사전 뜻은, "(중요한 사건·변화들이 일어난) 시대"라는 뜻이다.
• 훈련 데이터셋에 포함된 모든 데이터들이 한 번씩 모델을 통과한 횟수로, 모든 학습 데이터셋을 학습하는 횟수를 의미한다.
• 1 epoch는 전체 학습 데이터셋이 한 신경망에 적용되어 순전파와 역전파를 통해 신경망을 한 번 통과했다는 의미가 된다.
• 즉 epoch가 10회라면, 학습 데이터 셋 A를 10회 모델에 학습시켰다는 것이다.
• epoch를 높일수록, 다양한 무작위 가중치로 학습을 해보므로, 적합한 파라미터를 찾을 확률이 올라간다.
  (즉, 손실 값이 내려가게 된다.)
• 그러나, 지나치게 epoch를 높이게 되면, 그 학습 데이터셋에 과적합(Overfitting)되어 다른 데이터에 대해선 제대로 된 예측을 하지 못할 수 있다.

4. Batch size(배치 사이즈)

• Batch의 네이버 영어 사전 뜻은 "(일괄적으로 처리되는) 집단", "한 회분(한 번에 만들어 내는 음식 기계 등의 양)", "(일괄 처리를 위해) 함께 묶다"라는 의미가 있다.
• 즉, 연산 한 번에 들어가는 데이터의 크기를 가리킨다.
• 1 Batch size에 해당하는 데이터 셋을 mini Batch라고 한다.
• 1회 epoch 안에 m 개($m \geq 1$)의 mini Batch가 들어가게 되며, 만약, m = 1인 경우, 배치 학습법이라고 한다.
• 배치 사이즈가 너무 큰 경우 한 번에 처리해야 할 데이터의 양이 많아지므로, 학습 속도가 느려지고, 메모리 부족 문제가 발생할 위험이 있다.
• 반대로, 배치 사이즈가 너무 작은 경우 적은 데이터를 대상으로 가중치를 업데이트하고, 이 업데이트가 자주 발생하므로, 훈련이 불안정해진다.

5. Iteration(이터레이션)

• Iteration은 네이버 영어사전에서 "(계산·컴퓨터 처리 절차의) 반복"이라는 뜻이다.
• 전체 데이터를 모델에 한번 학습시키는데 필요한 배치의 수를 말한다.
• 즉, 1 epoch를 마치는데 필요한 파라미터 업데이트 횟수라 할 수 있다.
• 각 배치마다 파라미터 업데이트가 한 번씩 이루어지므로, Iteration은 "파라미터 업데이트 횟수 = 배치의 수"가 된다.

※ 참고

 만약, 데이터셋이 너무 거대해서 전체를 메모리에 올리는 것만으로도 부하가 걸릴 정도라면, 배치 학습 방법을 하되, 한 번에 학습할 학습 데이터 셋의 크기를 줄이고, for문으로 실제 batch를 만들고, pickle로 파일로 만들어 놓은 데이터 셋을 일부씩 불러와 batch에 학습시키고, 모든 데이터 셋을 불러와 한번 학습하는 것을 epoch로 잡는 방식도 있다.

 위 글만으로는 이해가 가지 않을 수 있으므로, 나중에 기회가 된다면 이를 자세히 다뤄보도록 하겠다.

 이번 포스트에서는 학습 단위로 사용되는 단어인 Epoch, Batch size, mini batch, Iteration에 대해 알아보았다. 다음 포스트에서는 배치 경사 하강법(BGD)과 확률적 경사 하강법(SGD)에 대해 학습해보도록 하겠다.

 지난 포스트에서는 기계학습에서 사용되는 최적화 알고리즘인 경사 하강법에 대하여 살펴보았다. 이번 포스트에서는 경사 하강법의 한계점에 대해 학습해보도록 하겠다.

경사 하강법의 한계점

• 앞서 손실함수를 기반으로 경사 하강법의 개형을 그려보았으나, 실제로는 저렇게 깔끔한 이차 함수 형태를 그리지 않는다.
• 퍼셉트론의 공식이 활성화 함수를 타게 되면, 손실 함수의 모습은 거시적인 관점에서 봤을 때는 최적해를 1개 가진 이차 함수의 형태를 그리긴 하지만, 그 모습이 울퉁불퉁해져 최적해에 수렴하기 어려워진다.
• 이번 포스트에서는 경사하강법의 한계점에 대해 하나하나 짚고 넘어가 보도록 하겠다.

1. 데이터가 많아질수록 계산량 증가

• 앞서, 경사하강법(Gradient Descent)은 신경망에서 출력되는 예측값(Predict)과 실제값(Label)의 차이인 손실 함수(Loss Function)의 값을 최소화하는 것이 목적이다.
• 그러나, 학습용 데이터 셋이 많아진다면, 당연히 계산량도 무지막지하게 많아지게 되는데, 그로 인해 학습 속도가 매우 느려지게 된다.
• 기계학습에는 아주 거대한 빅데이터가 사용되게 되는데, 이러한 퍼포먼스 문제는 결코 무시할 수 없는 문제다.

2. Local minimum(Optima) 문제

• 앞서 그린 대략적인 손실함수의 개형은 굉장히 매끈하였으나, 활성화 함수로 인해 그 모양이 울퉁불퉁해지게 되고, 그로 인해 최적해에 수렴하지 못할 수 있다.
• 아래 그래프를 보도록 하자.

• 실제 손실함수의 모양은 위 그래프보다 울퉁불퉁한 정도가 심하나 이해를 돕기 위해 일부분만 가져와봤다.
• 위 그래프에서 $\alpha$를 전역 최소해(Global minimum), $\beta$를 지역 최소해(Local minimum)라 한다.

• 경사 하강법의 목적은 손실 함수에서 랜덤 하게 선택한 가중치를 미분하여 나온 결과를 힌트로 해서, 최적해를 찾아가는 것인데, 위 그래프처럼 만약 랜덤 하게 선택된 가중치가 Local minimum 가까이에 있고, Local minimum에 수렴해버리면, 실제 목표인 Global  minimum을 찾지 못하는 문제가 발생할 수 있다.

• 만약, 학습률(Learning Rate)을 너무 크게 설정한다면, Global minimum에 가까운 곳에서 시작한다 할지라도, 구간을 뛰어넘어 Local minimum에서 수렴할 수도 있다.
• 그러나, 실제로는 모델의 학습이 지역 최소값(Local minimum)에 빠져, 최적의 가중치를 못 찾는 일이 발생할 위험은 그리 크지 않다.

• 학습 시 가중치를 초기화하여 반복하여 최적해를 찾아가므로, $\beta$에서 수렴하여 Loss값이 0 가까이 떨어지지 못한다할지라도, 시작 위치가 다른 가중치에서 전역 최소값(Global minimum)에 수렴하여 Loss값이 0에 수렴할 수 있다.
• 즉, 모든 초기화된 가중치가 지역 최솟값에 수렴할 수 있는 위치에 존재하지 않는다면, 지역 최솟값 문제는 발생하지 않는다. 그러므로, Local minimum 현상의 발생 위험은 그리 크지 않다고 할 수 있다.

3. Plateau 문제

• 1. Local minimum 문제의 예시에서는 손실함수의 모양이 전반적으로 곡선을 그렸으나, 손실 함수의 안에는 평탄한 영역이 존재하기도 한다.

• 위 그래프에서 Plateau(플래튜)라고 불리는 평탄한 영역에서는 학습 속도가 매우 느려지며, 느려지다 못해 정지해버릴 위험이 존재한다.
• 경사 하강법의 공식을 보면, "현 지점의 기울기 X 학습률"을 통해 다음 가중치를 결정하는데, 평탄한 영역의 기울기는 매우 낮기 때문에 이동거리가 갈수록 줄어들게 되고, 그로 인해 더 이상 학습이 일어나지 않는 가중치 소실(Gradient Vanishing) 현상이 발생할 수 있다.
• 이러한 Plateau 현상이 발생하면, 극솟값에 수렴하지 못해, 학습 시간이 매우 길어지고, 경사하강법의 랜덤 한 가중치에서 현재의 기울기를 힌트로 기울기가 0인 극솟값에 수렴시켜 최적해를 찾는다는 알고리즘이 제대로 작동하지 못하게 된다.

4. Zigzag 문제

• 지금까지 경사하강법을 설명할 때, 이해하기 용이하도록 가중치($w$)가 1개만 있는 2차원 그래프를 사용했으나, 실제론 가중치의 수가 매우 많다. 이번엔 가중치가 2개인($w_1, w_2$) 3차원 그래프를 등고선으로 그려보자.

• 위 그래프는 2개의 매개변수($w_1, w_2$)에 대한 손실 함수를 등고선으로 그린 것이다.
• 가중치의 스케일(크기)이 동일하다면, 최적해로 바로 찾아갈 수 있으나, 가중치는 모르는 임의의 값이므로, 스케일이 동일하리란 보장이 없다.
• 만약, 가중치 스케일이 다르다면, 다음과 같은 현상이 발생하게 된다.

• 두 매개변수 $w_1$의 스케일이 $w_2$보다 크다보니, 손실 함수는 $x$축 방향 가중치인 $w_1$의 변화에 매우 둔감하고, $y$축인 $w_2$의 변화에 매우 민감하다.
• 즉, $w_2$의 크기가 $w_2$에 비해 매우 작다보니, $w_2$가 조금만 변해도 손실 함수는 크게 변하게 되어, 두 매개변수의 변화에 따른 손실 함수 변화가 일정하지 않다.
• 위 경우는 매개변수가 2개밖에 존재하지 않았으나, 실제에서는 그 수가 수백만개에 달할 수 있을 정도로 많기 때문에 이러한 Zigzag 현상은 더욱 복잡해지며, 그로 인해 최적해를 찾아가기가 어려워지고, 학습 시간 역시 길어지게 된다.

 지금까지 경사하강법의 문제점에 대해 알아보았다. 머신러닝에서는 위 문제들을 해결하기 위해 경사 하강법을 효율적으로 사용하기 위한 최적화 기법(Optimizer)들이 매우 많다.

 예를 들어 다음 포스트에서 학습할 SGD나 가장 많이 사용되는 Adam, Momentum, Adagrad 등이 있는데, 각 최적화 알고리즘들은 데이터의 형태에 따라 그에 맞는 방법을 사용하길 바란다.

 다음 포스트에서는 최적화 기법의 가장 기초가 되는 확률적 경사 하강법(Stochastic Gradient Descent, SGD)에 대해 학습해보도록 하겠다.

[참조]

towardsdatascience.com/demystifying-optimizations-for-machine-learning-c6c6405d3eea

www.programmersought.com/article/59882346228/

nittaku.tistory.com/271?category=742607

 지금까지 가중치를 평가하는 방법인 손실함수(Loss Function)에 대해 학습해보았다. 그렇다면, 어떻게 손실함수를 기반으로 최적의 가중치를 찾아낼까?

 이번 포스트에서는 손실함수로부터 어떻게 경사 하강법이 나오게 되었는지를 이야기해보고, 경사하강법을 위주로 설명해보도록 하겠다.

손실함수와 경사하강법

1. 최적화(Optimizer)

• 최적화는 손실함수(Loss Function)의 결과값을 최소화하는 가중치를 찾아내는 것이 목적이다.
• 그렇다면, 손실함수의 개형은 어떻게 생겼을까?
• 예상한 값과 실제값의 차이인 제곱 오차(SE)를 가지고, 손실함수의 개형을 보도록 하자.

$$ SE = (y - \hat{y})^2 $$

• 이해하기 쉽도록 예측값을 변수(가중치)가 1개만 있는 퍼셉트론을 가져와보자
• 예측값은 선형이다(변수는 가중치인 $w$이며, $x$와 상관 없이, 가산성과 동차성이 성립한다.)

$$ \hat{y} = wx + b $$

• 제곱 오차의 $\hat{y}$에 예측값을 대입하고 식을 풀어보자.

$$ (y - \hat{y})^2 = (y - (wx + b))^2 = y^2 -2y(wx + b) + (wx + b)^2 = w^2x^2 + 2wxb + b^2 - 2wxy - 2yb + y^2 $$

• 위 식에서 변수는 $w$이므로, 위 함수는 1개의 최적해를 갖는 이차 함수 형태인 것을 알 수 있다.
• 그러므로, 손실함수의 개형은 다음과 같다.

2. 경사하강법(Gradient Descent)

• 경사 하강법은 1차 미분계수를 이용해 함수의 최소값을 찾아가는 방법으로, 함수 값이 낮아지는 방향으로 독립 변수 값을 변형시켜가면서 최종적으로 최소 함수 값을 갖도록 하는 독립 변수 값을 찾는 방법이다.
• 위에서 보듯, 손실함수의 개형은 1개의 최적해를 갖는 2차 함수의 형태이므로, 경사하강법을 사용하여, 최소 함수 값을 갖도록 하는 최적해(가중치)를 탐색해야한다.
• 경사 하강법은 임의의 가중치를 설정하여, 그 점에서의 기울기를 계산하고, 그 기울기를 힌트로 기울기가 0인 지점을 찾아간다.
• 손실 함수의 부호를 반전시켜, 최댓값을 찾는다면 경사 상승법(Gradient Ascent)이 되나, 동일한 것이므로, 굳이 사용하지 않는다.

• 위 그럼처럼 기울기는 손실함수에서 임의의 가중치에서 시작하며, 기울기가 음수인 경우에는 양의 방향으로 이동하고, 기울기가 양수인 경우에는 음의 방향으로 이동하여, 극솟값을 찾아간다.
• 여기서 움직이는 기울기(경사)는 가중치에 대하여 편미분 한 벡터이고, 이 가중치를 조금씩 움직인다.

3. 경사하강법 공식

• 경사 하강법을 공식으로 써보면 다음과 같다.

$$ x_{i+1} = x_i - \eta\bigtriangledown f(x_i) $$

• 여기서 $\eta$(eta, 에타)는 학습률(Learning Rate)이라 하며, 한 번의 학습에서 얼마나 이동할지를 정한다.
• $\bigtriangledown$는 벡터 미분 연산자로 델(del) 연산자라 하며 이 기호를 나블라(nabla) 기호라고 한다.
• 스칼라 함수 $f(x)$의 기울기는 $\bigtriangledown f$로 표현한다.
• 기울기는 $f$의 각 성분의 편미분으로 구성된 열 벡터로 정의하고, 아래와 같이 표시한다.

$$ \bigtriangledown f = (\frac{\partial f}{\partial x_1}, ..., \frac{\partial f}{\partial x_n}) $$

$$ \bigtriangledown f = (\frac{\partial f}{\partial x}, \frac{\partial f}{\partial y}) $$

• 예를 들어 함수 $f(x, y, z) = 2x + 3y^2 - sin(z)$의 기울기는 다음과 같다.

$$ \bigtriangledown f = (\frac{\partial f}{\partial x} + \frac{\partial f}{\partial y} + \frac{\partial f}{\partial z}) =(2, 6y, -coas(z)) $$

• ko.wikipedia.org/wiki/%EA%B8%B0%EC%9A%B8%EA%B8%B0_(%EB%B2%A1%ED%84%B0)

• 즉, 경사하강법 공식은 현재의 위치 $x_i$에 학습률 $\eta$에 그 위치에서의 기울기 $\bigtriangledown f(x_i)$만큼을 곱한 값을 뺀만큼 위치를 이동시켜 다음 위치 $x_{i+1}$로 이동한다는 소리다.
• 여기서 학습률과 기울기 곱($\eta\bigtriangledown f(x_i)$)을 빼는 이유는 현재의 기울기의 반대방향으로 이동하여, 극소값에 도달하기 위해서이다.

4. 학습률(Learning Rate, LR)

4.1. 경사 하강법 공식에서의 학습률의 영향

• 위 경사 하강법의 공식에서 중요한 것은 학습률(Laerning Rate)인데, 이 학습률에 따라 경사 하강법 시, 이동하는 수준이 달라지게 된다.
• 예를 들어, 기울기가 2.5이고 학습률이 0.01이라면, 경사하강법 알고리즘은 이전 지점으로부터 0.025 떨어진 지점을 다음 지점으로 결정한다.
• 즉, "이동 거리 = 학습률 X 기울기"로 움직인다. 이는 기울기가 낮다면 학습률이 높다할지라도 움직이는 거리가 줄어든다는 소리이고, 큰 고랑에 빠진다면, 거기서 나오지 못하고 수렴할 수 있다는 소리다.

4.2. 학습률이 낮은 경우

• 학습률이 낮다면, 이동하는 거리가 짧으며, 경사하강법 공식에 의해 이동할수록 기울기가 더욱 감소하므로, 짧은 이동 거리가 더 짧아진다.
• 그로 인해, 경사 하강법 알고리즘이 수렴하기 위해 반복해야하는 데이터 양이 많아지므로, 학습 시간이 늘어나게 된다.

4.3. 학습률이 높은 경우

• 학습률이 지나치게 큰 경우, 크게 이동하므로, 수렴이 빨리 발생해 학습 시간이 적게 걸린다.
• 그러나, 너무 크게 이동하므로, 전역 최솟값(Global minimum)이 있는 영역을 건너 뛰어 지역 최솟값에서 수렴할 수도 있다.
  (이 부분은 다음 포스트에서 세세하게 다루도록 하겠다.)

 지금까지 손실함수를 최소화하는 방법으로 어째서 경사하강법을 사용하는지와 경사하강법이 어떠한 구조로 움직이는지에 대하여 학습해보았다.

 다음 포스트에서는 경사하강법의 한계점에 대해 학습해보도록 하겠다.

 이전 포스트에서는 이진 분류에서 주로 사용되는 이진 교차 엔트로피 오차(Binary Cross Entropy Error, BCEE)에 대해 학습해보았다.

 이번 포스트에서는 다중 분류에서 사용되는 범주형 교차 엔트로피 오차(Categorical Cross Entropy error)에 대해 학습해보겠다.

범주형 교차 엔트로피 오차(Categorical Cross Entropy Error, CCEE)

• 범주형 교차 엔트로피 오차는 클래스가 3개 이상인 데이터를 대상으로 사용하는 손실함수다.
• CCEE는 주로, 소프트맥스(Softmax) 함수를 활성화 함수로 하여 사용된다.
• 출력층의 노드 수는 클래스의 수와 동일하다.
• 실제 데이터인 라벨은 원-핫 벡터로 구성되어 있다.
• 출력된 벡터는 각 클래스에 속할 확률이 나오며, 총합은 1이다.
• 처음 학습하였던 교차 엔트로피 오차를 N개의 데이터 셋에 대해 1개의 스칼라를 추출하는 방법이 CCEE다.

1.  범주형 교차 엔트로피 오차의 공식

• 범주형 교차 엔트로피 오차 공식은 다음과 같다.

$$ Loss = -\frac{1}{N}\sum_{j=1}^{N}\sum_{i=1}^{C}t_{ij}log(y_{ij}) $$

• 위 공식은 지금까지 잘 따라왔다면, 따로 풀이가 필요 없을 정도로 단순한 공식이다.
• 앞서 학습하였던 교차 엔트로피 오차 공식을 데이터셋의 수 $N$개만큼 합하여 평균을 낸 것이다.
• 이진형 교차 엔트로피 오차와의 차이는 출력층의 노드 수가 1개인지 $m$개$(m\geq3)$인지로, 출력층에서 데이터 하나당 클래스 수만큼의 원소를 가진 벡터가 나오므로, 각 벡터의 교차 엔트로피 오차들의 평균을 구하는 것이다.
• 바로 구현으로 넘어가 보자.

2. 구현해보자.

>>> import numpy as np

>>> def CCEE(predict, label):
    
>>>     delta = 1e-7
>>>     log_pred = np.log(predict + delta)
    
>>>     return -(np.sum(np.sum(label * log_pred, axis = 1)))/label.shape[0]

• np.sum() 함수를 보면 axis = 1이라는 것이 있다. 이는 0으로 설정하면, 열을 기준으로 해당 함수를 실행하고, 1으로 설정하면, 행을 기준으로 함수를 실행한다.
•  이 부분은 헷갈리기 좋으므로, 익숙해지기 전이라면, 작게 데이터를 만들어서 한번 보고 실행해보는 것을 추천한다.

>>> predict = np.array([[0.1, 0.7, 0.05, 0.05, 0.1],
>>>                     [0.05, 0.0, 0.85, 0.1, 0.0],
>>>                     [0.05, 0.8, 0.05, 0.1, 0.1],
>>>                     [0.75, 0.15, 0.05, 0.05, 0.0],
>>>                     [0.0, 0.1, 0.1, 0.0, 0.8]])
                    
>>> label = np.array([[0, 1, 0, 0, 0],
>>>                   [0, 0, 1, 0, 0],
>>>                   [0, 1, 0, 0, 0],
>>>                   [1, 0, 0, 0, 0],
>>>                   [0, 0, 0, 0, 1]])
>>> CCEE(predict, label)
0.25063248093584295

• 범주형 교차 엔트로피 오차의 구현은 아주 단순하다. 
• 위에서 보듯, 교차 엔트로피는 각 벡터에 대해 일어나고, 교차 엔트로피 오차의 평균을 만들면 된다.
• 실제 데이터와 예측 데이터를 아주 가깝게 해 보자.

>>> predict = np.array([[0.1, 0.85, 0.0, 0.05, 0.0],
>>>                     [0.05, 0.0, 0.9, 0.05, 0.0],
>>>                     [0.0, 0.95, 0.0, 0.1, 0.04],
>>>                     [0.9, 0.0, 0.05, 0.05, 0.0],
>>>                     [0.0, 0.1, 0.0, 0.0, 0.9]])

>>> label = np.array([[0, 1, 0, 0, 0],
>>>                   [0, 0, 1, 0, 0],
>>>                   [0, 1, 0, 0, 0],
>>>                   [1, 0, 0, 0, 0],
>>>                   [0, 0, 0, 0, 1]])

>>> CCEE(predict, label)
0.10597864292305711

• 범주형 교차 엔트로피 오차 역시 편차가 줄어들수록 출력 값이 0에 가까워지는 것을 볼 수 있다.
• 반대로 실제 데이터와 예측 데이터의 차이를 크게 만들어보자.

>>> predict = np.array([[0.1, 0.6, 0.2, 0.05, 0.05],
>>>                     [0.1, 0.2, 0.5, 0.2, 0.0],
>>>                     [0.1, 0.6, 0.0, 0.1, 0.2],
>>>                     [0.4, 0.0, 0.1, 0.3, 0.2],
>>>                     [0.05, 0.1, 0.05, 0.2, 0.6]])

>>> label = np.array([[0, 1, 0, 0, 0],
>>>                   [0, 0, 1, 0, 0],
>>>                   [0, 1, 0, 0, 0],
>>>                   [1, 0, 0, 0, 0],
>>>                   [0, 0, 0, 0, 1]])

>>> CCEE(predict, label)
0.6283827667464331

• 앞서 교차 엔트로피 오차에서도 이야기하였지만, 원-핫 벡터에서 1에 해당하는 위치의 데이터만 가지고 연산을 한다.
• 각 행의 총합은 1이다.

 지금까지 가장 기본이 되는 손실함수인 제곱오차(SE)에서 파생된 손실함수인 오차제곱합(SSE), 평균제곱오차(MSE), 평균제곱근오차(RMSE), 교차 엔트로피 오차에서 파생된 이진 교차 엔트로피 오차(BCEE), 범주형 교차 엔트로피 오차(CCEE)에 대하여 학습해보았다.

 이 밖에도 Huber나 Sparse Categorical Crossentropy 등이 여러 손실함수가 있으나, 이들까지 하나하나 다루다간 끝이 나지 않을지도 모른다. 이밖에 다른 손실함수에 대해 학습해보고자 한다면, TensorFlow의 keras에서 손실함수 API를 정리해놓은 아래 홈페이지를 참고하기를 바란다.

www.tensorflow.org/api_docs/python/tf/keras/losses

 다음 포스트에서는 신경망의 핵심 알고리즘인 경사법에 대해 학습해보도록 하자.

 이전 포스트에서는 범주형 데이터를 분류하는데 주로 사용되는 손실함수인 교차 엔트로피 오차와 그 근간이 되는 정보 이론에서의 엔트로피가 무엇인지를 알아보았다.

 이번 포스트에서는 교차 엔트로피 오차 중에서도 이진 분류를 할 때, 주로 사용되는 이진 교차 엔트로피 오차에 대해 학습해보도록 하겠다.

이진 교차 엔트로피 오차(Binary Cross Entropy Error)

• 교차 엔트로피 오차는 나누고자 하는 분류가 몇 개인지에 따라 사용하는 손실함수가 바뀌게 된다.
• 이는 사용되는 활성화 함수가 다르기 때문으로, 범주가 2개인 데이터는 시그모이드(Sigmoid) 함수를 사용하여 0~1 사이의 값을 반환하거나, 하이퍼볼릭 탄젠트(Hyperbolic Tangent) 함수를 사용하여 -1~1 사이의 값을 반환한다. 이 두 활성화 함수 모두 출력값이 단 하나의 스칼라 값이다.
• 반면에 범주가 3개 이상이라면, 총 합 1에 각 클래스에 속할 확률을 클래스의 수만큼 반환하는 소프트맥스(Softmax) 함수를 사용하여 클래스 수만큼의 원소가 들어있는 배열을 반환하므로, 이에 대한 평가 방법이 달라져야 한다.
• 이진 교차 엔트로피 오차는 로그 손실(Log loss) 또는 로지스틱 손실(Logistic loss)라 불리며, 주로 로지스틱 회귀의 비용 함수로 사용된다.

1. 이진 교차 엔트로피 오차의 공식

• 이진 교차 엔트로피 오차의 공식은 다음과 같다.

$$ Loss = -\frac{1}{N}\sum_{i=1}^{N}(y_i*ln\hat{y_i} + (1-y_i)*ln(1-\hat{y_i})) $$

• $\hat{y_i}$는 예측값이며, $y_i$는 실제값이다.
• 얼핏 보면, 꽤 어려워보이는데 앞서 우리가 학습했던 내용을 기반으로 보면 상당히 단순한 공식이다.
• 먼저 앞서 학습헀던 공식들을 조금 더 이해해보자.
• 엔트로피 공식은 다음과 같다.

$$H(X) = - \sum_{x}P(x)lnP(x) $$

• 교차 엔트로피 공식은 다음과 같다. 

$$H(P, Q) = - \sum_{x}P(x)lnQ(x) $$

• 위 두 공식에서 엔트로피 공식과 교차 엔트로피 공식의 차이는 실제값($P(x)$)과 타깃이 되는 예측값($Q(x)$)의 정보량 비율 합으로 구해지는 것을 알 수 있다.
• 여기서, 교차 엔트로피 오차는 분류할 클래스의 수가 $N>2$인 정수이므로, 클래스별 확률이 다 달랐으나, 이진 교차 엔트로피 오차는 클래스가 "y=0"와 "y=1" 단 두 가지만 존재하는 것을 알 수 있다.

$$ p = [y, 1-y] $$

$$ q = [\hat{y}, 1-\hat{y}] $$

• 그렇다면, $y=0$의 교차 엔트로피 공식을 만들어보자.

$$ H(y)= -\sum_{i=1}^{N}(y_i*ln\hat{y_i}) $$

• $y=1$의 교차 엔트로피 공식을 만들어보자.

$$ H(y-1)= -\sum_{i=1}^{N}((1-y_i)*ln(1-\hat{y_i})) $$

• 밑과 위가 같은 시그마끼리는 서로 합칠 수 있다.

$$ H(y) + H(y-1)= -\sum_{i=1}^{N}(y_i*ln\hat{y_i} + (1-y_i)*ln(1-\hat{y_i})) $$

• 여기서 $N$개의 학습 데이터 전체에 대한 교차 엔트로피를 구해주는 것이므로, 평균으로 만들어 값을 줄여주자!

$$ Loss = -\frac{1}{N}\sum_{i=1}^{N}(y_i*ln\hat{y_i} + (1-y_i)*ln(1-\hat{y_i})) $$

• 앞서, 오차제곱합(SSE)와 평균제곱오차(MSE)에 대해 보았을 텐데, 합은 데이터의 수가 많아질수록 증가하므로, 데이터의 수로 나눠 평균으로 만들어야 이를 보정해줄 수 있다.
• 여기서 데이터의 수는 입력 값의 벡터 크기가 아니라, Input되는 데이터의 수를 말한다.
• 이진 교차 엔트로피 오차는 출력층의 노드 수를 하나로 하여 출력값을 하나로 받으므로, 실제값(Label)과 예측값(predict) 모두 하나의 스칼라 값이다.
• 왜 교차 엔트로피 오차(CEE)에서는 왜 N으로 나눠주지 않았는지 의문이 들 수 있는데, 그 이유는 교차 엔트로피 오차는 하나의 데이터에 대해서만 실시한 것이기 때문이다.
• 교차 엔트로피 오차(CEE)를 N개의 데이터에 대해 실시하면 범주형 교차 엔트로피 오차(Categorical Cross Entropy Error)가 된다.

2. 구현해보자!

• 이진형 교차 엔트로피 에러(BCEE)는 앞서 학습 했던, 교차 엔트로피 에러와 꽤 유사하다.

>>> import numpy as np

>>> def BCEE(predict, label):
    
>>>     delta = 1e-7
>>>     pred_diff = 1 - predict
>>>     label_diff = 1 - label
>>>     result = -(np.sum(label*np.log(predict+delta)+label_diff*np.log(pred_diff+delta)))/len(label)
    
>>>     return result

>>> predict = np.array([0.8, 0.1, 0.05, 0.9, 0.05])
>>> label = np.array([1, 0, 0, 1, 0])
>>> BCEE(predict, label)
0.10729012273129139

• 위 데이터를 보면 총 5개의 데이터 셋에 대한 이진 분류 결과를 보았다.
• 이번에는 예측값과 실제 데이터를 더 유사하게 하여 결과를 내보자.

>>> predict = np.array([0.95, 0.05, 0.01, 0.95, 0.01])
>>> label = np.array([1, 0, 0, 1, 0])
>>> BCEE(predict, label)
0.03479600741200121

• 보다 0에 가까워진 것을 알 수 있다.
• 이번에는 좀 멀게 만들어보자.

>>> predict = np.array([0.30, 0.40, 0.20, 0.65, 0.2])
>>> label = np.array([1, 0, 0, 1, 0])
>>> BCEE(predict, label)

 지금까지 이진 교차 엔트로피 오차(Binary Cross Entropy Error, BCEE)에 대해 학습해보았다. BCEE는 앞서 봤던 CEE를 단순하게 "y=0"일 사건과 "y=1"일 사건에 대한 교차 엔트로피 오차 합의 평균을 낸 것으로, 큰 차이가 없다는 것을 알 수 있다.

 다음 포스트에서는 이진 교차 엔트로피 오차에 대응하는 다중 분류에 사용되는 범주형 교차 엔트로피 오차(Categorical Cross Entropy Error)에 대해 학습해보도록 하겠다.