수치 해석적 최적화
미분¶
어떤 함수의 특정 지점에서의 경사, 즉 기울기는 미분으로 구할 수 있다. 미분은 두 지점을 잇는 기울기에서 두 지점 사이의 간격을 극한으로 보내 정의한다. 미분에는 크게 두 가지 방법이 있다. 하나는 기호를 조작하여 도함수를 직접 구하는 해석적 방법이고, 다른 하나는 근삿값을 구하는 수치 미분이다. 수치 미분은 해석적 미분이 어려울 때 사용하며, 서로 다르지만 무한히 가까운 두 지점 사이의 기울기를 구한다는 미분의 정의를 그대로 반영한다. 서로 다르면서 무한히 가깝다는 것은 수치로는 표현할 수 없으므로, 0으로 해석되지 않으면서 가능한 한 작은 값을 두 지점의 차이로 두어 근사적으로 구한다.
경사 하강법¶
측정된 손실을 기준으로 학습 매개변수를 갱신하여 더 낮은 손실을 내는 최적의 매개변수를 찾는 과정을 수학적으로 최적화라고 한다. 최적화의 기본적인 방법론이 경사 하강법(gradient descent)이다. 경사 하강법의 기본 구상은, 어떤 지점의 경사, 즉 기울기를 구한 뒤 기울기가 더 낮아지는 방향으로 매개변수를 갱신해 나가면 이전보다 더 낮은 곳에 도달할 수 있다는 것이다. 스키장에서 산을 타고 내려올수록 경사가 점차 완만해지고, 가장 낮은 곳에 이르면 경사가 사라져 더 이상 움직이지 않게 되는 것과 비슷하다. 경사가 0인 지점은 최소점 외에 극대점이나 안장점일 수도 있어, 이것만으로 최저점에 도달했다고 판단할 수는 없다.
학습률¶
경사 하강을 수행할 때 갱신의 정도를 조절하기 위해 학습률을 설정한다. 너무 작은 값은 최저점까지 내려가는 데 오래 걸리고, 너무 큰 값은 최적점을 사이에 두고 지나쳐 발산할 수 있다. 목적지까지 이동할 때 적절한 속도가 중요한 것과 비슷하다. 처음부터 지나치게 느리게 가면 너무 오래 걸리고, 지나치게 빠르게 가면 목적지를 지나쳐 되돌아와야 할 수도 있다. 학습률의 적절한 값은 데이터셋과 모델에 따라 달라지며 미리 알아낼 방법이 없으므로, 사람이 여러 값을 실험적으로 바꿔 가며 좋은 값을 찾아야 하는 학습 환경에 해당한다.
최적화의 학습 흐름에서 경사 하강·역전파·최적화 기법·배치의 역할을 먼저 구분한다. 아래 수치 미분 코드는 그대로 따라가며 근사 기울기와 계산 비용을 확인한다.
import sys
print(sys.version)import numpy as np
print(np.__version__)
np.show_config()def sigmoid(x):
return 1 / (1 + np.exp(-x))
def 경사산출(f, x):
h = 1e-4
경사 = np.empty_like(x)
for i, xi in enumerate(x):
x[i] = xi + h
fxh1 = f(x)
x[i] = xi - h
fxh2 = f(x)
경사[i] = (fxh1 - fxh2) / (2 * h)
x[i] = xi # 원래 값 복원
return 경사
def 경사산출_2d(f, X):
경사 = np.zeros_like(X)
for j, xj in enumerate(X):
경사[j] = 경사산출(f, xj)
return 경사
def 교차엔트로피오차(y, y_pred):
delta = 1e-7
배치크기 = y.shape[0]
return -np.sum(y * np.log(y_pred + delta)) / 배치크기
def softmax(z):
exp_z = np.exp(z - np.max(z))
y = exp_z / np.sum(exp_z)
return y
def softmax_2d(Z):
return np.apply_along_axis(softmax, axis=1, arr=Z)
class 완전연결:
def __init__(self, 입력, 출력, 활성화=None):
self.W = np.random.randn(입력, 출력)
self.b = np.zeros(출력)
self.activation = 활성화
def forward(self, X):
Z = np.dot(X, self.W) + self.b
if self.activation:
return self.activation(Z)
return Z
class 신경망:
def __init__(self, 손실함수):
self.layers = []
self.loss_func = 손실함수
def add(self, layer):
self.layers.append(layer)
def predict(self, X):
"""순전파 (feedforward)"""
output = X
for layer in self.layers:
output = layer.forward(output)
return output
def 손실산출(self, X, y):
y_pred = self.predict(X)
손실 = self.loss_func(y, y_pred)
return 손실
def fit(self, X, y, 배치크기, 학습횟수, 학습률):
"""학습"""
표본수 = X.shape[0]
손실변화 = []
for i in range(학습횟수):
print(f'학습 {i+1}')
# 1. 미니배치
배치색인 = np.random.choice(표본수, 배치크기)
X_batch = X[배치색인]
y_batch = y[배치색인]
# 2. 경사 산출
f = lambda 매개변수: self.손실산출(X_batch, y_batch)
층별경사 = []
for layer in self.layers:
dW = 경사산출_2d(f, layer.W)
db = 경사산출(f, layer.b)
층별경사.append((dW, db))
# 3. 매개변수 갱신 (경사 하강)
for layer, (dW, db) in zip(self.layers, 층별경사):
layer.W -= dW * 학습률
layer.b -= db * 학습률
# (선택적) 손실확인
손실 = self.손실산출(X_batch, y_batch)
손실변화.append(손실)
print(f'\t손실: {손실}')
return 손실변화import pickle
with open('../data/mnist/mnist_data.pkl', 'rb') as f:
mnist = pickle.load(f)
(train_images, train_labels), (test_images, test_labels) = mnist
def 전처리(images, target_shape=(784,)):
X = images.reshape(-1, *target_shape)
X = X.astype('float32')
X /= 255
return X
X_train = 전처리(train_images)
X_test = 전처리(test_images)
assert X_train.shape == (60000, 784)
assert X_test.shape == (10000, 784)
# 원핫인코딩
one_hot_encoding = lambda labels: np.eye(10)[labels]
Y_train = one_hot_encoding(train_labels)model = 신경망(교차엔트로피오차)
model.add(완전연결(784, 50, sigmoid))
model.add(완전연결(50, 100, sigmoid))
model.add(완전연결(100, 10, softmax_2d))
배치크기 = 100
에폭당_배치수 = len(X_train) // 배치크기
에폭수 = 1
학습횟수 = 에폭당_배치수 * 에폭수
손실변화 = model.fit(X_train, Y_train, 배치크기=배치크기, 학습횟수=1, 학습률=0.1)
outputs = model.predict(X_train)
y_pred = np.argmax(outputs, axis=1)
print(f'Acc: {np.mean(train_labels == y_pred):.2%}')수치 미분은 미분의 정의를 그대로 구현하면 되기 때문에 구현이 수월하다. 그러나 매개변수의 개수가 많아질수록 편미분을 구하기 위한 연산이 가파르게 증가하는 것이 문제다. 이때 각 변수의 편미분을 구하기 위해 수행하는 순전파의 출력은 손실이다.
수치 미분의 문제점
편미분 수행을 위해 각 변수마다 순전파를 반복적으로 수행해야 한다. 미분 연산을 위해 각 변수마다 두 번씩 순전파가 발생한다.
예를 들어, 입력이 2차원 벡터()이고, 1층에 세 개의 뉴런(), 2층에 두 개의 뉴런()이 활용된다면 매개변수의 개수는 이고, 그에 따라 순전파 횟수는 이다.
from functools import wraps
def count_method_calls(func):
@wraps(func)
def wrapper(*args, **kwargs):
wrapper.calls += 1
return func(*args, **kwargs)
wrapper.calls = 0
return wrapper
model = 신경망(교차엔트로피오차)
model.add(완전연결(2, 3, sigmoid))
model.add(완전연결(3, 2, softmax_2d))
model.손실산출 = count_method_calls(신경망.손실산출).__get__(model, 신경망)
X = np.array([[0.1, 0.2]])
Y = np.array([[0, 1]])
model.fit(X, Y, 배치크기=1, 학습횟수=1, 학습률=0.1)
# 마지막 순전파 호출은 손실 측정을 위한 것이므로 제외
print(f'순전파 횟수: {model.손실산출.calls - 1}')다음 신경망의 매개변수는 45,360개이다. 학습 시점에 경사 산출을 위해 필요한 순전파 횟수는 다음과 같다.
전체 표본수가 60,000일 때 학습 시점에서 미니 배치 크기를 100으로 설정한다면, 에폭당 600번의 미니 배치 반복이 필요하다. 그렇다면, 1 에폭에 필요한 순전파 횟수는 54,432,000이다. 즉, 1 에폭에 5천만 번 이상의 순전파 연산을 수행해야 한다는 뜻이다.
매개변수 수는 이다. 여기서 600회는 전체 데이터를 중복 없이 순회할 때의 미니 배치 수에 대응한다. 아래 복원 추출 구현에서는 같은 갱신 횟수를 사용해도 모든 표본을 한 번씩 본다고 보장할 수 없다. 수치 미분 경사 산출만 센 횟수이며 손실 기록 등 추가 계산은 별도다.
이러한 연산량 문제는 매개변수의 개수가 많아질수록 그에 비례하여 증가한다. 지금 다룬 것은 지극히 간단한 3층 신경망임을 고려하면, 딥러닝을 수치 미분으로 학습시키는 것은 사실상 불가능에 가깝다. 딥러닝에서는 매개변수의 개수가 수억에서 수십억, 나아가 수조 개에 이를 수 있기 때문이다.
model = 신경망(교차엔트로피오차)
model.add(완전연결(784, 50, sigmoid))
model.add(완전연결(50, 100, sigmoid))
model.add(완전연결(100, 10, softmax_2d))
model.손실산출 = count_method_calls(신경망.손실산출).__get__(model, 신경망)
model.fit(X_train, Y_train, 배치크기=100, 학습횟수=1, 학습률=0.1)
# 마지막 순전파 호출은 손실 측정을 위한 것이므로 제외
print(f'순전파 횟수: {model.손실산출.calls - 1}')연산 성능의 변천¶
1980년대와 비교하면 컴퓨터의 연산 성능은 만 배 가까이 차이가 난다. 오늘날의 준수한 CPU에서 5분 정도 소요되는 연산이라면, 1980년대의 컴퓨터에서는 1년 가까이 소요된다는 의미다. 미니 배치 하나를 훈련하는 데 현재의 컴퓨터로 5분이 걸리고 1 에폭이 100개의 미니 배치로 구성된다면 1 에폭에 500분이 소요되는데, 같은 연산을 1980년대 컴퓨터로 수행하면 1 에폭 훈련에 500년이 필요하다. 신경망이 퍼셉트론과 달리 비선형성을 극복할 수 있다 하더라도, 훈련에 수백 년을 기다리는 것은 현실적이지 않다. 더구나 훈련 결과가 만족스럽지 않으면 신경망 구성을 바꿔 다시 훈련하고 결과를 확인하는 과정을 반복해야 한다. 수치 미분적 방법은 이해가 쉽고 구현이 간단하지만, 매개변수마다 손실을 반복 평가해야 한다. 중심 수치 미분은 매개변수 수 에 대해 약 회의 순전파가 필요하고, 각 순전파의 비용도 모델의 연산량에 따라 커지므로 큰 신경망의 학습에는 계산 부담이 크다.