[딥러닝] 6. 딥러닝 모델 학습의 문제점 pt.3 : 과적합

4. 과적합 문제와 방지 기법

 

과적합 문제 (overfitting) : 알고리즘이 학습 데이터에 과하게 적합한 상태.
                                            학습 데이터가 아닌 다른 데이터에서 정확한 예측을 생성하지 못함 (일반화 하지 못함)

• 과적합 발생 원인 : 
  • 데이터의 퍼진 정도, 즉 분산(variance)이 높은 경우
  • 너무 많이 학습 데이터를 학습시킨 경우 (epochs가 매우 큰 경우)
  • 학습에 사용된 파라미터가 너무 많은 경우
  • 데이터에 비해 모델이 너무 복잡한 경우
  • 데이터에 노이즈 & 이상치(outlier)가 너무 많은 경우

 

• 과적합 현상 방지 기법 : 정규화 (Regularization), 드롭아웃 (Dropout), 배치 정규화 (Batch Normalization)

 

 

 

1. 정규화 (Regularization) : 

모델이 복잡해질수록 parameter들은 많아지고, 절댓값이 커지는 경향이 발생함. ->  기존 손실 함수에 규제항을 더해 최적값 찾기 가능

딥러닝은 규제항(loss)가 작아지는 방향으로 학습함

 

• L1 정규화 (Lasso Regularization) : 
  • 가중치의 절댓값의 합을 규제항(loss)으로 정의.
  • $ Total Loss = Loss + \lambda  \sum_w|W| $
  • 모델 내의 일부 가중치를 0으로 만들어 의미있는 가중치만 남도록 만들어 줌 > sparse한 모델을 만듦
  • 가중치에 L1 정규화를 적용하는 비율 (0.001 ~0.005)
  • tf.keras.layers.Dense(kernel_regularizer = tf.keras.regularizers.l1(ratio))
• L2 정규화(Ridge Regularization): 
  • 가중치의 제곱의 합을 규제항(loss)으로 정의. 
  • $ Total Loss =  Loss + \lambda \sum_w W^2$ 
  • 학습이 진행될 때 가중치의 값이 0에 가까워지도록 만들어줌. 큰 값을 가진 가중치를 더욱 제약하는 효과
  • L1 정규화에 비하여 0으로 수렴하는 가중치가 적음. 
  • 특정 가중치에 치중되지 않도록 가중치 값을 조율하게 되며 가중치 감쇠 (Weight Decay)라고 부름
  • 가중치에 L2 정규화를 적용하는 비율 (0.001 ~0.005)
  • tf.keras.layers.Dense(kernel_regularizer = tf.keras.regularizers.l2(ratio))

 

[ 기본 모델 vs L1 정규화 적용 모델 vs L2 정규화 적용 모델 비교 ]

import numpy as np
import tensorflow as tf
from visual import *
import logging, os
logging.disable(logging.WARNING)

# 데이터를 전처리하는 함수 - one hot 임베딩
def sequences_shaping(sequences, dimension):
    
    results = np.zeros((len(sequences), dimension))
    for i, word_indices in enumerate(sequences):
        results[i, word_indices] = 1.0 
    
    return results

''' 기본 모델 '''
def Basic(word_num):
    
    basic_model = tf.keras.Sequential([ 
        tf.keras.layers.Dense(256, activation = 'relu', input_shape=(word_num,)), 
        tf.keras.layers.Dense(128, activation = 'relu'),
        tf.keras.layers.Dense(1, activation= 'sigmoid')
        ])
    
    return basic_model


''' 기본 모델에 L1 정규화 적용 (입력층과 히든층에만 적용) '''
def L1(word_num):
    
    l1_model = tf.keras.Sequential([ 
        tf.keras.layers.Dense(256, activation = 'relu', input_shape=(word_num,), kernel_regularizer = tf.keras.regularizers.l1(0.002)), 
        tf.keras.layers.Dense(128, activation = 'relu', kernel_regularizer = tf.keras.regularizers.l1(0.002)),
        tf.keras.layers.Dense(1, activation= 'sigmoid')
        ])
    
    return l1_model

''' 기본 모델에 L2 정규화 적용 (입력층과 히든층에만 적용) '''
def L2(word_num):
    
    l2_model = tf.keras.Sequential([ 
        tf.keras.layers.Dense(256, activation = 'relu', input_shape=(word_num,), kernel_regularizer = tf.keras.regularizers.l2(0.002)), 
        tf.keras.layers.Dense(128, activation = 'relu', kernel_regularizer = tf.keras.regularizers.l2(0.002)),
        tf.keras.layers.Dense(1, activation= 'sigmoid')
        ])
    
    return l2_model


''' 세 모델을 불러온 후 학습시키고 테스트 데이터에 대해 평가 (binary crossentropy 값 출력) '''

def main():
    
    word_num = 100
    data_num = 25000
    
    # Keras에 내장되어 있는 imdb 데이터 세트를 불러오고 전처리
    (train_data, train_labels), (test_data, test_labels) = tf.keras.datasets.imdb.load_data(num_words = word_num)
    
    train_data = sequences_shaping(train_data, dimension = word_num)
    test_data = sequences_shaping(test_data, dimension = word_num)
    
    basic_model = Basic(word_num)  # 기본 모델
    l1_model = L1(word_num)     # L1 정규화를 적용할 모델
    l2_model = L2(word_num)     # L2 정규화를 적용할 모델
    
    # 모델 최적화
    basic_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy','binary_crossentropy'])
    l1_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy','binary_crossentropy'])
    l2_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy','binary_crossentropy'])
    
    basic_model.summary()
    l1_model.summary()
    l2_model.summary
    
    # 모델 학습
    basic_history = basic_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)
    print('\n')
    l1_history = l1_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)
    print('\n')
    l2_history = l2_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)
    
    # 모델 평가
    scores_basic = basic_model.evaluate(test_data, test_labels)
    scores_l1 = l1_model.evaluate(test_data, test_labels)
    scores_l2 = l2_model.evaluate(test_data, test_labels)
    
    print('\nscores_basic: ', scores_basic[-1])
    print('scores_l1: ', scores_l1[-1])
    print('scores_l2: ', scores_l2[-1])
    
    Visulaize([('Basic', basic_history),('L1 Regularization', l1_history), ('L2 Regularization', l2_history)])
    
    return basic_history, l1_history, l2_history

if __name__ == "__main__":
    main()

 

 

 

[ 코드 실행 결과 ]

• 규제를 적용하지 않은 basic 모델은 train의 crossentropy 값과 validation의 crossentropy 값이 차이가 큼 -> overfitting발생함
• L1, L2 정규화를 사용한 모델의 train, validation의 cross entropy 값 차이가 크지 않음 -> overfitting이 완화되었음
• 수치 데이터에서 L1, L2 정규화를 사용한 모델의 일반화 성능이 더 좋음을 알수 있음

### output ###
scores_basic:  0.7418451
scores_l1:  0.56926525
scores_l2:  0.56637627

 

 

 

 

 

2. 드롭 아웃 (Drop out) : 

• 각 layer마다 일정 비율의 뉴런을 임의로 drop시켜 나머지 뉴런들만 학습하는 방법. 
• 데이터를 학습할 때, 일부 퍼셉트론(뉴런)을 랜덤하게 0으로 만들어 모델 내부의 특정 가중치(Weight)에 치중되는 것을 막음
• 드롭 아웃을 적용하면 학습되는 노드와 가중치들이 매번 달라짐.
• 다른 정규화 기법들과 상호 보완적으로 사용 가능
• drop된 뉴런은 backpropagation때 신호 차단. Test 과정에서는 dropout 사용 X(모든 뉴런에 신호 전달)
• 드롭 아웃을 적용할 확률 : 0.1 ~ 0.5
• tf.keras.layers.Dropout(prob)

 

 

[ 기본 모델 vs dropout 적용 모델 비교 ]

import numpy as np
import tensorflow as tf
from visual import *
import logging, os
logging.disable(logging.WARNING)

# 데이터를 전처리하는 함수
def sequences_shaping(sequences, dimension):
    
    results = np.zeros((len(sequences), dimension))
    for i, word_indices in enumerate(sequences):
        results[i, word_indices] = 1.0 
        
    return results
    
''' 기본 모델 생성 '''
def Basic(word_num):
    
    basic_model = tf.keras.Sequential([ 
        tf.keras.layers.Dense(256, activation = 'relu', input_shape=(word_num,)), 
        tf.keras.layers.Dense(128, activation = 'relu'),
        tf.keras.layers.Dense(1, activation= 'sigmoid')
        ])
    
    return basic_model
    
''' 기본 모델에 드롭 아웃 레이어 추가 '''
def Dropout(word_num):
    
    dropout_model = tf.keras.Sequential([ 
        tf.keras.layers.Dense(256, activation = 'relu', input_shape=(word_num,)),
        tf.keras.layers.Dropout(0.3), 
        tf.keras.layers.Dense(128, activation = 'relu'),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Dense(1, activation= 'sigmoid')
        ])
    
    return dropout_model

''' 두 모델을 불러온 후 학습시키고 테스트 데이터에 대해 평가(binary crossentropy 점수 출력) '''
def main():
    
    word_num = 100
    data_num = 25000
    
    # Keras에 내장되어 있는 imdb 데이터 세트를 불러오고 전처리
    (train_data, train_labels), (test_data, test_labels) = tf.keras.datasets.imdb.load_data(num_words = word_num)
    
    train_data = sequences_shaping(train_data, dimension = word_num)
    test_data = sequences_shaping(test_data, dimension = word_num)
    
    basic_model = Basic(word_num)   # 기본 모델
    dropout_model = Dropout(word_num)  # 드롭 아웃 적용할 모델
    
    basic_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy','binary_crossentropy'])
    dropout_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy','binary_crossentropy'])
    
    basic_model.summary()
    dropout_model.summary()
    
    basic_history = basic_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)
    print('\n')
    dropout_history = dropout_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)
    
    scores_basic = basic_model.evaluate(test_data, test_labels)
    scores_dropout = dropout_model.evaluate(test_data, test_labels)
    
    print('\nscores_basic: ', scores_basic[-1])
    print('scores_dropout: ', scores_dropout[-1])
    
    Visulaize([('Basic', basic_history),('Dropout', dropout_history)])
    
    return basic_history, dropout_history

if __name__ == "__main__":
    main()

 

 

 

[ 코드 실행 결과 ]

• dropout을 적용하지 않은 basic 모델은 train의 crossentropy 값과 validation의 crossentropy 값이 차이 큼 -> overfitting발생
• dropout을 적용한 모델의 train, validation의 cross entropy 값 차이가 크지 않음 -> overfitting이 완화되었음
• 테스트 데이터에서 droupout을 사용한 모델의 binary crossentropy 점수가 더 낮음 -> dropout 적용 모델의 일반화 성능이 더 좋음

### output ###
scores_basic:  0.7272758
scores_dropout:  0.60718566

 

 

 

 

3. 배치 정규화 (Batch Normalization):

• Normalization(정규화)을 처음 Input data 뿐만 아니라 신경망 내부 Hidden Layer의 input에도 적용
• 값의 분포를 통일함 (scailing)
• 배치 정규화의 장점 :
  • 매 Layer마다 정규화를 진행하므로 가중치 초기값에 크게 의존하지 않음. (가중치 초기화 중요도 감소)
  • 과적합 억제 (Dropout, L1, L2 정규화 필요성 감소)
  • 핵심은 학습 속도의 향상

 

 

 

[ 기본 모델 vs  배치 정규화 적용 모델 비교 ]

• 배치 정규화는 하나의 레이어로써 Dense 레이어와 활성화 함수 사이에서 작용
• 따라서, 기본 모델을 생성할 때 활성화 함수와 똑같은 역할을 하는 Activation 레이어를 따로 생성해야 함

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import logging
import os
from visual import *
logging.disable(logging.WARNING)

np.random.seed(42)
tf.random.set_seed(42)

# 기본 모델
def generate_basic_model():
    basic_model = tf.keras.Sequential([
                  tf.keras.layers.Flatten(input_shape=(28, 28)),
                  tf.keras.layers.Dense(256),
                  tf.keras.layers.Activation('relu'),
                  tf.keras.layers.Dense(128),
                  tf.keras.layers.Activation('relu'),
                  tf.keras.layers.Dense(512),
                  tf.keras.layers.Activation('relu'),
                  tf.keras.layers.Dense(64),
                  tf.keras.layers.Activation('relu'),
                  tf.keras.layers.Dense(128),
                  tf.keras.layers.Activation('relu'),
                  tf.keras.layers.Dense(256),
                  tf.keras.layers.Activation('relu'),
                  tf.keras.layers.Dense(10, activation='softmax')])
    return basic_model

''' 배치 정규화 적용 모델(각 Dense Layer 사이에 적용) '''
def generate_batch_norm_model():
    bn_model = tf.keras.Sequential([
                tf.keras.layers.Flatten(input_shape=(28, 28)),
                tf.keras.layers.Dense(256),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(128),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(512),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(64),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(128),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(256),
                tf.keras.layers.BatchNormalization(),
                tf.keras.layers.Activation('relu'),
                tf.keras.layers.Dense(10, activation='softmax')])
    return bn_model


def main():
    # MNIST 데이터를 불러오고 전처리
    mnist = tf.keras.datasets.mnist
    (train_data, train_labels), (test_data, test_labels) = mnist.load_data()
    train_data, test_data = train_data / 255.0, test_data / 255.0

    base_model = generate_basic_model() # 기본 모델
    bn_model = generate_batch_norm_model() # 배치 정규화를 적용한 모델

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

    base_model.summary()
    bn_model.summary()
    
    base_history = base_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)
    bn_history = bn_model.fit(train_data, train_labels, epochs=20, batch_size=500, validation_data=(test_data, test_labels), verbose=0)

    score_basic = base_model.evaluate(test_data, test_labels)
    score_bn = bn_model.evaluate(test_data, test_labels)

    print('\naccuracy_basic : ', score_basic[-1])
    print('\naccuracy_bn : ', score_bn[-1])

    Visulaize([('Basic', base_history), ('Batch Normalization', bn_history)])

    return base_history, bn_history

if __name__ == "__main__":
    main()

 

 

[ 코드 실행 결과 ] 

• batch norm을 사용한 모델의 loss 가 더 작음
• base model은 epoch가 증가함에 따라 loss가 감소하기도 하고, 증가하기도 함 -> 학습이 안정적으로 이루어지지 않음
• batch norm model은 epoch가 증가함에 따라 loss가 감소하는 경향을 보임 -> 학습이 안정적으로 이루어짐