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

 이전 포스트에서 모델을 생성해보고, 생성된 모델의 정보를 살펴보았다. 이번 포스트에서는 모델을 컴파일에 대해 학습해보도록 하겠다.

모델 컴파일

0. 이전 코드 정리

# Import Module
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

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

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)

# 모델 생성
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))

1. 모델 컴파일

# 모델 컴파일
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

• 모델을 어떤 방식으로 학습시킬지 결정하는 과정이다.
• 모델 컴파일에서 지정하는 주요 항목은 최적화 방법인 옵티마이저(Optimizer)와 손실 함수(loss)이다.
• 추가로, 훈련과 평가 시 계산할 지표를 추가로 지정할 수 있다(metrics).

2. Optimizer

• 최적화 방법인 Optimizer는 경사 하강법(GD)을 어떤 방법으로 사용할지를 정한다고 생각하면 된다.
• Optimizer를 정하는 이유는 Optimizer 방법을 무엇을 선택하느냐에 따라 최적해를 찾아가는 속도가 크게 달라진다.
• 경사 하강법(GD)은 기본적으로 4가지 문제가 존재하며, 이는 다음과 같다.
  (좀 더 자세히 알고 싶은 사람은 다음 포스팅: "머신러닝-6.1. 최적화(2)-경사하강법의 한계점"을 참고하기 바란다.)

1. 데이터가 많아질수록 계산량이 증가함
2. Local minimum 문제
3. Plateau 문제
4. Zigzag 문제

• 위 문제들을 간단하게 말하면, 경사 하강법이 가진 구조적 단점으로 인해, 최적해를 제대로 찾아가지 못하거나, 찾는 속도가 늦어진다는 것이다.
• 이를 해결하기 위해선 데이터셋에 맞는 Optimizer를 사용해야 하며, 단순하게 가장 많이 사용하는 Optimizer가 Adam이므로, Adam을 사용하는 것은 그다지 추천할 수 없는 방법이다.

# Optimizer는
model.compile(optimizer = "Adam",
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

• 위 방법으로 Optimizer를 하게 되면, 코드는 단순하지만, 학습률, Momentum과 같은 Optimizer 고유의 하이퍼 파라미터를 수정할 수 없다. 

# 모델 컴파일
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

• 위 방법으로 Optimizer를 잡아줘야, 각종 하이퍼 파라미터를 수정할 수 있다.
• keras.optimizers. 뒤에 원하는 optimizer를 넣으면 된다.

3. Optimizer의 종류

• Optimizer는 기본적으로 SGD를 기반으로 하므로, 확률적 추출을 통해 경사 하강법을 시행한다.
• Optimizer는 크게 Momentum 방식(관성 부여)과 Adagrad 방식(상황에 따른 이동 거리 조정)으로 나뉜다.
• Momentum 방식과 Adagrad 방식을 하나로 합친 방법이 Adam과 Nadam이다.
• 다른 Optimizer를 사용함으로 인해 최적해를 찾아가는 방법이 달라지게 되고, 그로 인해 학습 속도가 바뀌게 된다.
• Local minimum 문제는 무작위 가중치 초기화로 인해 발생할 가능성이 매우 낮다.
• 단순하게 Adam만 고집하지 말고, 여러 Optimizer를 사용하길 바란다.
• Optimizer와 경사하강법에 대한 상세한 설명을 보고자 한다면, 다음 포스트를 참고하기 바란다.
• 참고: "머신러닝-6.0. 최적화(1)-손실함수와 경사하강법"

Optimizer별 최적해 수렴 속도 차이

• 별이 최적해라고 할 때, 각종 Optimizer가 최적해를 찾아가는 방식을 시각화한 것이다.
• 해가 n개이므로, 파라미터는 평면이 아니라 입체이며, 이 입체를 이해하기 쉽도록 2차원 등고선으로 그린 것이다.

• 말안장 그림이라 하여, 3차원으로 최적해를 찾아가는 과정을 그린 것이다.
• SGD는 지역 최솟값(Local minimum)에 빠져 최적해를 찾아가지 못하였다.
• 위 두 그림의 출처는 다음과 같으며, 보다 자세한 설명을 보고 싶은 경우 해당 사이트를 참고하기 바란다.
• ruder.io/optimizing-gradient-descent/

4. loss

• 손실 함수는 데이터셋과 라벨 데이터의 생김새에 따라 사용하는 방법이 달라진다.
• 기본적으로 연속형 데이터를 대상으로는 제곱 오차(SE)에서 파생된 기법을 사용하며, 범주형 데이터를 대상으로는 크로스 엔트로피 오차(CEE)에서 파생된 기법을 사용한다.
• 클래스의 수나 Label의 형태에 따라 사용하는 방법이 조금씩 달라진다.
• 가장 많이 사용되는 손실 함수의 사용 예는 다음과 같다.

• 위 표는 기본적인 손실 함수에 대한 것이므로, 성능이 나오지 않는다면, 다른 손실 함수를 사용할 필요가 있다.
• 위 손실함수에 대한 상세한 설명을 보고자 한다면, 아래 포스팅을 참고하기 바란다.
• 참고: "머신러닝-5.0. 손실함수(1)-제곱오차(SE)와 오차제곱합(SSE)
• 모든 손실 함수의 목록은 아래 주소에 있으므로 필요시, 참고하기 바란다.
• www.tensorflow.org/api_docs/python/tf/keras/losses

5. metrics

• 평가 기준으로 모델의 학습에는 영향을 미치지 않으나, 학습 중에 제대로 학습되고 있는지를 볼 수 있다.
• metrics에 무엇을 넣느냐에 따라 학습 시, 히스토리에 나오는 출력 Log가 달라지게 된다.
• 일반적으로 accuracy 즉, 정확도가 사용된다.
• 이 역시 데이터 셋에 따라 바뀌며, 손실 함수와 유사한 것을 선택하면 된다.
• metrics에 사용하는 하이퍼 파라미터는 아래 사이트를 참고하기 바란다.
• keras.io/api/metrics/

 지금까지 Compile을 하는 방법에 대해 알아보았다. Compile은 일반적으로 사용하는 기법을 사용하여도 큰 차이를 느끼지 못할 수도 있으나, 제대로 모델을 학습시키기 위해선 데이터의 형태에 맞는 하이퍼 파라미터를 잡아주는 것이 좋다.

 다음 포스트에서는 모델을 실제로 학습시켜보고, 그 Log를 시각화하여 최적의 Epochs을 선택하는 방법에 대해 학습해보겠다.

 이전 포스트에서 확률적 경사 하강법(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

 이전 포스트에서는 학습 단위에 대한 단어인 에포크(Epoch), 배치 크기(Batch size), 이터레이션(Iteration)에 대해 알아보았다. 이번 포스트에서 알아볼 확률적 경사 하강법(SGD)의 키는 배치 크기와 랜덤 추출이다.

 경사 하강법에 다른 식을 붙이지 않고 바로 사용하는 방법은 크게 두 가지인 배치 경사 하강법(BGD)과 확률적 경사 하강법(SGD)이 있는데, 이 둘은 손실 함수의 기울기 계산에 사용되는 데이터 셋의 규모만 제외하고 같다.

 중요한 것은 손실 함수의 경사를 구하는 대상이다!

1. 배치 경사 하강법(Batch Gradient Descent, BGD)

• 배치 경사 하강법(BGD)은 경사 하강법의 손실 함수의 기울기 계산에 전체 학습 데이터셋의 크기와 동일하게 잡는 방법이다.
• 즉, 경사 하강법 대상이 배치 크기와 동일하다는 것이다.
• 데이터셋 모두를 대상으로 하다 보니 파라미터가 한번 이동할 때마다, 계산해야 할 값이 지나치게 많으므로, 계산 시간도 엄청 길어지고, 소모되는 메모리도 엄청나다.
• mini batch 안 모든 데이터를 대상으로 경사 하강법을 실시하므로, 안정적으로 수렴한다.

• 안정적으로 수렴하므로, 수렴까지 발생하는 총 파라미터 업데이트 수는 매우 적다.
• 안정적으로 수렴하는 것은 좋으나, 안정적으로 움직이기 때문에 지역 최소해(Local Minimum)에 빠지더라도 안정적으로 움직이므로 빠져나오기 힘들다. 즉, Local Optima(minimum) 문제가 발생할 가능성이 높다.
• 학습 데이터셋이 커지면 커질수록 시간과 리소스 소모가 지나치게 크다.

2. 확률적 경사 하강법(Stochastic Gradient Descent, SGD)

• 전체 훈련 데이터셋을 대상으로 학습하는 것은 한정된 리소스를 가지고 있는 우리의 분석 환경에서 매우 비효율적이며, 파라미터 업데이트 수가 적다는 것은 랜덤 하게 뽑힌 시작 위치의 가중치 수도 적으므로, Local minimum 현상이 발생할 확률도 높다는 것이다.
• 그래서 나온 방법이 학습 데이터셋에서 무작위로 한 개의 샘플 데이터 셋을 추출하고, 그 샘플에 대해서만 기울기를 계산하는 것이다.
• 샘플 데이터 셋에 대해서만 경사(Gradient)를 계산하므로, 매 반복에서 다뤄야 할 데이터 수가 매우 적어, 학습 속도가 매우 빠르다.
• 하나의 샘플만 대상으로 경사를 계산하므로, 메모리 소모량이 매우 낮으며, 매우 큰 훈련 데이터 셋이라 할지라도 학습 가능하다.
• 그러나, 무작위로 추출된 샘플에 대해서 경사를 구하므로, 배치 경사 하강법보다 훨씬 불안정하게 움직인다.

• 손실 함수가 최솟값에 다다를 때까지 위아래로 요동치며 움직이다 보니, 학습이 진행되다 보면, 최적해에 매우 근접하게 움직이긴 하겠으나, 최적해(Global minimum)에 정확히 도달하지 못할 가능성이 있다.
• 그러나, 이렇게 요동치며 움직이므로, 지역 최솟값(Local minimum)에 빠진 다할지라도, 지역 최솟값에서 쉽게 빠져나올 수 있으며, 그로 인해 전역 최솟값(Global minimum)을 찾을 가능성이 BGD에 비해 더 높다.
• 즉, 확률적 경사 하강법(SGD)은 속도가 매우 빠르고 메모리를 적게 먹는다는 장점이 있으나, 경사를 구할 때, 무작위성을 띄므로 지역 최솟값에서 탈출하기 쉬우나, 전역 최솟값에 다다르기 힘들다는 단점을 가지고 있다.
• 이 문제를 해결하기 미니 배치 경사 하강법(mini-Batch gradient descent)이 등장하였다.

학습률 스케줄(Learning rate schedule)

• 전역 최솟값에 도달하기 어렵다는 문제를 해결하기 위한 방법으로, 학습률을 천천히 줄여 전역 최솟값에 다다르게 하는 방법이 있다.
• 학습률은 작아질수록 이동하는 양이 줄어들기 때문에 전역 최솟값에 안정적으로 수렴할 수 있다.
• 만약 학습률이 너무 급격하게 감소하면, Local Optima 문제나 Plateau 현상이 발생할 가능성이 높아진다.
• 그렇다고 학습률을 너무 천천히 줄이면 최적해 주변을 맴돌 수 있다.

3. 미니 배치 경사 하강법(mini-Batch gradient descent)

• 앞서 이야기한 배치 경사 하강법(BGD)나 확률적 경사 하강법(SGD)은 모두 배치 크기가 학습 데이터 셋 크기와 동일하였으나, 미니 배치 경사 하강법은 배치 크기를 줄이고, 확률적 경사 하강법을 사용하는 기법이다.
• 예를 들어, 학습 데이터가 1000개고, batch size를 100으로 잡았다고 할 때, 총 10개의 mini batch가 나오게 된다. 이 mini batch 하나당 한 번씩 SGD를 진행하므로, 1 epoch당 총 10번의 SGD를 진행한다고 할 수 있다.
• 일반적으로 우리가 부르는 확률적 경사 하강법(SGD)은 실제론 미니 배치 경사 하강법(mini-BGD)이므로, 지금까지 학습했던 차이들은 기억하되, 앞으로 SGD를 말하면, 미니 배치 경사 하강법을 떠올리면 된다.

• 미니 배치 경사 하강법은 앞서 이야기했던, 전체 데이터셋을 대상으로 한 SGD보다 파라미터 공간에서 Shooting이 줄어들게 되는데, 이는 한 미니 배치의 손실 값 평균에 대해 경사 하강을 진행하기 때문이다.
• 그로 인해, 최적해에 더 가까이 도달할 수 있으나, Local optima 현상이 발생할 수 있다. 그러나, 앞서 말했듯 Local optima 문제는 무수히 많은 임의의 파라미터로부터 시작되면, 해결되는 문제이며, 학습 속도가 빠른 SGD의 장점을 사용하여, 학습량을 늘리면 해결되는 문제다.
• 배치 크기는 총 학습 데이터셋의 크기를 배치 크기로 나눴을 때, 딱 떨어지는 크기로 하는 것이 좋다.
• 만약, 1050개의 데이터에 대하여 100개로 배치 크기를 나누면, 마지막 50개 데이터셋에 대해 과도한 평가를 할 수 있기 때문이다.
• 그러나, 만약 배치 크기로 나누기 애매한 경우라면, 예를 들어 총 학습 데이터 셋이 1,000,050개가 있고, 배치 크기를 1,000개로 나누고 싶은 경우라면, 나머지인 50개는 버리도록 하자(물론 완전 무작위 하게 50개를 선택해서 버려야 한다.).

  지금까지 확률적 경사 하강법(SGD)에 대해 알아보았다. 본래의 SGD는 "배치 크기 = 학습 데이터 셋 크기"이지만, 일반적으로 통용되는 SGD는 "배치 크기 < 학습 데이터 셋 크기"인 미니 배치를 만들어 학습시키는 미니 배치 경사 하강법이다. 

 경사 하강법의 파이썬 코드화는 경사 하강법 함수 자체는 단순하지만, 학습에서 발생하는 모든 알고리즘이 복합적으로 작동하므로, 코드화시키는 것은 시간 낭비로 판단된다. Optimizer 파트부턴 그 개념과 특징을 이해하고, 텐서플로우로 학습을 해보도록 하자.

 다음 포스트에서는 경사 하강법의 한계점을 보완하기 위한 시도 중 하나인 모멘텀(Momentum)에 대해 학습해보도록 하겠다.

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

경사 하강법의 한계점

• 앞서 손실함수를 기반으로 경사 하강법의 개형을 그려보았으나, 실제로는 저렇게 깔끔한 이차 함수 형태를 그리지 않는다.
• 퍼셉트론의 공식이 활성화 함수를 타게 되면, 손실 함수의 모습은 거시적인 관점에서 봤을 때는 최적해를 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)이 있는 영역을 건너 뛰어 지역 최솟값에서 수렴할 수도 있다.
  (이 부분은 다음 포스트에서 세세하게 다루도록 하겠다.)

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

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

신경망 학습

 이전 포스트에서 다층 퍼셉트론에서 데이터가 흐르는 것에 대해 학습해보았고, 그 과정에서 석연치 않은 부분이 하나 있었다.

 바로 가중치가 이미 주어졌다는 것인데, 가중치를 저렇게 속 편하게 알고 있는 경우는 있을 수가 없으며, 그렇다고 가중치를 하나하나 찾아내는 것은 불가능에 가깝다.

 한 층의 노드 수는 입력되는 텐서의 크기이기 때문에 한층에 수백 수 천 개에 달하는 노드가 존재할 수 있으며, 그러한 층이 무수히 많이 쌓이게 된다면, 각 노드에서 다음 층의 노드로 연결되는 가중치 엣지의 수가 셀 수 없이 많아지므로, 일일이 이를 구해 입력된 데이터가 내가 전혀 알지 못하는 분류대로 나눠지게 만드는 것이 가능할 리가 없다.

 애초에 딥러닝이라는 기술은 엄청난 양의 데이터만 있고 거기에 숨겨진 함수 즉, 규칙을 모를 때 사용하는 것이며, 이 데이터 속에 막연한 현상이 숨어있을 것이라 추측하고 있는 상황에서, 어떻게 그 규칙을 찾아낼지도 모르고, 수많은 이론을 조합해 만들어낸 알고리즘이 정확할지도 모르기 때문에 사용하는 것이다.

 즉, 딥러닝은 순수하게 데이터만 가지고, 내가 분류하고자 하는 바에 가장 적합한 레이어를 쌓아 만들어낸 머신러닝 알고리즘에 데이터를 학습시켜, 최적의 가중치를 알아서 찾아내 모델을 만들어내고, 여기에 새로운 데이터들을 넣어 분류하는 것이다. 때문에 딥러닝을 데이터 주도 학습이라고도 한다.

 그렇다면, 어떻게 최적의 가중치를 찾을 수 있을까?

1. 손실 함수(Loss Function)

• 자, 당신에게 1억 장에 달하는 고양이 사진과 강아지 사진이 있다고 생각해보자.
• 당신은 고양이와 강아지를 구분할 수 있지만, 이 사진의 양이 지나치게 많아, 이걸 일일이 고양이와 강아지로 구분하는 것은 불가능하다.
• 그렇다면, 당신이 만 장의 사진에 대해 고양이는 0, 강아지는 1이라 라벨(Label)을 붙였고(실제 값), 컴퓨터가 사진에서 찾아낸 특징을 기반으로 분류해낸 것(예측값)의 차이가 작다면, 최적의 가중치를 찾았다고 할 수 있지 않을까?
• 바로 이 실제값과 예측값의 오차가 손실함수(Loss Function)다.
• 오차가 클수록 손실 함수의 값이 커지고, 오차가 작아질수록 손실 함수의 값이 작아진다.
• 즉, 이 손실 함수가 0에 가깝게 줄어들게 만드는 것이 학습의 목표라고 할 수 있다.
• 손실함수는 이 오차를 비용이라고 판단하여, 비용함수(Cost Funtion)라고도 한다.

2. 최적화(Optimizer)

• 자, 당신은 이제 손실 함수의 존재를 알았다. 그리고 손실함수를 이용해서 최적의 가중치를 찾을 수 있다고 했다.
• 그렇다면, 어떻게 최적의 가중치를 찾아갈 수 있을까?
• 먼저, 각 층에 임의의 가중치를 설정한다(보통 가중치는 0, 편향은 1로 설정한다.)
• 학습 데이터셋을 모델에 통과시켜, 출력값을 계산한다.
• 출력 값과 실제 값이 허용 오차 이내가 되도록 각층의 가중치를 업데이트한다.
• 이 과정에서 출력 값과 실제값의 차이를 나타내는 지표로 사용되는 것이 손실함수다.
• 손실함수를 최소화시키기 위해, 가중치의 미분(기울기)을 계산하고, 그 미분 값을 기반으로 가장 적합한 가중치 값을 갱신하는 과정을 반복한다.
• 이 기울기를 기반으로 최적의 미분 값을 찾아가는 방식을 최적화(Optimizer)라고 하며, 그 유명한 경사하강법(Gradient Descent)이 여기에 해당한다.
• 참고로 손실함수와 유사한 정확도(Accuracy)라는 것이 있는데, 손실함수는 연속적으로 변해 미분 가능하지만, 정확도는 가중치의 변화에 둔감하고, 불연속적으로 변해 미분이 불가능하여, 손실함수를 지표로 학습을 해나간다.
  (정확도는 출력된 값과 실제값이 일치하는 비율로, 나중에 텐서플로우로 실제 학습과 예측을 해보는 과정에서 다루도록 하겠다.)

3. 역전파(Back Propagation)

• 당신은 최적화를 통해 최적의 가중치를 찾을 수 있다. 그렇다면, 어떻게 이 것을 모델에 반영해줄 것인가?
• 역전파는 최적화를 효율적으로 할 수 있게 해주는 알고리즘으로, 순전파와 반대방향으로 실제값과 예측값의 오차를 전파하여, 가중치를 업데이트하고 최적의 학습 결과를 찾아간다.
• 먼저 순전파를 통해 출력층에서 오차를 계산하고, 이를 다시 입력층으로 역전파시켜 가중치를 업데이트하고, 다시 입력값을 넣어 새로운 오차를 계산하고, 이를 또 역전파해서 가중치를 업데이트하는 것을 반복한다.
• 즉, "순전파 > 역전파 > 가중치 업데이트 > 순전파 > 역전파 > 가중치 업데이트..."의 과정으로 학습은 이루어진다.

4.  정리해보면!

• 손실함수(Loss Function): 가중치가 얼마나 잘 만들어졌는지를 확인하는 방법
• 최적화(Optimizer): 손실함수를 기반으로 최적의 가중치를 찾는 방법
• 역전파(Back Propagation): 가중치를 효율적으로 업데이트 하는 방법
• 이 3가지 방법이 서로 앙상블을 이뤄 신경망에서 가장 적합한 가중치를 찾아낸다.

 지금까지 인공신경망을 학습시키는 3가지 개념에 대해 학습해보았다. 각 기법은 포스팅 하나로 설명하기엔 그 양이 활성화 함수 때처럼 만만치 않으므로, 하나하나 상세하게 다뤄보도록 하겠다.

 다음 포스트에서는 가장 대표적인 손실함수인 오차제곱합(Sum of Squareds for error, SSE)에 대해 학습해보도록 하겠다.