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

 이전 포스트에서는 범주형 데이터들을 원-핫 벡터로 바꿔서 성능 향상을 이뤄봤다. 그러나 Accuracy 0.78 > 0.79667이라는 기대에 미치지 못하는 성능 향상이 일어났다.

 이번에는 하이퍼 파라미터 튜닝을 하여, 성능을 보다 올려보도록 하겠다.

하이퍼 파라미터 튜닝

• 하이퍼 파라미터 튜닝이 무엇인지 이전 포스트(참고)에서 살짝 다뤄보았다.
• 이전 포스트에서 원-핫 벡터를 사용한, 데이터 셋을 만들었으나, 그 성능이 생각보다 크지 않았다.
• 데이터 셋의 상태는 실제로 더 좋아졌으나, 적절한 하이퍼 파라미터나, 적합한 모델을 만들지 못해서 발생한 문제일 수 있다.
• 이번엔 하이퍼 파라미터를 하나하나 잡아보도록 하자.

0. 학습 이전까지 코드 정리

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

# 필요한 Data를 모두 가져온다.
def import_Data(file_path):

    result = dict()
    for file in os.listdir(file_path):

        file_name = file[:-4]
        result[file_name] = pd.read_csv(file_path + "/" + file)

    return result


# Rawdata 생성
def make_Rawdata(dict_data):

    dict_key = list(dict_data.keys())
    test_Dataset = pd.merge(dict_data["gender_submission"], dict_data["test"], how='outer', on="PassengerId")
    Rawdata = pd.concat([dict_data["train"], test_Dataset])
    Rawdata.reset_index(drop=True, inplace=True)
    
    return Rawdata


# 불필요한 컬럼 제거
def remove_columns(DF, remove_list):
    
    # 원본 정보 유지를 위해 copy하여, 원본 Data와의 종속성을 끊었다.
    result = copy(Rawdata)

    # PassengerId를 Index로 하자.
    result.set_index("PassengerId", inplace = True)

    # 불필요한 column 제거
    for column in remove_list:

        del(result[column])
        
    return result


# 결측값 처리
def missing_value(DF):

    # Cabin 변수를 제거하자
    del(DF["Cabin"])
    
    # 결측값이 있는 모든 행은 제거한다.
    DF.dropna(inplace = True)
    
    
# 원-핫 벡터
def one_hot_Encoding(data, column):

    # 한 변수 내 빈도
    freq = data[column].value_counts()

    # 빈도가 큰 순서로 용어 사전 생성
    vocabulary = freq.sort_values(ascending = False).index

    # DataFrame에 용어 사전 크기의 column 생성
    for word in vocabulary:

        new_column = column + "_" + str(word)
        data[new_column] = 0

    # 생성된 column에 해당하는 row에 1을 넣음
    for word in vocabulary:

        target_index = data[data[column] == word].index
        new_column = column + "_" + str(word)
        data.loc[target_index, new_column] = 1

    # 기존 컬럼 제거
    del(data[column])
    

# 스케일 조정
def scale_adjust(X_test, X_train, C_number, key="min_max"):
    
    if key == "min_max":
        
        min_key = np.min(X_train[:,C_number])
        max_key = np.max(X_train[:,C_number])
        
        X_train[:,C_number] = (X_train[:,C_number] - min_key)/(max_key - min_key)
        X_test[:,C_number] = (X_test[:,C_number] - min_key)/(max_key - min_key)
        
    elif key =="norm":
        
        mean_key = np.mean(X_train[:,C_number])
        std_key = np.std(X_train[:,C_number])
        
        X_train[:,C_number] = (X_train[:,C_number] - mean_key)/std_key
        X_test[:,C_number] = (X_test[:,C_number] - mean_key)/std_key
        
    return X_test, X_train

# Data Handling
############ Global Parameter ############
file_path = "./Dataset"
remove_list = ["Name", "Ticket"]
##########################################


# 0. Rawdata 생성
Rawdata_dict = import_Data(file_path)
Rawdata = make_Rawdata(Rawdata_dict)


# 1. 필요 없는 column 제거
DF_Hand = remove_columns(Rawdata, remove_list)


# 2. 결측값 처리
missing_value(DF_Hand)


# 3. One-Hot encoding
one_hot_Encoding(DF_Hand, 'Pclass')
one_hot_Encoding(DF_Hand, 'Sex')
one_hot_Encoding(DF_Hand, 'Embarked')


# 4. 데이터 쪼개기
# Label 생성
y_test, y_train = DF_Hand["Survived"][:300].to_numpy(), DF_Hand["Survived"][300:].to_numpy()


# 5. Dataset 생성
del(DF_Hand["Survived"])
X_test, X_train = DF_Hand[:300].values, DF_Hand[300:].values


# 6. 특성 스케일 조정
X_test, X_train = scale_adjust(X_test, X_train, 0, key="min_max")
X_test, X_train = scale_adjust(X_test, X_train, 3, key="min_max")

# 모델 생성
model = keras.Sequential()
model.add(Dense(128, activation = "relu"))
model.add(Dense(64, activation = "relu"))
model.add(Dense(32, activation = "relu"))
model.add(Dense(16, activation = "relu"))
model.add(Dense(1, activation = "sigmoid"))

# 모델 Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt,
              loss = "binary_crossentropy",
              metrics=["binary_accuracy"])

1. 적절한 Epochs 잡기

• 혹시 과적합(Overfitting)이 발생한 것일지도 모르니 손실 값의 추이를 보자.
• 모델은 적합한 epochs를 넘어 학습하게 된다면, train Dataset에 지나치게 맞춰져서, Test set을 제대로 분류하지 못하는 문제가 발생할 수 있다.

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

Epoch 95/500
24/24 [==============================] - 0s 997us/step - loss: 0.2396 - binary_accuracy: 0.8955
Epoch 96/500
24/24 [==============================] - 0s 1ms/step - loss: 0.2528 - binary_accuracy: 0.8892
Epoch 97/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1841 - binary_accuracy: 0.9220
Epoch 98/500
24/24 [==============================] - 0s 997us/step - loss: 0.2407 - binary_accuracy: 0.8902
Epoch 99/500
24/24 [==============================] - 0s 911us/step - loss: 0.2251 - binary_accuracy: 0.8925
Epoch 100/500
24/24 [==============================] - 0s 1ms/step - loss: 0.2491 - binary_accuracy: 0.8909

...

Epoch 195/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1727 - binary_accuracy: 0.9196
Epoch 196/500
24/24 [==============================] - 0s 997us/step - loss: 0.1872 - binary_accuracy: 0.9266
Epoch 197/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1782 - binary_accuracy: 0.9232
Epoch 198/500
24/24 [==============================] - 0s 954us/step - loss: 0.2125 - binary_accuracy: 0.9080
Epoch 199/500
24/24 [==============================] - 0s 867us/step - loss: 0.1910 - binary_accuracy: 0.9235
Epoch 200/500
24/24 [==============================] - 0s 954us/step - loss: 0.2054 - binary_accuracy: 0.9145

...

Epoch 296/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1784 - binary_accuracy: 0.9128
Epoch 297/500
24/24 [==============================] - 0s 1ms/step - loss: 0.2052 - binary_accuracy: 0.9170
Epoch 298/500
24/24 [==============================] - 0s 997us/step - loss: 0.2241 - binary_accuracy: 0.9151
Epoch 299/500
24/24 [==============================] - 0s 996us/step - loss: 0.2345 - binary_accuracy: 0.9055
Epoch 300/500
24/24 [==============================] - 0s 1ms/step - loss: 0.2218 - binary_accuracy: 0.9008

...

Epoch 395/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1688 - binary_accuracy: 0.9271
Epoch 396/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1840 - binary_accuracy: 0.9213
Epoch 397/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1711 - binary_accuracy: 0.9204
Epoch 398/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1995 - binary_accuracy: 0.9167
Epoch 399/500
24/24 [==============================] - 0s 1ms/step - loss: 0.2236 - binary_accuracy: 0.9166
Epoch 400/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1880 - binary_accuracy: 0.9280

...

Epoch 495/500
24/24 [==============================] - 0s 954us/step - loss: 0.1608 - binary_accuracy: 0.9270
Epoch 496/500
24/24 [==============================] - 0s 997us/step - loss: 0.1601 - binary_accuracy: 0.9334
Epoch 497/500
24/24 [==============================] - 0s 954us/step - loss: 0.1428 - binary_accuracy: 0.9540
Epoch 498/500
24/24 [==============================] - 0s 998us/step - loss: 0.1522 - binary_accuracy: 0.9360
Epoch 499/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1431 - binary_accuracy: 0.9410
Epoch 500/500
24/24 [==============================] - 0s 911us/step - loss: 0.1581 - binary_accuracy: 0.9440
<tensorflow.python.keras.callbacks.History at 0x1e9a8427790>

• 손실 값의 추이를 보니, 거의 차이가 없는 것을 볼 수 있다.
• 과적합이 의심되므로, epochs를 100으로 줄여서 다시 학습해보자.

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

Epoch 1/100
24/24 [==============================] - 1s 1ms/step - loss: 0.5505 - binary_accuracy: 0.7738
Epoch 2/100
24/24 [==============================] - 0s 1ms/step - loss: 0.3769 - binary_accuracy: 0.8455
Epoch 3/100
24/24 [==============================] - 0s 2ms/step - loss: 0.3293 - binary_accuracy: 0.8878
Epoch 4/100
24/24 [==============================] - 0s 2ms/step - loss: 0.3400 - binary_accuracy: 0.8485
Epoch 5/100
24/24 [==============================] - 0s 1ms/step - loss: 0.3340 - binary_accuracy: 0.8688

...

Epoch 96/100
24/24 [==============================] - 0s 963us/step - loss: 0.2319 - binary_accuracy: 0.9013
Epoch 97/100
24/24 [==============================] - 0s 1ms/step - loss: 0.2237 - binary_accuracy: 0.9102
Epoch 98/100
24/24 [==============================] - 0s 953us/step - loss: 0.2326 - binary_accuracy: 0.9151
Epoch 99/100
24/24 [==============================] - 0s 997us/step - loss: 0.2412 - binary_accuracy: 0.8963
Epoch 100/100
24/24 [==============================] - 0s 1ms/step - loss: 0.2346 - binary_accuracy: 0.9002
<tensorflow.python.keras.callbacks.History at 0x119d9265790>

>>> pred = model.predict(X_test).reshape(X_test.shape[0])
>>> pred = np.where(pred > 0.5, 1, 0)
>>> accuracy = 1 - (np.where((pred - y_test) == 0, 0, 1).sum()/len(y_test))
>>> print("Accuracy:", accuracy)

Accuracy: 0.81

• epochs만 100으로 줄였을 뿐인데, Accuracy가 0.79667에서 0.81로 상승하였다.

2. 적절한 모델 만들기

• 연구자의 감에 의존하는 부분이라고도 할 수 있으나, 적절한 모델 작성은 전혀 다른 결과를 가져온다.
• 이번엔 Dropout과 Batchnormalization을 추가하여 모델을 학습시켜보자.
• 위 두 내용은 꽤 심도 깊은 내용이므로 추후 자세히 설명하겠으나, 이번엔 아주 간략하게 설명하고 넘어가 보겠다.

Dropout

• Dropout은 Overfitting, model combination 문제를 해결하기 위해 등장한 개념으로, 신경망의 뉴런을 랜덤 하게 부분적으로 생략시킨다.
• 간단하게 말하자면, 신경망을 망각시킨다고 생각하는 게 좋다.

Bachnormalization:

• 배치 정규화라 불린다.
• 활성화 함수의 활성화 값이나 출력 값을 정규분포로 만들어줘, Noise를 추가하는 개념으로, 학습을 할 때마다 활성화 값이나 출력 값을 정규화하므로, 초기화(가중치 초깃값) 문제의 영향을 덜 받게 해 준다.
• 학습률(Learning Rate)을 높게 설정할 수 있으므로, 학습 속도가 개선된다.
• Overfitting 위험을 줄일 수 있다.
• 가중치 소실(Gradient Vanishing) 문제를 해결해준다.

# module 추가 Import
from tensorflow.keras.layers import (Dense, Dropout, BatchNormalization)

# 모델 생성
model = keras.Sequential()
model.add(BatchNormalization())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.10))
model.add(Dense(64, activation = 'relu'))
model.add(Dropout(0.10))
model.add(Dense(32, activation = 'relu'))
model.add(Dropout(0.10))
model.add(Dense(16, activation = 'relu'))
# 마지막 Dropout은 좀 크게 주자
model.add(Dropout(0.50))
model.add(Dense(1, activation = 'sigmoid'))

# 모델 Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt,
              loss = "binary_crossentropy",
              metrics=["binary_accuracy"])

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

Epoch 1/100
24/24 [==============================] - 1s 2ms/step - loss: 0.6060 - binary_accuracy: 0.6829
Epoch 2/100
24/24 [==============================] - 0s 2ms/step - loss: 0.4085 - binary_accuracy: 0.8484
Epoch 3/100
24/24 [==============================] - 0s 2ms/step - loss: 0.3800 - binary_accuracy: 0.8719
Epoch 4/100
24/24 [==============================] - 0s 2ms/step - loss: 0.3713 - binary_accuracy: 0.8580
Epoch 5/100
24/24 [==============================] - 0s 2ms/step - loss: 0.3626 - binary_accuracy: 0.8666
Epoch 6/100

...

Epoch 96/100
24/24 [==============================] - 0s 1ms/step - loss: 0.3144 - binary_accuracy: 0.8592
Epoch 97/100
24/24 [==============================] - 0s 2ms/step - loss: 0.3060 - binary_accuracy: 0.8716
Epoch 98/100
24/24 [==============================] - 0s 2ms/step - loss: 0.2887 - binary_accuracy: 0.8794
Epoch 99/100
24/24 [==============================] - 0s 1ms/step - loss: 0.2879 - binary_accuracy: 0.8695
Epoch 100/100
24/24 [==============================] - 0s 2ms/step - loss: 0.2805 - binary_accuracy: 0.8969
<tensorflow.python.keras.callbacks.History at 0x1fa4c5b0220>

>>> pred = model.predict(X_test).reshape(X_test.shape[0])
>>> pred = np.where(pred > 0.5, 1, 0)
>>> accuracy = 1 - (np.where((pred - y_test) == 0, 0, 1).sum()/len(y_test))
>>> print("Accuracy:", accuracy)

Accuracy: 0.8200000000000001

• 성능이 소폭 상승하긴 하였으나, 손실 값이 이전보다 떨어진 폭이 작다.
• 혹시나, 손실 값을 더 떨어뜨릴 수 있을지도 모르니, epochs를 올려보자.
• Dropout과 Batchnormalization 둘 모두 overfitting 문제를 해결해주므로, 현재 필요한 epochs보다 낮은 상태일 가능성이 있다.

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

Epoch 1/200
24/24 [==============================] - 1s 2ms/step - loss: 0.6264 - binary_accuracy: 0.6648
Epoch 2/200
24/24 [==============================] - 0s 2ms/step - loss: 0.4572 - binary_accuracy: 0.8413
Epoch 3/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3927 - binary_accuracy: 0.8649
Epoch 4/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3488 - binary_accuracy: 0.8736
Epoch 5/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3500 - binary_accuracy: 0.8776

...

Epoch 196/200
24/24 [==============================] - 0s 2ms/step - loss: 0.2589 - binary_accuracy: 0.8917
Epoch 197/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3108 - binary_accuracy: 0.8813
Epoch 198/200
24/24 [==============================] - 0s 2ms/step - loss: 0.2486 - binary_accuracy: 0.9010
Epoch 199/200
24/24 [==============================] - 0s 1ms/step - loss: 0.2808 - binary_accuracy: 0.9001
Epoch 200/200
24/24 [==============================] - 0s 1ms/step - loss: 0.2638 - binary_accuracy: 0.9069
<tensorflow.python.keras.callbacks.History at 0x1b772b801f0>

>>> pred = model.predict(X_test).reshape(X_test.shape[0])
>>> pred = np.where(pred > 0.5, 1, 0)
>>> accuracy = 1 - (np.where((pred - y_test) == 0, 0, 1).sum()/len(y_test))
>>> print("Accuracy:", accuracy)
Accuracy: 0.8266666666666667

• 정확도가 0.82667로 소폭 성능이 상승한 것을 볼 수 있다.

3. 최종 코드

• 결측 값이 가장 많은 연령에 대하여, 평균 대체, 중윗값 대체, 사용하지 않음(Default)이 가능하게 코드를 수정하였다.
• 변수 SibSp와 Parch는 등간 척도이므로, 연속형 척도이나, 표준화를 하지 않았다.
• 그 값의 편차가 매우 작으므로, 미치는 영향은 작다고 판단되지만, 통일성을 위해 스케일 조정을 해주었다.

# Inport Module
import pandas as pd
import numpy as np
import os
from tensorflow.keras.layers import (Dense, Dropout, BatchNormalization)
from tensorflow import keras
from copy import copy




###################################### Function ######################################
# 필요한 Data를 모두 가져온다.
def import_Data(file_path):

    result = dict()
    for file in os.listdir(file_path):

        file_name = file[:-4]
        result[file_name] = pd.read_csv(file_path + "/" + file)

    return result


# Rawdata 생성
def make_Rawdata(dict_data):

    dict_key = list(dict_data.keys())
    test_Dataset = pd.merge(dict_data["gender_submission"], dict_data["test"], how='outer', on="PassengerId")
    Rawdata = pd.concat([dict_data["train"], test_Dataset])
    Rawdata.reset_index(drop=True, inplace=True)
    
    return Rawdata


# 불필요한 컬럼 제거
def remove_columns(DF, remove_list):
    
    # 원본 정보 유지를 위해 copy하여, 원본 Data와의 종속성을 끊었다.
    result = copy(Rawdata)

    # PassengerId를 Index로 하자.
    result.set_index("PassengerId", inplace = True)

    # 불필요한 column 제거
    for column in remove_list:

        del(result[column])
        
    return result


# 결측값 처리
def missing_value(DF, key=None):

    # Cabin 변수를 제거하자
    del(DF["Cabin"])
    
    if key == "mean":
        DF["Age"] = DF["Age"].fillna(np.mean(DF["Age"]))
        
    elif key == "median":
        DF["Age"] = DF["Age"].fillna(np.median((DF["Age"].dropna())))
    
    # 결측값이 있는 모든 행은 제거한다.
    DF.dropna(inplace = True)
    
    
# 원-핫 벡터
def one_hot_Encoding(data, column):

    # 한 변수 내 빈도
    freq = data[column].value_counts()

    # 빈도가 큰 순서로 용어 사전 생성
    vocabulary = freq.sort_values(ascending = False).index

    # DataFrame에 용어 사전 크기의 column 생성
    for word in vocabulary:

        new_column = column + "_" + str(word)
        data[new_column] = 0

    # 생성된 column에 해당하는 row에 1을 넣음
    for word in vocabulary:

        target_index = data[data[column] == word].index
        new_column = column + "_" + str(word)
        data.loc[target_index, new_column] = 1

    # 기존 컬럼 제거
    del(data[column])
    

# 스케일 조정
def scale_adjust(X_test, X_train, C_number, key="min_max"):
    
    if key == "min_max":
        
        min_key = np.min(X_train[:,C_number])
        max_key = np.max(X_train[:,C_number])
        
        X_train[:,C_number] = (X_train[:,C_number] - min_key)/(max_key - min_key)
        X_test[:,C_number] = (X_test[:,C_number] - min_key)/(max_key - min_key)
        
    elif key =="norm":
        
        mean_key = np.mean(X_train[:,C_number])
        std_key = np.std(X_train[:,C_number])
        
        X_train[:,C_number] = (X_train[:,C_number] - mean_key)/std_key
        X_test[:,C_number] = (X_test[:,C_number] - mean_key)/std_key
        
    return X_test, X_train
######################################################################################






################################## Global Variable ###################################
file_path = "./Dataset"
remove_list = ["Name", "Ticket"]
######################################################################################
# Data Handling
# 0. Rawdata 생성
Rawdata_dict = import_Data(file_path)
Rawdata = make_Rawdata(Rawdata_dict)


# 1. 필요 없는 column 제거
DF_Hand = remove_columns(Rawdata, remove_list)


# 2. 결측값 처리
missing_value(DF_Hand)


# 3. One-Hot encoding
one_hot_Encoding(DF_Hand, 'Pclass')
one_hot_Encoding(DF_Hand, 'Sex')
one_hot_Encoding(DF_Hand, 'Embarked')


# 4. 데이터 쪼개기
# Label 생성
y_test, y_train = DF_Hand["Survived"][:300].to_numpy(), DF_Hand["Survived"][300:].to_numpy()


# 5. Dataset 생성
del(DF_Hand["Survived"])
X_test, X_train = DF_Hand[:300].values, DF_Hand[300:].values


# 6. 특성 스케일 조정
X_test, X_train = scale_adjust(X_test, X_train, 0, key="min_max")
X_test, X_train = scale_adjust(X_test, X_train, 1, key="min_max")
X_test, X_train = scale_adjust(X_test, X_train, 2, key="min_max")
X_test, X_train = scale_adjust(X_test, X_train, 3, key="min_max")
######################################################################################






######################################## Model #######################################
# 모델 생성
model = keras.Sequential()
model.add(BatchNormalization())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.10))
model.add(Dense(64, activation = 'relu'))
model.add(Dropout(0.10))
model.add(Dense(32, activation = 'relu'))
model.add(Dropout(0.10))
model.add(Dense(16, activation = 'relu'))
# 마지막 Dropout은 좀 크게 주자
model.add(Dropout(0.50))
model.add(Dense(1, activation = 'sigmoid'))

# 모델 Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt,
              loss = "binary_crossentropy",
              metrics=["binary_accuracy"])
######################################################################################

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

Epoch 1/200
24/24 [==============================] - 1s 2ms/step - loss: 0.6264 - binary_accuracy: 0.6648
Epoch 2/200
24/24 [==============================] - 0s 2ms/step - loss: 0.4572 - binary_accuracy: 0.8413
Epoch 3/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3927 - binary_accuracy: 0.8649
Epoch 4/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3488 - binary_accuracy: 0.8736
Epoch 5/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3500 - binary_accuracy: 0.8776

...

Epoch 196/200
24/24 [==============================] - 0s 2ms/step - loss: 0.2589 - binary_accuracy: 0.8917
Epoch 197/200
24/24 [==============================] - 0s 2ms/step - loss: 0.3108 - binary_accuracy: 0.8813
Epoch 198/200
24/24 [==============================] - 0s 2ms/step - loss: 0.2486 - binary_accuracy: 0.9010
Epoch 199/200
24/24 [==============================] - 0s 1ms/step - loss: 0.2808 - binary_accuracy: 0.9001
Epoch 200/200
24/24 [==============================] - 0s 1ms/step - loss: 0.2638 - binary_accuracy: 0.9069
<tensorflow.python.keras.callbacks.History at 0x1b772b801f0>

>>> test_loss, test_acc = model.evaluate(X_test, y_test, verbose = 2)
>>> print("Accuracy:", np.round(test_acc, 5))
10/10 - 0s - loss: 0.7177 - binary_accuracy: 0.8200
Accuracy: 0.82

• model.evaluate(test_set, test_label, verbose=2): 위에서 직접 만들었던, Accuracy를 한 줄의 코드로 추출 가능하다.
• test_loss는 손실 값(loss)을 의미한다.
• test_acc는 정확도(accuracy)를 의미한다.

 지금까지 가장 기본적인 방법을 사용해서 타이타닉 데이터를 이진 분류해보았다. 최초 정확도가 0.78이 나왔으나, 최종적으로는 0.82가 나왔다.

 타이타닉 데이터를 사용한 생존자 분류 모델의 정확도는 기본적으로 Accuracy = 0.8을 기준으로 하며, 이를 얼마나 더 잘 모델링하느냐에 따라 그 결과가 Accuracy = 1.0까지 나오기도 한다.

 이보다 더 좋은 해결 방법을 참고하고자 한다면, 캐글에서 다른 사람들의 코드를 참고해보는 것도 좋은 생각이다. 그러나, 개인적으로는 이 내용을 기반으로, 더 발전시켜보기를 바란다.

 다음 포스팅에서는 타이타닉 데이터를 사용해서 더 많은 작업을 해보도록 하겠다.

 이전 포스트에서 타이타닉 데이터가 어떻게 구성되어 있는지 확인해보았다. 이번 포스트에서는 타이타닉 데이터를 전처리해보고, 생존자 분류 모델을 만들어보자.

타이타닉 데이터 생존자 분류 모델 만들기

• 모든 데이터 분석에서도 그렇듯 딥 러닝 모델 생성에서도 제일 우선 되는 것은 데이터 전처리다.
• 머신러닝 모델을 만들 때의 순서는 다음과 같다.

1. 데이터 셋의 특징을 잘 나타낼 수 있게 전처리를 한다(Data Handling).
2. 학습이 제대로 되도록 데이터 셋을 잘 쪼갠다(Train, Validation, Test).
3. 목적과 데이터에 맞는 모델을 생성한다.
4. 학습 후, 모델의 성능을 평가하고, 성능을 업그레이드한다.

• 이번엔 각 영역이 미치는 영향이 얼마나 큰지를 시각적으로 보도록 하겠다.

0. 데이터 불러오기

• 이전 포스트에서 만들었던 데이터를 가져오는 코드를 정리해보자.

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

# 모든 Data를 DataFrame의 형태로 dictionary에 넣어 가지고 온다.
def import_Data(file_path):

    result = dict()
    for file in os.listdir(file_path):

        file_name = file[:-4]
        result[file_name] = pd.read_csv(file_path + "/" + file)

    return result

# 해당 경로에 있는 모든 파일을 DataFrame으로 가지고 왔다.
file_path = "./Dataset"
Rawdata_dict = import_Data(file_path)

1. 데이터 전처리

• 이전 포스트에서 파악한 데이터 셋의 내용을 기반으로, 데이터 셋을 전처리해보자.

1.1. 데이터 셋 전처리가 쉽도록 한 덩어리로 만들자.

# 흩어져 있는 데이터를 모아 하나의 Rawdata로 만든다.
def make_Rawdata(dict_data):

    dict_key = list(dict_data.keys())
    test_Dataset = pd.merge(dict_data["gender_submission"], dict_data["test"], how='outer', on="PassengerId")
    Rawdata = pd.concat([dict_data["train"], test_Dataset])
    Rawdata.reset_index(drop=True, inplace=True)
    
    return Rawdata

• pd.merge(): 두 DataFrame을 동일한 Column을 기준(열 기준)으로 하나로 합친다.
• pd.concat(): 모든 Column이 동일한 두 DataFrame을 행 기준으로 하나로 합친다.
• DataFrame.reset_index(): DataFrame의 index를 초기화한다.

Rawdata = make_Rawdata(Rawdata_dict)
Rawdata

1.2. 불필요한 Column을 제거하자.

• 생존 여부에 절대 영향을 줄 수 없는 Column을 제거하여, Feature가 두드러지도록 만들자.
• 고객의 ID(PassengerId), 고객의 이름(Name), 티켓 번호(Tiket)는 생존 여부에 영향을 줄 가능성이 거의 없다고 판단된다. 그러므로, Dataset에서 제거하자.

from copy import copy

def remove_columns(DF, remove_list):
    
    # 원본 정보 유지를 위해 copy하여, 원본 Data와의 종속성을 끊었다.
    result = copy(Rawdata)

    # PassengerId를 Index로 하자.
    result.set_index("PassengerId", inplace = True)

    # 불필요한 column 제거
    for column in remove_list:

        del(result[column])
        
    return result

• copy(Data): Data를 복사하여, 데이터의 종속성이 없는 데이터를 만들어낸다.
• DataFrame.set_index(): 특정 column을 Index로 설정한다.
• del(DataFrame[column]): DataFrame에서 해당 column을 제거한다.

remove_list = ["Name", "Ticket"]
DF_Hand1 = remove_columns(Rawdata, remove_list)
DF_Hand1

1.3. 칼럼 별 결측 값의 현황을 파악하자.

• 결측 값은 다른 행의 데이터들을 없애버릴 수 있으므로, 최우선 해결해야 할 과제다.
• 먼저, 각 칼럼 별 결측 값이 존재하는 칼럼과 그 개수를 파악하자.

# 컬럼별 결측값의 갯수 파악
>>> DF_Hand1.isnull().sum()

Survived       0
Pclass         0
Sex            0
Age          263
SibSp          0
Parch          0
Fare           1
Cabin       1014
Embarked       2
dtype: int64

• df.isnull(): DataFrame에서 결측 값(NaN)인 원소는 True로, 그렇지 않은 원소는 False로 나타낸다.
• df.sum(): DataFrame의 각 칼럼 별 합을 낸다.
• 위 결과를 보니, Cabin은 결측 값의 수가 지나치게 많아, 사용하지 않는 것이 좋다고 판단된다.
• Cabin은 객실 번호로, 객실 번호가 배에서 탈출하기 좋은 위치에 영향을 줄 수도 있다고 판단되나, 이미 이 정보를 담을 수 있는 다른 변수인 Pclass(티켓 등급), Fare(승객 요금), Embarked(기항지 위치)가 있으니, 제거해도 괜찮을 것으로 판단된다.
• Age는 총 데이터 1309개 중 263개에 해당하여, 차지하는 비중이 20%나 되지만, 생존에 큰 영향을 줄 수 있다고 판단되어, 보류하도록 하겠다.
• 결측 값은 Single Imputation으로 대체하지 않고, 일단 행 제거를 하여, 데이터의 양을 줄이는 쪽으로 방향을 잡도록 하겠다.
• 단순 대체로 평균을 넣는다거나, 의사 결정 나무, 회귀 모형을 통한 결측 값 추정이 가능하긴 하나, 일단은 이는 뒤로 미루자.

def missing_value(DF):

    # Cabin 변수를 제거하자
    del(DF["Cabin"])
    
    # 결측값이 있는 모든 행은 제거한다.
    DF.dropna(inplace = True)

• DataFrame.dropna(): 결측 값이 있는 행을 모두 제거한다.

# 결측값 처리
missing_value(DF_Hand1)
DF_Hand1

• 결측 값이 있는 행들을 제거하여, 총 행의 수가 1309개에서 1043개로 감소하였다.

1.4. 문자열 처리

• 머신러닝에 들어가는 Tensor에는 문자가 들어갈 수 없다.
• 모든 문자를 숫자로 바꾸도록 하자.
• 단순하게, 각 문자를 특정 숫자로 바꾸도록 하자.
• Sex: male = 0, female = 1
• Embarked: C = 0, Q = 1, S = 2

# 문자 데이터 처리
DF_Hand1["Sex"] = np.where(DF_Hand1["Sex"].to_numpy() == "male", 0, 1)
DF_Hand1["Embarked"] = np.where(DF_Hand1["Embarked"].to_numpy() == "C", 0,
                                np.where(DF_Hand1["Embarked"].to_numpy() == "Q", 1, 2))

>>> DF_Hand1

2. 데이터셋 분리 및 표준화

• 기본적인 데이터 전처리는 끝났으므로, 데이터셋을 Train과 Test, Label Dataset으로 분리하자.

2.1. 데이터셋 분리

• Train:Test = 7:3으로 분리해보자.
• Label Data도 분리하자.

# Label 생성
y_test, y_train = DF_Hand1["Survived"][:300].to_numpy(), DF_Hand1["Survived"][300:].to_numpy()

# Dataset 생성
del(DF_Hand1["Survived"])
X_test, X_train = DF_Hand1[:300].values, DF_Hand1[300:].values

• Series.to_numpy(), DataFrame.values 이 두 함수를 사용하면, 쉽게 array로 만들 수 있다.

>>> X_train
array([[  1.    ,   0.    ,  27.    , ...,   2.    , 211.5   ,   0.    ],
       [  3.    ,   0.    ,  20.    , ...,   0.    ,   4.0125,   0.    ],
       [  3.    ,   0.    ,  19.    , ...,   0.    ,   7.775 ,   2.    ],
       ...,
       [  3.    ,   1.    ,  28.    , ...,   0.    ,   7.775 ,   2.    ],
       [  1.    ,   1.    ,  39.    , ...,   0.    , 108.9   ,   0.    ],
       [  3.    ,   0.    ,  38.5   , ...,   0.    ,   7.25  ,   2.    ]])
       
>>> y_test
array([0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0,
       1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1,
       0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0,
       1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,
       0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0,
       1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1,
       1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0,
       1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
       1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
       1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0,
       1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1,
       1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1,
       0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1], dtype=int64)

2.2. 표준화시켜주자.

• 숫자가 큰  Age,  Fare를 Train Dataset에 맞춰 최소-최대 스케일 변환해주자.

# 표준화
age_min = np.min(X_test[:,2])
age_max = np.max(X_test[:,2])

Fare_min = np.min(X_test[:,5])
Fare_max = np.max(X_test[:,5])

X_train[:,2] = (X_train[:,2] - age_min)/(age_max - age_min)
X_test[:,2] = (X_test[:,2] - age_min)/(age_max - age_min)

X_train[:,5] = (X_train[:,5] - Fare_min)/(Fare_max - Fare_min)
X_test[:,5] = (X_test[:,5] - Fare_min)/(Fare_max - Fare_min)

>>> X_train
array([[1.        , 0.        , 0.3729514 , ..., 2.        , 0.41282051,
        0.        ],
       [3.        , 0.        , 0.27319367, ..., 0.        , 0.00783188,
        0.        ],
       [3.        , 0.        , 0.25894257, ..., 0.        , 0.01517579,
        2.        ],
       ...,
       [3.        , 1.        , 0.38720251, ..., 0.        , 0.01517579,
        2.        ],
       [1.        , 1.        , 0.54396466, ..., 0.        , 0.21255864,
        0.        ],
       [3.        , 0.        , 0.53683911, ..., 0.        , 0.01415106,
        2.        ]])
        
>>> X_test
array([[3.        , 0.        , 0.30169588, ..., 0.        , 0.01415106,
        2.        ],
       [1.        , 1.        , 0.52971355, ..., 0.        , 0.13913574,
        0.        ],
       [3.        , 1.        , 0.3587003 , ..., 0.        , 0.01546857,
        2.        ],
       ...,
       [1.        , 0.        , 0.30169588, ..., 0.        , 0.26473857,
        0.        ],
       [3.        , 1.        , 0.0309249 , ..., 1.        , 0.04113566,
        2.        ],
       [3.        , 1.        , 0.30169588, ..., 0.        , 0.01415106,
        2.        ]])

• 이제 학습 준비가 어느 정도 완료되었다.

3. 모델 생성 및 학습하기

• 생존자 분류는 생존 or 사망으로 이진 분류이다.
• 이진 분류는 맨 마지막 출력층에서 Sigmoid 함수를 활성화 함수로 사용한다(참고: Sigmoid 함수).
• 손실 함수로는 binary cross Entropy를 사용한다(참고: binary crossentropy 함수).
• 분류이므로 compile에 metrics를 넣어 기준을 정해준다.

# 모델 생성
model = keras.Sequential()
model.add(Dense(128, activation = "relu"))
model.add(Dense(64, activation = "relu"))
model.add(Dense(32, activation = "relu"))
model.add(Dense(16, activation = "relu"))
model.add(Dense(1, activation = "sigmoid"))

# 모델 Compile
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt,
              loss = "binary_crossentropy",
              metrics=["binary_accuracy"])

>>> model.fit(X_train, y_train, epochs = 500)
Epoch 1/500
24/24 [==============================] - 1s 2ms/step - loss: 0.6112 - binary_accuracy: 0.6089
Epoch 2/500
24/24 [==============================] - 0s 2ms/step - loss: 0.3803 - binary_accuracy: 0.8494
Epoch 3/500
24/24 [==============================] - 0s 1ms/step - loss: 0.3446 - binary_accuracy: 0.8722
Epoch 4/500
24/24 [==============================] - 0s 1ms/step - loss: 0.3261 - binary_accuracy: 0.8778
Epoch 5/500
24/24 [==============================] - 0s 1ms/step - loss: 0.3600 - binary_accuracy: 0.8678

...

Epoch 496/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1601 - binary_accuracy: 0.9350
Epoch 497/500
24/24 [==============================] - 0s 954us/step - loss: 0.1759 - binary_accuracy: 0.9169
Epoch 498/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1753 - binary_accuracy: 0.9257
Epoch 499/500
24/24 [==============================] - 0s 997us/step - loss: 0.1667 - binary_accuracy: 0.9264
Epoch 500/500
24/24 [==============================] - 0s 1ms/step - loss: 0.1576 - binary_accuracy: 0.9289
<tensorflow.python.keras.callbacks.History at 0x15afa302b20>

• epochs를 500으로 주었으나, 손실 값이 0.1576으로 만족할 만큼 떨어지진 않은 것을 볼 수 있다.
• 그러나 이 손실 값은 상대적인 값이므로, 단순하게 접근해선 안된다.

4. 모델 평가하기

• 분류이므로, 모델을 평가하는 기준인 정확도는 실제 분류와 예측한 분류가 얼마나 일치하는지를 보면 될 것이다.

>>> pred = model.predict(X_test).reshape(X_test.shape[0])
>>> pred = np.where(pred > 0.5, 1, 0)
>>> accuracy = 1 - (np.where((pred - y_test) == 0, 0, 1).sum()/len(y_test))
>>> print("Accuracy:", accuracy)

Accuracy: 0.78

• 정확도가 0.78로 78%의 예측값만 실제와 일치하는 것으로 나타났다.
• 모델이 78%만 맞췄다는 것은, 모델의 분류 성능이 기대할만한 수준이라 보기가 힘들다고 할 수 있다.
• 그러나, 우리는 캐글의 Leaderboard를 보면 Titanic Dataset의 생존 분류의 예측률이 1.000으로 100%에 가까운 성능이 나온 것을 볼 수 있다!

• 대체 무슨 차이가 있길래 이 사람들이 만든 모델과 이번에 만든 모델의 성능 차이가 이토록 많이 날까?

 머신러닝은 보시다시피 마법의 상자가 아니라, 사용자가 얼마나 잘 설계를 하냐에 따라 전혀 다른 결과가 나오게 된다. 다음 포스트부턴 타이타닉 생존자 분류 모델의 성능을 올릴 수 있는 방법에 대해 학습해보도록 하겠다.

 지난 포스트에서는 시그모이드 함수에서 발전한 소프트맥스 함수에 대해 학습해보았다. 이번 포스트에서는 시그모이드 함수와 꽤 유사하면서, 시그모이드 함수의 단점을 보완한 하이퍼볼릭 탄젠트 함수에 대해 학습해보겠다.

하이퍼볼릭 탄젠트(Hyperbolic Tangent, tanh)

 우리말로 쌍곡선 탄젠트 함수라고 말하는 하이퍼볼릭 탄젠트는 수학이나 물리학을 전공한 사람이 아니라면, 영 볼 일이 없는 함수다.

 시그모이드, 소프트맥스 함수는 워낙 자주 사용되고, 신경망의 핵심 알고리즘인 로지스틱 회귀 모형에서 유래되었으므로, 공식까지 세세하게 파고 들어갔으나, 하이퍼볼릭 탄젠트 함수는 그 정도까지 설명할 필요는 없다고 생각한다.

 가볍게 하이퍼볼릭 탄젠트가 어떻게 생겼고, 왜 시그모이드 함수의 단점을 보완했다는지만 알아보도록 하자.

1. 하이퍼볼릭 탄젠트란?

• 하이퍼볼릭 함수는 우리말로 쌍곡선 함수라고도 하며, 삼각함수는 단위원 그래프를 매개변수로 표시할 때, 나오지만, 쌍곡선 함수는 표준 쌍곡선을 매개변수로 표시할 때 나온다는 특징이 있다.
• 삼각함수에서 $tanx$ = $sinx$/$cosx$로 나왔듯, 쌍곡선 함수에서 쌍곡탄젠트(Hyperbolic tangent)는 $tanhx$ = $sinhx$/$coshx$를 통해서 구한다.
• 공식은 다음과 같다.

$$ sinhx = sinhx = \frac{e^x - e^{-x}}{2} $$

$$ coshx = \frac{e^x + e^{-x}}{2} $$

$$ tanhx = \frac{sinhx}{coshx} = \frac{e^x - e^{-x}}{e^x + e^{-x}} $$

• 이들을 명명하는 방식은 다음과 같다.
  • $sinhx$: 신치, 쌍곡 샤인, 하이퍼볼릭 샤인
  • $coshx$: 코시, 쌍곡 코샤인, 하이퍼볼릭 코샤인
  • $tanhx$: 텐치, 쌍곡 탄젠트, 하이퍼볼릭 탄젠트

2. 하이퍼볼릭 탄젠트의 구현.

• 위 공식을 그대로 구현해보면 다음 코드와 같다.

>>> import numpy as np

# 하이퍼볼릭 탄젠트
>>> def tanh(x):
>>>     p_exp_x = np.exp(x)
>>>     m_exp_x = np.exp(-x)
    
>>>     y = (p_exp_x - m_exp_x)/(p_exp_x + m_exp_x)
    
>>>     return y

• 시각화해보자

>>> import matplotlib.pyplot as plt

>>> x = np.arange(-5.0, 5.0, 0.1)
>>> y = tanh(x)

# 캔버스 설정
>>> fig = plt.figure(figsize=(10,7)) # 캔버스 생성
>>> fig.set_facecolor('white')      # 캔버스 색상 설정

>>> plt.plot(x, y)
>>> plt.title("Hyperbolic Tangent", fontsize=30)
>>> plt.xlabel('x', fontsize=20)
>>> plt.ylabel('y', fontsize=20, rotation=0)

>>> plt.yticks([-1.0, 0.0, 1.0]) # 특정 축에서 특정 값만 나오게
>>> plt.axvline(0.0, color='k')
>>> ax = plt.gca()
>>> ax.yaxis.grid(True) # y축에 있는 모든 숫자에 회색 점근선을 그음

>>> plt.show()

• 위 그림을 보면, 어째서 하이퍼볼릭 탄젠트 함수가 시그모이드 함수를 일부 보완했다고 하였는지, 이해할 수 있겠는가?
• 시그모이드 함수와 하이퍼볼릭 탄젠트 함수의 가장 큰 차이는 출력값의 범위로, 하이퍼볼릭 탄젠트 함수는 -1에서 1 사이의 값을 출력하며, 중앙값도 0이다!
• 이를 정리해보면 다음과 같다.

3. 하이퍼볼릭 탄젠트와 시그모이드 함수

• 하이퍼볼릭 탄젠트는 중앙값이 0이기 때문에, 경사하강법 사용 시 시그모이드 함수에서 발생하는 편향 이동이 발생하지 않는다.
• 즉, 기울기가 양수 음수 모두 나올 수 있기 때문에 시그모이드 함수보다 학습 효율성이 뛰어나다.
• 또한, 시그모이드 함수보다 범위가 넓기 때문에 출력값의 변화폭이 더 크고, 그로 인해 기울기 소실(Gradient Vanishing) 증상이 더 적은 편이다.
  (※ 기울기 소실(Gradient Vanishing): 미분 함수에 대하여, 값이 일정 이상 커지는 경우 미분값이 소실되는 현상)

• 때문에 은닉층에서 시그모이드 함수와 같은 역할을 하는 레이어를 쌓고자 한다면, 하이퍼볼릭 탄젠트를 사용하는 것이 효과적이다.
• 그러나, 시그모이드 함수보다 범위가 넓다 뿐이지 하이퍼볼릭 탄젠트 역시 그 구간이 그리 크지는 않은 편이므로, $x$가 -5보다 작고 5보다 큰 경우, 기울기(Gradient)가 0으로 작아져 소실되는 기울기 소실 현상 문제는 여전히 존재한다.

# 시그모이드 함수의 미분
def diff_sigmoid(x):
    
    return 1/(1+np.exp(-x)) * (1 - (1/(1+np.exp(-x))))

# 하이퍼볼릭 탄젠트의 미분
def diff_tanh(x):
    
    return 4 / (np.exp(2*x) + 2 + np.exp(-2*x))

>>> import matplotlib.pyplot as plt

>>> x = np.arange(-10.0, 10.0, 0.1)
>>> y1 = diff_sigmoid(x)
>>> y2 = diff_tanh(x)

>>> fig = plt.figure(figsize=(10,5))

>>> plt.plot(x, y1, c = 'blue', linestyle = "--", label = "diff_sigmoid")
>>> plt.plot(x, y2, c = 'green', label = "diff_tanh")

>>> plt.title("Sigmoid VS tanh", fontsize=30)
>>> plt.xlabel('x', fontsize=20)
>>> plt.ylabel('y', fontsize=20, rotation=0)

>>> plt.ylim(-0.5, 2)
>>> plt.xlim(-7, 7)

>>> plt.legend(loc = "upper right")

>>> plt.axvline(0.0, color='k')
>>> ax = plt.gca()
>>> ax.yaxis.grid(True)
>>> ax.xaxis.grid(True)

>>> plt.show()

• 위 그래프는 시그모이드의 도함수(파랑)와 하이퍼볼릭 탄젠트(녹색)의 미분 함수를 비교한 것으로, 시그모이드 함수의 미분보다 하이퍼볼릭 탄젠트의 미분이 상황이 더 낫긴 하지만, 하이퍼볼릭 탄젠트의 미분 역시 ±5부터 0이 되어버리므로, 기울기 소실 문제에서 안전하지 않다는 것을 알 수 있다.

 지금까지 하이퍼볼릭 탄젠트에 대해 알아보았다. 시그모이드 함수의 단점을 많이 보완한 활성화 함수이긴 하지만, 여전히 기울기 소실 문제가 발생할 가능성이 있으므로, 은닉층에서 쓰고자 하면, 쓰되 조심히 쓰기를 바란다.

 다음 포스트에서는 은닉층에서 가장 많이 사용되는 렐루(ReLU) 함수에 대해 알아보도록 하겠다.

 지난 포스트에서 퍼셉트론의 가장 기본이 되는 활성화 함수인 계단 함수(Step Function)를 학습하였으며, 선형 함수(Linear Function)의 한계점에 대해서도 학습해보았다.

 선형 함수는 층을 쌓는 것이 무의미해진다는 단점이 있고, 비선형함수 중 하나인 계단 함수는 값의 크기에 대한 정보가 소실된다는 단점이 있다.

 이번 포스트에서는 이 두 단점이 해결된 비선형 함수 중 하나인 시그모이드 함수에 대해 학습해보겠다.

시그모이드 함수(Sigmoid Function)

계단 함수는 출력을 0과 1로 이진 값만 반환하며, 그 사이에 있는 값은 무시한다는 단점이 있었다. 그렇다면, 앞서 봤던 계단 함수의 각진 부분이 매끄러워진다면 어떨까?

1. 로지스틱 회귀 모델과 오즈(Odds)

• 통계학을 조금이라도 공부해봤거나, 분석에 관심 있는 사람이라면, 이진 분류의 대표적인 모델 중 하나인 로지스틱 회귀(Logistic regression)에 대해 들어봤거나, 알고 있을 것이다.
• 시그모이드 함수를 설명하기 앞서 로지스틱 회귀 모델의 오즈(Odds)를 이야기 해보겠다.

오즈(Odds)

• 오즈는 성공과 실패의 비율이다.
• 확률(Probability)과 뉘앙스가 꽤 다른 확률로
• "사건 A가 일어날 확률 / 사건 A가 일어나지 않을 확률"을 말한다.

$$ Odds = \frac{P}{1-P} $$

오즈비(Odds ratio)

• 참고로 오즈비(Odds ratio)와 오즈(Odds)를 헷갈리는 경우가 종종 있는데, 오즈비는 우리말로 교차비라고 하며, 서로 다른 집단의 오즈를 비교할 때 사용된다.
• 예를 들어 약품의 성능 대한 오즈비는, "약품 A를 먹어서 호전될 오즈 / 위약을 먹어서 호전될 오즈"이다.

$$ Test\ favorable\ Odds = \frac{Test\ favorable\ ratio}{Test\ unfavorable\ ratio} = \frac{\frac{60}{100}}{\frac{40}{100}} = 1.5$$

$$ Control\ favorable\ Odds = \frac{Control\ favorable\ ratio}{Control\ unfavorable\ ratio} = \frac{\frac{20}{100}}{\frac{80}{100}}=0.25$$

$$ OddsRatio = \frac{Test\ favorable\ Odds}{Control\ favorable\ Odds} = \frac{1.5}{0.25} = 6.0 $$

• 위 예시를 보면, 약품A의 효과는 위약의 효과의 6.0배임을 알 수 있다.

로짓 변환.

• 오즈에 자연로그를 취해서 로짓(Logit) 함수를 만들어보자.

$$ logit(P) = ln\frac{p}{1-p} = f(x) $$

$$ \frac{p}{1-p} = e^{f(x)},\ \  p=e^{f(x)}(1-p),\ \  p=e^{f(x)} - pe^{f(x)}, \ \  p(1+e^{f(x)})=e^{f(x)} $$

$$ p = \frac{e^{f(x)}}{1+e^{f(x)}} = \frac{1}{1+e^{-{f(x)}}} $$

• 위 함수를 로지스틱 시그모이드 함수(Logistic sigmoid function)이라고 하며, 줄여서 시그모이드 함수(Sigmoid function)이라고 한다.
• 여기서 $f(x)$에 회귀 분석과 같은 함수 식을 넣으면, 로지스틱 회귀 모델(Logistic Regression model)이 된다.

$$ f(x) = w^Tx = w_0x_0 + w_1x_1 + w_2x_2 +\ ... + w_mx_m  $$

2. 시그모이드 함수(Sigmoid Function)

• 시그모이드 함수를 파이썬에서 구현해보자.

# 시그모이드 함수
>>> def sigmoid(x):
>>>     return 1 / (1 + np.exp(-x))

>>> x = np.arange(-10.0, 10.0, 0.1)
>>> y = sigmoid(x)

# 캔버스 설정
>>> fig = plt.figure(figsize=(8,7)) # 캔버스 생성
>>> fig.set_facecolor('white')      # 캔버스 색상 설정

>>> plt.plot(x, y)
>>> plt.ylim(-0.1, 1.1)
>>> plt.xlim(-10, 10)
>>> plt.title("Sigmoid", fontsize=30)
>>> plt.xlabel('x', fontsize=20)
>>> plt.ylabel('y', rotation=0, fontsize=20)

>>> plt.yticks([0.0, 0.5, 1.0]) # 특정 축에서 특정 값만 나오게
>>> plt.axvline(0.0, color='k')
>>> ax = plt.gca()
>>> ax.yaxis.grid(True) # y축에 있는 모든 숫자에 회색 점근선을 그음

>>> plt.show()

• 시그모이드 함수는 0에서 1 사이의 함수이며, 값이 들어왔을 때, 0~1 사이의 값을 반환한다.
• 연속형 데이터이기 때문에 계단 함수가 끊기지 않는 매끄러운 모양으로 바뀐 것을 알 수 있다.
• 동시에 이상치가 들어온다 할지라도, 시그모이드 함수는 0과 1에 수렴하므로, 이상치 문제도 해결하면서, 연속된 값을 전달할 수 있다.

• 시그모이드 함수를 활성화 함수로 사용하면, 0과 1에 가까운 값을 통해 이진 분류를 할 수 있다.

3. 시그모이드 함수의 장점과 단점

A. 장점

• 출력 값의 범위가 0 ~ 1 사이이며, 매우 매끄러운 곡선을 가지므로, 후술 할 경사하강법을 시행할 때, 기울기가 급격하게 변해서 발산하는, 기울기 폭주(Gradient Exploding)가 발생하지 않는다.
• 분류는 0과 1로 나뉘며, 출력 값이 어느 값에 가까운지를 통해 어느 분류에 속하는지 쉽게 알 수 있다.

B. 단점

• 입력값이 아무리 크더라도, 출력되는 값의 범위가 매우 좁기 때문에 경사하강법 수행 시에 범위가 너무 좁아, 0에 수렴하는 기울기 소실(Gradient Vanishing)이 발생할 수 있다.

  B.1. 기울기 소실(Gradient Vanishing) 문제

• 시그모이드 함수는 아무리 큰 값이 들어온다 할지라도 0~1사이의 값만 반환하므로, 값이 일정 비율로 줄어들어 값의 왜곡이라 할 수는 없으나, 값이 현저하게 줄어들게 된다. 
• 또한, 출력 값의 중앙값이 0이 아닌 0.5이며, 모두 양수기 때문에 출력의 가중치 합이 입력의 가중치 합보다 커지게 된다.
• 이를 편향 이동(Bias Gradient)라 하고, 신호가 각 레이어를 통과할 때마다 분산이 계속 커지게 되어, 활성화 함수의 출력이 최댓값과 최솟값인 0과 1에 수렴하게 된다.
• 시그모이드 함수의 도함수는 $\sigma(1-\sigma)$인데, 도함수에 들어가는 함수의 값이 0이나 1에 가까울수록 당연히 출력되는 값이 0에 가까워지게 된다.
• 이로 인해 수렴되는 뉴련의 기울기(Gradient) 값이 0이 되고, 역전파 시 0이 곱해져서 기울기가 소멸(kill)되는 현상이 발생해버린다! 즉, 역전파가 진행될수록 아래 층(Layer)에 아무런 신호가 전달되지 않는 것이다!
• 이를 기울기 소실(Gradient Vanishing)이라 하며, 렐루 함수가 등장하기 전까지인 1986년부터 2006년까지 해결되지 않은 문제다.

  B.2. 학습 속도 저하 문제

• 시그모이드 함수의 출력값은 모두 양수기 때문에 경사하강법을 진행할 때, 그 기울기가 모두 양수거나 음수가 된다. 이는 기울기 업데이트가 지그재그로 변동하는 결과를 가지고 오고, 학습 효율성을 감소시켜 학습에 더 많은 시간이 들어가게 만든다.

 위 시그모이드 함수의 장단점을 간추려보면, 출력값이 너무 작아 제대로 학습이 안되는데다가 시간도 많이 잡아먹는다는 소리다.

 이는, 출력층에서 시그모이드 함수를 사용하는 것은 상관 없으나, 아래로 정보가 계속 흘러가는 은닉층(Hidden Layer)에서는 시그모이드 함수를 활성화 함수로 사용해서는 안된다는 소리다.

• 은닉층(Hidden Layer)은 입력층(시작), 출력층(끝) 사이에 있는 부분이다.
• 즉, 은닉층에는 앞서 말했던 선형 함수와 시그모이드 함수는 사용하지 않는 것이 좋다.
• 시그모이드 함수는 이진 분류를 하고자 하는 경우 출력층에서만 사용하는 것을 권고한다.
• 만약, 입력층에서 시그모이드 함수를 쓰고자 한다면, 이의 발전형인 하이퍼볼릭 탄젠트 함수를 사용하는 것을 추천한다.

 이번 포스트에서는 시그모이드 함수에 대해 간략하게 알아보았다. 시그모이드 함수는 이진 분류가 목적인 학습 모델에서 출력층에서 사용하는 것을 추천한다. 다음 포스트에서는 또 다른 활성화 함수인 소프트맥스 함수에 대해 학습해보겠다.