[라이트 머신러닝] Session 5. 퍼셉트론의 메가 진화와 경사하강법!

728x90

이전 세션 두 개에서 우리는 퍼셉트론 함수를 학습하고 왔습니다. 기억하시나요? 기억이 안 나신다면 앞 두 개 글을 보고 오시는 것을 추천드립니다. 제가 공부하는만큼 앞 글들이 주기적으로 수정될 수 있음을 알아주시길 바랍니다ㅜㅜ

https://dnai-deny.tistory.com/5 https://dnai-deny.tistory.com/6

이번 세션에서는 퍼셉트론 알고리즘의 진화버전인 아달린과 머신러닝에 있어서 매우 중요한 개념인 경사하강법에 대해 알아보도록 하겠습니다.

1. 적응형 선형 뉴런, 아달린

아달린은 단일 층 신경망의 또 다른 종류입니다. 버나드 위드로우와 테드 호프가 개발한 알고리즘이죠. 제목에서 보이듯 퍼셉트론이 진화한 형태라고 할 수 있습니다. 왜냐하면, 아달린에서는 비용 함수(cost function)이라는 주요 개념이 정의되었기 때문입니다.

아달린과 퍼셉트론의 차이점은 가중치 업데이트 방식에 있습니다. 아달린은 단위 계단 함수 대신 선형 활성화 함수를 사용합니다. 이 함수에서는 최종 입력과 동일한 함수를 선형 활성화 함수로 사용합니다. 바로 아래 수식이죠.

가중치 학습에는 선형 활성화 함수가 사용되지만 최종 예측을 만드는 데에는 여전히 임계함수를 사용합니다. 두 알고리즘의 주요한 차이점은 아래 그림에서 확인할 수 있습니다. 아달린은 정답 클래스 레이블과 선형 활성화 함수의 실수 출력 값을 비교해 가중치를 업데이트하지만 퍼셉트론은 정답 클래스 레이블과 예측 클래스 레이블을 비교한다는 점이 다릅니다.

2. 경사하강법으로 비용함수 최소화하기

지도학습의 핵심 구성 요소 중 하나는 최적화를 위해 정의된 목적함수입니다. 최소화가 목적인 비용함수가 종종 목적함수가 되기도 한다고 합니다. 아달린은 계산괸 출력과 진짜 클래스 레이블 사이의 오차의 제곱을 합한 값으로 비용함수 J를 정의합니다.

이 함수의 장점은 바로 볼록함수라는 점입니다. 당연히 볼록함수이기 때문에 미분이 가능하고, 미분해서 구해진 그 기울기를 경사라고 부릅니다. 이것을 이용한 경사 하강법(gradient descent)를 적용하여 비용함수를 최소화하는 가중치를 찾을 수 있습니다.

그림 4에서는 가중치에 따른 경사가 지역 혹은 전역 최솟값에 도달할 때까지 언덕을 내려오는 것으로 보여주고 있습니다. 학습을 반복하면서 경사가 완만해지는 쪽으로 진행하게 되고, 진행 크기는 기울기와 학습률(learning rate)로 결정합니다.

이때 w := w + △w 는 동일한데, △w = -n▽J(w) 로 가중치 변화량이 정의됩니다. 학습률 n을 음수의 그래디언트에 곱한 것이죠. 비용 함수의 그래디언트를 계산하려면 각 가중치 wj에 대한 편도 함수를 계산해야합니다.

따라서 가중치의 엽데이트 공식을 아래와 같이 쓸 수 있습니다.

여기까지 보면 퍼셉트론과 거의 동일하게 보이지만, ∮(z(i)) 는 정수 클래스 레이블이 아니고 실수라는 점이 다릅니다. 그리고 가가 샘플마다 가중치를 업데이트 하는 것이 아닌 모든 샘플을 기반으로 가중치 업데이트를 계산합니다. 이 방식을 배치 경사 하강법(batch gradient descent)이라고 합니다.

3. 파이썬으로 아달린 구현하기

class AdalineGD(object):
    """적응형 선형 뉴런 분류기

    매개변수
    ------------
    eta : float
      학습률 (0.0과 1.0 사이)
    n_iter : int
      훈련 데이터셋 반복 횟수
    random_state : int
      가중치 무작위 초기화를 위한 난수 생성기 시드

    속성
    -----------
    w_ : 1d-array
      학습된 가중치
    cost_ : list
      에포크마다 누적된 비용 함수의 제곱합

    """
    def __init__(self, eta=0.01, n_iter=50, random_state=1):
        self.eta = eta
        self.n_iter = n_iter
        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

        """
        rgen = np.random.RandomState(self.random_state)
        self.w_ = rgen.normal(loc=0.0, scale=0.01, size=1 + X.shape[1])
        self.cost_ = []

        for i in range(self.n_iter):
            net_input = self.net_input(X)
            # Please note that the "activation" method has no effect
            # in the code since it is simply an identity function. We
            # could write `output = self.net_input(X)` directly instead.
            # The purpose of the activation is more conceptual, i.e.,  
            # in the case of logistic regression (as we will see later), 
            # we could change it to
            # a sigmoid function to implement a logistic regression classifier.
            output = self.activation(net_input)
            errors = (y - output)
            self.w_[1:] += self.eta * X.T.dot(errors)
            self.w_[0] += self.eta * errors.sum()
            cost = (errors**2).sum() / 2.0
            self.cost_.append(cost)
        return self

    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)

퍼셉트론과 다른 점이 보이시나요? fit 메소드 안 반복문에 self.w_[1:] += self.eta * X.T.dot(errors)와 self.w_[0] * errors.sum()이 다르죠. 0번째 가중치인 절편이 오차합과 학습률의 곱이고, 그 이외의 부분에서는 X.T.dot(errors)는 특성 오차 벡터 간의 행렬과 벡터의 곱을 학습률에 곱한 값입니다.

또 다른 점은 activation 메서드인데, 이것은 그저 단순한 항등 함수이기 때문에 별다른 영향을 미치지 않습니다.

실제 모델에서는 최적으로 수렴하는 좋은 학습률(learning rate)를 찾기 위해 여러 번 실험을 거쳐야합니다. 학습률 0.01과 0.0001을 비교해보도록 하겠습니다.

fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))

ada1 = AdalineGD(n_iter=10, eta=0.01).fit(X, y)
ax[0].plot(range(1, len(ada1.cost_) + 1), np.log10(ada1.cost_), marker='o')
ax[0].set_xlabel('Epochs')
ax[0].set_ylabel('log(Sum-squared-error)')
ax[0].set_title('Adaline - Learning rate 0.01')

ada2 = AdalineGD(n_iter=10, eta=0.0001).fit(X, y)
ax[1].plot(range(1, len(ada2.cost_) + 1), ada2.cost_, marker='o')
ax[1].set_xlabel('Epochs')
ax[1].set_ylabel('Sum-squared-error')
ax[1].set_title('Adaline - Learning rate 0.0001')

plt.show()

왼쪽과 오른쪽을 비교해보면, 학습률이 0.01인 경우에 epoch이 늘어남에도 불구하고 오히려 오차가 계속 늘어나는 것을 확인할 수 있습니다. 이는 가중치를 업데이트할 때 학습률이 너무 커서 경사하강을 하던 중에 기울기가 최소가 되는 값을 찾지 못하고 튀기 때문입니다. 오른쪽의 경우는 오히려 학습률이 너무 작아서 최솟값에 수렴하기 위해서는 아주 많은 epoch이 필요합니다. 아래 그림 8이 글로 설명한 내용을 그림으로 설명해주고 있습니다.

4. 경사 하강법 성능 강화하기

모델에서 최적의 성능을 위해 필요한 것은 좋은 모델만이 아닙니다. 두 번째 세션에 나왔던 데이터 전처리를 기억하시나요? (https://dnai-deny.tistory.com/3) 지금 볼 내용은 최적의 성능을 위해 특성 스케일, 데이터 전처리에 발끝을 담가볼 수 있는 표준화(standardization) 입니다. 이 기술은 데이터에 정규분포의 성질을 부여해 경사 하강법 학습이 빠르게 수렴할 수 있도록 만들어줍니다. 이 과정은 정규분포와 같이 표준을 0에 맞추고 표준편차를 1로 만듭니다. j번째 특성을 표준화하는 방법을 아래 수식에서 확인할 수 있습니다.

모든 샘플에서 평균을 뺀 것을 표준편차로 나누면 됩니다. xj는 모든 샘플의 j번째 특성을 포함한 백터를 의미합니다. 처리를 거치게 되면 아래 그림 10에서 보이는 것처럼 더 적은 과정으로 빠르게 최적의 해결방법을 찾을 수 있죠.

아래 코드를 이용해서 간단하게 표준화를 할 수 있습니다. numpy 내장 함수 mean과 std가 제공하는 기능 덕분이죠.

# 특성을 표준화합니다.
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()

ada = AdalineGD(n_iter=15, eta=0.01)
ada.fit(X_std, y)

plot_decision_regions(X_std, y, classifier=ada)
plt.title('Adaline - Gradient Descent')
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.legend(loc='upper left')
plt.tight_layout()
plt.show()

plt.plot(range(1, len(ada.cost_) + 1), ada.cost_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('Sum-squared-error')

plt.tight_layout()
plt.show()

표준화가 끝나면 결정경계 그래프와 비용이 감소되는 cost function 그래프를 확인할 수 있습니다. 우리는 학습률을 0.01로 사용하고, 특성을 표준화하니 확실히 모델이 수렴하는 것을 볼 수 있죠. 하지만 모든 샘플이 완벽하게 분류되더라도 Sum-Squared error의 값이 0이 되지는 않습니다.

5. 대규모 머신러닝과 확률적인 경사하강법

4와 같은 방법을 다른 말로 배치 경사 하강법이라고 합니다. 하지만 매우 많은 양의 데이터를 다뤄야하는 경우에는 배치 경사 하강법을 이용하면 계산 비용이 상당히 높아집니다. 계산해야할 거리가 많아지기 때문이죠. 가중치가 업데이트 될 때마다 전체 데이터를 다시 학습해야하기 때문입니다.

이 문제를 효율적으로 해결하기 위해서 확률적 경사 하강법(stochastic gradient descent)가 등장합니다. 아래 수식 두 개를 비교해보면서 이야기하도록 하겠습니다.

위 수식의 시그마 기호가 보이시나요? 첫 번째 수식은 배치 경사 하강법을 보여주고 있는데, 시그마 기호를 통해서 전체 데이터 셋 x에 대해서 누적된 오차 합을 기반으로 가중치를 업데이트 합니다. 반면에 두 번째 수식, 확률적 경사 하강법에서는 각 훈련 샘플에 대해서 조금씩 가중치를 업데이트 합니다.

확률적 경사 하강법은 일반 경사 하강법보다 훨씬 자주 가중치를 업데이트 해주기 때문에 수렴 속도가 훨씬 빠릅니다. 다만 오차의 궤적(그래프)는 훨씬 어지러운 형태가 되죠. 확률적 경사 하강법에서 좋은 결과를 얻기 위해서는 훈련 샘플의 순서를 랜덤하게, 그리고 에폭마다 훈련세트를 섞는 것이 좋습니다.

확률적 경사 하강법은 또 온라인 학습으로 사용할 수 있다는 장점이 있습니다. 온라인 학습에서 머신러닝 모델은 새로운 데이터가 도착하면 계속해서 훈련됩니다. 특히 온라인 학습은 많은 양의 데이터를 다뤄야할 때 유용합니다. 저장 공간에 제약이 있다면 모델을 업데이트하고 데이터를 버리는 것도 가능하고, 실시간으로 업데이트되는 변화에 즉시 적응할 수 있습니다.

이미 경사 하강법을 구현했기 때문에 약간의 수정을 통해 확률적 경사 하강법을 만들 수 있습니다.

class AdalineSGD(object):
    """ADAptive LInear NEuron 분류기

    Parameters
    ------------
    eta : float
      학습률 (0.0과 1.0 사이)
    n_iter : int
      훈련 데이터셋 반복 횟수
    shuffle : bool (default: True)
      True로 설정하면 같은 반복이 되지 않도록 에포크마다 훈련 데이터를 섞습니다
    random_state : int
      가중치 무작위 초기화를 위한 난수 생성기 시드

    Attributes
    -----------
    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):
        """훈련 데이터 학습

        Parameters
        ----------
        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)

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.tight_layout()
plt.show()

plt.plot(range(1, len(ada.cost_) + 1), ada.cost_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('Average Cost')

plt.tight_layout()
plt.show()

위 코드에서 fit 메서드 안에서 각 훈련 샘플마다 가중치를 업데이트 할 겁니다. 그리고 partial_fit 메서드를 구현해서 가중치를 초기화하지 않도록 해서 온라인 학습에서 사용하도록 합니다. 마지막으로 각 에폭마다 평균 비용을 계산하고 에포크가 변하기 전에 훈련샘플을 섞습니다.

아달린 분류가에서 사용하는 _shuffle 메서드는 np.random 모듈의 permutation 함수로 0부터 100사이의 랜덤 숫자 시퀀스를 생성해 샘플을 섞는 인덱스로 사용합니다. 그리고 fit 메서드로 훈련하고, plot_decision_regions로 그래프를 그립니다.

학습곡선 그래프에서 확실히 평균 비용(cost)가 빠르게 감소합니다. 에포크가 어느정도 지나면 최종 결정 경계는 배치 하강법과 거의 비슷합니다. 여기서 온라인 학습 방식으로 훈련하기 위해서는 각각의 샘플에 아래와 같이 partial_fit 메서드를 호출합니다.

ada.partial_fit(X_std[0,:], y[0])

이번 3, 4, 5세션에서는 기초적 선형 분류기인 퍼셉트론과 아달린 알고리즘을 구현해보았습니다. 또, 아주 중요한 경사하강법도 배웠죠. 이를 통해 여러분은 간단한 분류기를 구현하는 방법을 알게 되셨습니다. 축하드려요! 이번 구현에 사용한 객체 지향 방식이 이후 사이킷런을 이해하는데에도 도움이 되실 겁니다.

다음 세션부터는 로지스틱 회귀를 다루게 됩니다. 사이킷런을 통해서 퍼셉트론을 구현하는 방법도 살펴볼 거고, 중요한 함수인 시그모이드 함수도 배우게 될 겁니다. 모두들 수고하셨고, 항상 말씀드리다시피 모든 코드를 이해하실 필요는 없지만 주요한 함수들은 꼭 알아두세요! 다음 시간에 뵙겠습니다!