적응형 선형 뉴런 Adaline, 경사하강법

적응형 선형 뉴런(Adaptive Linear Neuron)은 퍼셉트론과 다르게 임계함수를 통과하기 전에 오차를 구해서 가중치 업데이트를 하는 알고리즘이다.

활성화 함수는 입력을 그대로 내보내는 항등함수이다.

가중치 업데이트 값을 찾는 방법으로는 경사하강법을 사용한다.

 

### 경사하강법 ###

제곱오차합을 통해 비용함수 J를 정의하고 J의 기울기가 최소가 되는 지점을 탐색하면서 오차를 구하고 가중치를 업데이트한다.

그레디언트(J의 기울기) 반대방향으로 가중치를 업데이트 하면서 비용함수(J)를 줄인다.

비용함수가 크면 클 수록 오차가 많은 것이다. 따라서 가중치를 크게 업데이트한다.

 

### 아달린 클래스 ###

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
 
df = pd.read_csv("https://raw.githubusercontent.com/jmnote/zdata/master/R/iris.csv")
 
class AdalineGD(object):
    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 : 2차원배열 훈련데이터, y: 1차원배열 타깃 값
        
        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)
            output = self.activation(net_input)
            errors = y - output
            self.w_[1:] += self.eta * X.T.dot(errors) # 절편을 제외한 나머지 구하기
            self.w_[0] += self.eta * errors.sum() # 절편구하기
            # 가중치 W를 계산하는 알고리즘
            
            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]
    # 최종입력 net_input 계산 메소드
    # 절편과 나머지 입력에 가중치를 곱해서 최종입력을 구함
    
    def activation(slef, X):
        return X
    # 선형 활성화 계산 메소드 
    # 아달린에서는 입력을 그대로 사용하는 항등함수 모양임
    
    def predict(self, X):
        return np.where((self.activation(self.net_input(X))) >= 0.0, 1, -1)
    # 예측 메소드
    # 최종입력이 활성화 함수를 지난 결과가 0보다 크면 1, 작으면 -1으로 예측

import matplotlib.pyplot as plt
 
y = df.iloc[0:100, 4].values
y = np.where(y == 'setosa', -1, 1)
X = df.iloc[0:100, [0, 2]].values
# 예측할 데이터셋 준비
# X : 입력 데이터, y : 예측 데이터
 
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10,4))
 
ada1 = AdalineGD(n_iter=10, eta=0.01).fit(X, y)
# 학습횟수 10번, 학습률 0.01인 아달린 객체를 만들고 X, y로 학습시킴.
 
ax[0].plot(range(1, len(ada1.cost_)+1),
           np.log10(ada1.cost_), marker='o')
# 에포크에 따른 오차를 로그함수 형태로 그림(오차가 너무커서 로그함수 그래프 이용)
 
ada2 = AdalineGD(n_iter=10, eta=0.0001).fit(X, y)
# 학습횟수 10번, 학습률 0.0001인 아달린 객체를 만들고 X, y로 학습시킴.
 
ax[1].plot(range(1, len(ada2.cost_)+1),
           ada2.cost_, marker='o')
# 에포크에 따른 오차를 그래프로 그림
 
ax[0].set_xlabel('Epochs')
ax[0].set_ylabel('log(Sum-squared-error)')
ax[0].set_title('Adline Learing rate 0.01')
 
ax[1].set_xlabel('Epochs')
ax[1].set_ylabel('Sum-squared-error')
ax[1].set_title('Adline Learing rate 0.0001')
plt.show()
# 에포크(학습의 횟수)에 따른 오차의 그래프
# 에타(학습률)이 0.01일때는 오차가 학습을 거듭할 수록 오히려 증가하는 양상을 보임
# 에타가 0.0001때는 오차가 감소하지만 여전히 예측하기에는 오차가 큼.

위의 코드를 실행한(학습 결과 시각화)한 결과인데 왼쪽 그래프에서는 에포크(학습횟수)가 클수록 오히려 에러가 증가하고있고 오른쪽그래프에서는 에러가 감소하고 있긴 하지만 여전히 만족한 만한 학습결과를 얻지는 못하고 있다.

 

이유는 데이터가 표준화 되어있지 않기 때문이다. 데이터를 표준화하고 다시 학습해보자.

 

 

### 데이터 표준화 ###

X = (X - X의 평균) / X의 분산    으로 표준화

# 입력데이터(X) 표준화
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)
# X_std 표준화된 입력으로 학습

ada = AdalineGD(n_iter=15, eta=0.01)
ada.fit(X_std, y)
# X_std 표준화된 입력으로 학습
 
plot_decision_regions(X_std, y, classifier=ada)
plt.title('Adaline Gradient Descent')
plt.xlabel('sepal length')
plt.ylabel('petal length')
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(비용함수)가 감소해서 수렴하고 있다.

 

 

 

# plot_decision_regions(X_std, y, classifier=ada) # 

학습한 결과를 시각화하는 사용자 정의 함수, 결정 경계를 색으로 나눠서 표현한다.

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.ylim(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,
                    edgecolors='black')