Chap.04 신경망 학습

4-0. Intro 

💡 학습이란?
훈련 데이터로부터 가중치 매개변수의 최적값을 자동으로 획득하는 것 

이번 장에서는 신경망이 학습할 수 있도록 해주는 지표인 손실 함수를 소개한다.

---

4-1. 데이터 학습 

기계학습의 중심에는 데이터가 존재한다. 기계학습에서는 이러한 데이터들을 분석하고 특징들을 추출하여 예측을 한다. 

신경망에서는 이런한 특징을 선정하는 것을 자동적으로 해준다.

위에 그림은 사람, 기계학습, 신경망의 차이를 직관적으로 보여준다. 

사람은 직접 눈으로 보며 특징을 찾아내고 검출하지만 기계락습은 사람이 생각한 특징을 토대로 기계학습을 한다. 반면에 신경망에서는 데이터의 특징을 자동으로 선정하며 결과를 추출한다. 이러한 과정의 딥러닝을 종단간 기계학습이라고 한다.

 

훈련 데이터와 시험 데이터 

보통 기계학습에서는 범용능력을 제대로 평가하기 위해 훈련 데이터와 시험 데이터로 분리한다.

💡 훈련 데이터와 시험 데이터 
훈련 데이터는 모델을 학습시킬 때 사용되며 시험데이터는 학습된 모델을 평가하기 위해 사용한다.

하지만 훈련 데이터로 모델을 학습시킬 때 오버피팅이 안 나도록 주의해야한다. 

💡 오버피팅이란?
한 데이터셋에만 지나치게 최적화된 상태

---

4-2. 손실 함수

신경망 학습에서는 현재의 상태를 손실함수로 표현하는 데 이 손실함수의 값을 이용해 알맞은 가중치 매개변수의 값을 찾아간다.

 💡 손실함수란?
신경망의 성능의 '나쁨'을 나타내는 지표이다. 대표적으로는 오차제곱합, 교차 엔트로피 오차를 사용한다.

 

오차제곱합

자 그럼 많이 사용하는 손실함수인 오차제곱합을 알아보자.

오차제곱합 수식

위의 수식은 오차제곱합을 수식으로 나타낸 것이다. 

단순히 신경망 결과(y)에서 정답 레이블(t)를 빼고 제곱 후 합을 구해 2로 나눈 것이다.

그럼 코드로 구현해보자.

def sum_squares_error(y, t):
    return 0.5 * np.sum((y-t)**2)

 이렇게 구한 오차제곱합을 어떻게 사용할까?

t =[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]
sum_squares_error(np.array(y), np.array(t))
# >>> 0.097500000000031

y = [0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0]
sum_squares_error(np.array(y), np.array(t))
# >>> 0.5975000000003

위에 코드처럼 오차제곱합이 낮아질수록 정답일 확률이 올라가고 반대로 높아질수록 정답일 확률은 내려간다.

 

교차 엔트로피 오차

그럼 다른 손실함수인 교차 엔트로피 오차를 살펴보자.

교차 엔트로피 오차 수식

오차제곱합과 마찬가지로 y는 출력을 t는 정답 레이블을 가리킨다.

def cross_entropy_error(y, t):
	delta = 1e-7
    return -np.sum(t * np.log(y + delta))

교차 엔트로피 오차는 로그 값이 무한데로 가는 것을 방지하기 위해 delta값을 사용하였다.

오차제곱합과 마찬가지로 교차 엔트로피 오차값이 커지면 정답일 확률은 낮아지고 작아지면 정답일 확률은 높아진다.

 

손실함수를 사용하는 이유

정확도를 지표로 하면 매개변수의 미분이 대부분의 장소에서 0이 되기 때문에 신경망을 학습시킬 때 정확도를 지표로 삼아서는 안 된다. 

정확도를 지표로 삼으면 정확도가 개선된다고 하더라도 불연속적인 값을 갖게 된다. 하지만 손실함수를 지표로 삼으면 연속적인 값을 갖게 된다.

---

4-3. 수치 미분

수치미분 수식

수치 미분의 수식은 다음과 같다. 그럼 이 수식을 코드로 구현해보자.

def numerical_diff(f, x):
    h = 10e-50 
    return (f(x+h) - f(h)) / (h)

수치미분을 코드로 구현해 보았지만 위 코드는 두 가지의 문제점이 있다.

1. h를 너무 작은 값을 주면 반올림 오차가 발생해 0으로 변환됨
2. f(x+h) - f(h)는 근사 미분이지 정확한 미분값이 아니다.

이 문제점 들을 해결하기 위해 다음 2개로 수정해보자.

1. h값을 너무 작지않게 변경
2. 중심차분 사용

def numerical_diff(f, x):
    h = 1e-4 # 0.0001
    return (f(x+h) - f(x-h)) / (2*h)

편미분

변수가 두 개이상의 식을 미분하기 위해서는 편미분을 사용한다. 

편미분은 여러 변수 중 목표 변수 하나에 초점을 맞추고 다른 변수 값을 고정하여 구한다.

def numerical_gradient(f, x):
    h = 1e-4 # 0.0001
    grad = np.zeros_like(x) # x와 형상이 같은 배열을 생성
    
    for idx in range(x.size):
        tmp_val = x[idx]
        
        # f(x+h) 계산
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)
        
        # f(x-h) 계산
        x[idx] = tmp_val - h 
        fxh2 = f(x) 
        
        grad[idx] = (fxh1 - fxh2) / (2*h)
        x[idx] = tmp_val # 값 복원
        
    return grad

편미분의 코드는 다음과 같이 구현할 수 있다.

---

4-4. 기울기

경사하강법

다시 이제 신경망으로 돌아가 보면 우리는 지금 손실 함수까지 배웠다. 그럼 손실함수가 최적의 해를 갱신하는 방법을 살펴보자.

경사하강법은 기울기를 이용해 손실함수가 최솟값을 갖는 곳을 찾아준다.

경사하강법은 손실함수 그래프에서 한 점의 기울기를 구한 후 기울기가 최소가 되는 곳으로 이동하는 것을 반복한다.

경사하강법의 수식은 아래와 같다. 

경사하강법 수식

이와같은 경사하강법을 코드로 구현해보자.

def gradient_descent(f, init_x, lr=0.01, step_num=100):
    x = init_x

    for i in range(step_num):
        grad = numerical_gradient(f, x)
        x -= lr * grad

    return x

경사하강법에서 값을 갱신할 때 학습률이라는 것이 존재하는데 이는 한 번의 학습으로 얼마만큼 학습해야하는지 즉 매개변수 값을 얼마나 갱신하느냐를 정하는 것이다.

 

그러면 이 경사하강법을 이용해 f(x0, x1) = x0^2 + x1^2의 최솟값을 구해보자.

def function_2(x):
    return x[0]**2 + x[1]**2

init_x = np.array([-3.0, 4.0])    

lr = 0.1
step_num = 20
x, x_history = gradient_descent(function_2, init_x, lr=lr, step_num=step_num)

다음과 같이 초기 좌표, 학습률, 반복횟수만 정해주면 쉽게 구할 수 있다.

경사하강법 학습 과정

학습률과 같이 사람이 직접 정해주는 매개변수를 하이퍼파라미터라고 한다.

---

4-5. 학습 알고리즘 구현하기

전제 

• 신경망에는 적응 가능한 가중치와 편향이 있고, 이 가중피롸 편향을 훈련 데이터에 적을하도록 조정하는 과정을 학습이라고 한다. 신경망 학습은 다음과 같이 4단계로 수행한다.

1단계 - 미니배치

• 훈련 데이터 중 일부를 무작위로 가져온다. 이렇게 선별한 데이터를 미니 배치라 하며, 그 미니배치의 손실함수 값을 줄이는 것이 목표이다.

2단계 - 기울기 산출

• 미니배치의 손실함수 값을 줄이기 위해 각 가중치 매개변수의 기울기를 구한다. 기울기는 손실함수의 값을 가장 작게 하는 방향을 제시한다.

3단계 - 매개변수 갱신

• 가중치 매개변수를 기울기 방향으로 아주 조금 갱신한다.

4단계 - 반복

• 1~3단계를 반복

2층 신경망 클래스 구현

class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        # 가중치 초기화
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)

    def predict(self, x):
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
    
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        
        return y
        
    # x : 입력 데이터, t : 정답 레이블
    def loss(self, x, t):
        y = self.predict(x)
        
        return cross_entropy_error(y, t)
    
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        t = np.argmax(t, axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
        
    # x : 입력 데이터, t : 정답 레이블
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t)
        
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        
        return grads

미니 배치 학습

# 데이터 읽기
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

# 하이퍼파라미터
iters_num = 10000  # 반복 횟수를 적절히 설정한다.
train_size = x_train.shape[0]
batch_size = 100   # 미니배치 크기
learning_rate = 0.1

train_loss_list = []
train_acc_list = []
test_acc_list = []

# 1에폭당 반복 수
iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    # 미니배치 획득
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 기울기 계산
    #grad = network.numerical_gradient(x_batch, t_batch)
    grad = network.gradient(x_batch, t_batch)
    
    # 매개변수 갱신
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    # 학습 경과 기록
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    
    # 1에폭당 정확도 계산
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

---

Chapter. 4 정리

기계학습에서 사용하는 데이터셋은 훈련 데이터와 시험 데이터로 나눠 사용한다. 
훈련 데이터로 학습한 모델의 범용 능력을 시험 데이터로 평가한다.
신경망 학습은 손실함수를 지표로, 소실함수의 값이 작아지는 방향으로 가중치 매개변수를 갱신한다.
가중치 매개변수를 갱신할 때는 가중치 매개변수의 기울기를 이용하고, 기울어진 방향으로 가중치의 값을 갱신하는 작업을 반복한다.
아주 작은 값을 주었을 때의 차분으로 미분하는 것을 수치 미분이라고 한다.
수치 미분을 이용해 가중치 매개 변수의 기울기를 구할 수 있다.
수치 미분을 이용한 계산에는 시간이 걸리지만, 그 구현은 간단하다.

---

출처: 사이토 고키, 『밑바닥부터 시작하는 딥러닝』, 한빛미디어(2017)