3 Inseok Kong Schedule

Deep Learning & PyTorch 4: Getting Started with Deep Learning

퍼셉트론이 XOR을 풀지 못하는 한계에서 출발해 딥러닝의 구성 요소(가중치, 활성화 함수, 손실 함수), 순전파와 역전파, 과적합과 기울기 소멸 등의 문제와 해결책, 경사 하강법과 옵티마이저, 대표적인 딥러닝 알고리즘을 정리한다.

4장은 본격적인 딥러닝 실습에 앞서 신경망의 구성 요소와 학습 원리를 정리하는 이론 장이다. 공식 예제 노트북은 없고, 본문의 짧은 파이토치 코드 조각만 있다.

4.1 인공 신경망의 한계와 딥러닝 출현

📖 thebook.io

오늘날 신경망의 기본 구조(입력층, 출력층, 그 사이를 잇는 가중치)는 1957년 프랭크 로젠블라트(Frank Rosenblatt)가 고안한 퍼셉트론(perceptron) 에서 출발한다. 퍼셉트론은 여러 입력 신호를 받아 가중합을 구하고, 그 값이 임계값을 넘으면 1, 아니면 0을 내보내는 선형 분류기다.

\[y = \begin{cases} 1 & w_1 x_1 + w_2 x_2 + b > 0 \\ 0 & \text{otherwise} \end{cases}\]

입력이 두 개(\(x_1\), \(x_2\))일 때 퍼셉트론이 어떤 논리를 표현할 수 있는지 논리 게이트로 확인해 보자.

\(x_1\) \(x_2\) AND OR XOR
0 0 0 0 0
1 0 0 1 1
0 1 0 1 1
1 1 1 1 0
  • AND: 두 입력이 모두 1일 때만 1. 네 점 \((0,0), (1,0), (0,1), (1,1)\)을 평면에 찍으면 \((1,1)\) 하나만 1이므로, 오른쪽 위 모서리를 잘라 내는 직선 하나로 나뉜다. 예: \(w_1 = w_2 = 1\), \(b = -1.5\).
  • OR: 하나라도 1이면 1. \((0,0)\) 하나만 0이므로 역시 직선 하나로 나뉜다. 예: \(w_1 = w_2 = 1\), \(b = -0.5\).
  • XOR(배타적 논리합): 둘 중 하나만 1일 때 1. 1인 점 \((1,0)\), \((0,1)\)이 대각선으로 마주 보고, 0인 점 \((0,0)\), \((1,1)\)도 다른 대각선에 있다. 이 두 그룹을 가르는 직선은 존재하지 않는다.

퍼셉트론의 결정 경계는 \(w_1 x_1 + w_2 x_2 + b = 0\), 즉 직선이므로 단층 퍼셉트론은 AND와 OR은 배울 수 있지만 XOR은 배울 수 없다. 데이터가 비선형적으로만 분리되기 때문이다.

해결책은 입력층과 출력층 사이에 은닉층(hidden layer) 을 두는 것이다. 예를 들어 XOR은 “OR이면서 NAND인 것”, 즉 \(\text{XOR}(x_1, x_2) = \text{AND}(\text{OR}(x_1, x_2), \text{NAND}(x_1, x_2))\)로 쓸 수 있다. 은닉층의 두 뉴런이 OR과 NAND를 계산하면, 출력층은 그 결과에 AND만 하면 된다. 입력 공간에서는 직선 두 개가 필요한 문제를, 은닉층이 만든 새 공간에서는 직선 하나로 풀 수 있게 된 것이다. 이렇게 층을 여러 개 쌓은 것이 다층 퍼셉트론(multi-layer perceptron) 이며, 은닉층이 여러 개인 신경망을 심층 신경망(Deep Neural Network, DNN), 그리고 이를 이용한 학습을 딥러닝이라 부른다.

4.2 딥러닝 구조

📖 thebook.io

딥러닝은 여러 층의 신경망으로 학습하는 방법이다. 각 층이 무엇으로 이루어지고 어떻게 학습하는지, 그리고 층이 깊어지면서 생기는 문제를 차례로 본다.

4.2.1 딥러닝 용어

신경망은 입력층, 하나 이상의 은닉층, 출력층으로 구성되며, 층 사이에서 신호를 처리하는 여러 함수를 쓴다.

구분 구성 요소 설명
층 입력층(input layer) 데이터를 받아들이는 층
층 은닉층(hidden layer) 이전 층의 모든 노드에서 값을 받아 가중합을 구하고, 활성화 함수를 거쳐 다음 층으로 넘기는 층
층 출력층(output layer) 신경망의 최종 결과가 나오는 층
값 가중치(weight) 노드와 노드 사이 연결의 강도
값 바이어스(bias) 가중합에 더하는 상수. 뉴런 출력이 켜지는 기준점을 옮기는 역할
연산 가중합(weighted sum), 전달 함수 입력 신호와 가중치를 곱해 모두 더한 값
함수 활성화 함수(activation function) 가중합을 받아 비선형 변환해 출력하는 함수
함수 손실 함수(loss function) 출력과 실제 값의 오차를 재어 가중치 학습의 기준을 주는 함수

가중치

가중치는 각 입력이 결과에 얼마나 영향을 미칠지 조절한다. 예를 들어 \(w_1\)이 0이나 0.001처럼 0에 가까우면 \(x_1\)이 아무리 커도 \(w_1 x_1\)은 거의 0이 되어 결과에 영향을 주지 못한다. 학습이란 결국 이 가중치들을 적절한 값으로 맞춰 가는 과정이다.

가중합(전달 함수)

각 노드는 들어오는 신호마다 가중치를 곱하고, 그 결과를 모두 더한 뒤 바이어스를 더한다. 이것이 가중합이다. 계산된 가중합이 활성화 함수로 넘어가므로 전달 함수(transfer function) 라고도 부른다.

\[z = \sum_{i=1}^{n} w_i x_i + b\]

활성화 함수

활성화 함수는 가중합을 받아 일정한 규칙에 따라 출력값을 바꾸는 비선형 함수다. 비선형이어야 하는 이유는, 선형 변환을 아무리 겹쳐도 결국 하나의 선형 변환(\(W_2(W_1 x) = (W_2 W_1) x\))이 되기 때문이다. 층을 깊게 쌓는 의미가 생기려면 층 사이에 비선형성이 있어야 한다.

시그모이드(sigmoid) 는 입력을 0과 1 사이로 눌러 준다. 로지스틱 회귀처럼 결과를 확률로 해석할 때 쓰인다.

\[\sigma(x) = \frac{1}{1 + e^{-x}}, \qquad \sigma'(x) = \sigma(x)\,(1 - \sigma(x))\]

도함수의 최댓값이 \(x=0\)에서의 0.25이고, 입력이 크거나 작으면 0에 가까워진다. 역전파는 층마다 이 도함수를 곱하므로 층이 깊어지면 기울기가 급격히 작아지는 기울기 소멸 문제(vanishing gradient problem) 가 생긴다. 그래서 요즘 은닉층에서는 잘 쓰지 않는다.

하이퍼볼릭 탄젠트(hyperbolic tangent, tanh) 는 출력 범위가 −1에서 1이다.

\[\tanh(x) = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}, \qquad \tanh'(x) = 1 - \tanh^2(x)\]

시그모이드의 출력은 항상 양수라 평균이 0보다 큰 쪽으로 치우치는데, tanh는 0을 중심으로 대칭이라 이 문제를 덜어 준다. 도함수의 최댓값도 1로 더 크지만, 입력 절댓값이 커지면 여전히 0으로 수렴하므로 기울기 소멸은 남아 있다.

렐루(ReLU, Rectified Linear Unit) 는 음수는 0으로, 양수는 그대로 내보낸다.

\[\text{ReLU}(x) = \max(0, x), \qquad \text{ReLU}'(x) = \begin{cases} 1 & x > 0 \\ 0 & x < 0 \end{cases}\]

양수 구간의 기울기가 항상 1이므로 층이 깊어져도 기울기가 줄지 않고, 계산도 단순해 학습이 빠르다. AlexNet 논문에서는 같은 정확도에 도달하는 데 tanh보다 약 6배 빨랐다고 보고했다. 현재 은닉층의 기본 선택이다. 다만 입력이 음수인 뉴런은 출력과 기울기가 모두 0이 되어 더 이상 학습되지 않을 수 있다(죽은 렐루, dying ReLU).

리키 렐루(Leaky ReLU) 는 음수 구간에 아주 작은 기울기를 남겨 이 문제를 줄인다.

\[\text{LeakyReLU}(x) = \begin{cases} x & x > 0 \\ a x & x \le 0 \end{cases} \qquad (a \text{는 작은 양수, 파이토치 기본값 } 0.01)\]

소프트맥스(softmax) 는 출력층에서 주로 쓰며, 여러 출력값을 0과 1 사이로 바꾸면서 합이 1이 되도록 정규화한다. 그래서 각 출력을 클래스별 확률로 해석할 수 있다.

\[y_k = \frac{\exp(a_k)}{\sum_{i=1}^{n} \exp(a_i)}\]

\(n\)은 출력 뉴런 수, \(a_k\)는 \(k\)번째 출력 뉴런의 입력, \(y_k\)는 그 출력이다. 분자는 해당 입력의 지수 함수이고 분모는 모든 입력의 지수 함수 합이다. 지수 함수 덕분에 큰 값은 더 크게, 작은 값은 더 작게 벌어진다.

함수 출력 범위 도함수 최댓값 주 사용처
시그모이드 (0, 1) 0.25 이진 분류 출력층
tanh (−1, 1) 1 RNN 내부 등
ReLU [0, ∞) 1 은닉층 기본
Leaky ReLU (−∞, ∞) 1 ReLU 대안
소프트맥스 (0, 1), 합 1 - 다중 분류 출력층

파이토치에서 은닉층에 렐루, 출력층에 소프트맥스를 쓰는 모델은 다음과 같다.

import torch

class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 은닉층
        self.relu = torch.nn.ReLU(inplace=True)
        self.out = torch.nn.Linear(n_hidden, n_output)       # 출력층
        self.softmax = torch.nn.Softmax(dim=1)               # (배치, 클래스)에서 클래스 축으로 정규화

    def forward(self, x):
        x = self.hidden(x)
        x = self.relu(x)       # 은닉층 활성화
        x = self.out(x)
        x = self.softmax(x)    # 출력을 확률로
        return x

책의 코드는 torch.nn.ReLu(오타)와 Softmax(dim=n_output)로 되어 있는데, 클래스 이름은 ReLU이고 dim은 정규화할 축 번호이므로 (배치, 클래스) 모양 출력이라면 dim=1이어야 한다. 또한 학습에 nn.CrossEntropyLoss를 쓸 경우 손실 함수 안에서 소프트맥스를 계산하므로, 모델에서는 소프트맥스를 빼고 로짓(logit)을 그대로 내보내는 것이 일반적이다.

손실 함수

경사 하강법(gradient descent) 은 손실 함수의 기울기와 학습률(learning rate) \(\eta\)를 이용해, 오차가 줄어드는 방향으로 가중치를 조금씩 옮기는 방법이다. 이때 “오차”를 정의하는 것이 손실 함수다. 손실이 클수록 많이 틀렸다는 뜻이고, 0에 가까울수록 정답에 가깝다는 뜻이다. 대표적으로 두 가지가 있다.

평균 제곱 오차(Mean Squared Error, MSE). 실제 값과 예측 값의 차이를 제곱해 평균 낸다. 회귀 문제의 기본 손실이다.

\[\text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2\]
loss_fn = torch.nn.MSELoss(reduction='sum')   # 'sum'이면 평균 대신 합계
y_pred = model(x)
loss = loss_fn(y_pred, y)

reduction은 샘플별 오차를 어떻게 합칠지 정한다. 기본값 'mean'은 평균, 'sum'은 합계, 'none'은 샘플별 값을 그대로 돌려준다.

크로스 엔트로피 오차(Cross Entropy Error, CEE). 분류 문제에서 정답을 원-핫 벡터 \(y\)(정답 클래스만 1)로, 모델 출력을 확률 \(\hat{y}\)로 보고 계산한다.

\[\text{CEE} = -\sum_{k} y_k \log \hat{y}_k\]

원-핫이므로 실제로는 정답 클래스의 확률 하나에만 \(-\log\)를 취하는 셈이다. 정답 확률이 1이면 손실이 0이고, 0에 가까워질수록 손실이 급격히 커진다.

분류에 MSE 대신 이것을 쓰는 이유는 학습 신호의 질 때문이다. 시그모이드나 소프트맥스 출력에 MSE를 쓰면, 출력이 0이나 1 근처로 포화된 상태에서 크게 틀려도 기울기가 매우 작아 학습이 더디고, 손실 곡면도 울퉁불퉁해져 지역 최소점에 빠지기 쉽다. 크로스 엔트로피는 출력의 지수 함수(\(e\))를 로그가 상쇄해서, 틀린 정도에 비례하는 깔끔한 기울기(소프트맥스와 함께 쓰면 \(\hat{y} - y\))를 준다.

import torch.nn as nn

loss = nn.CrossEntropyLoss()
input = torch.randn(5, 6, requires_grad=True)       # 샘플 5개 × 클래스 6개의 로짓 (표준정규분포 난수)
target = torch.empty(5, dtype=torch.long).random_(6) # 샘플별 정답 클래스 번호 0~5
output = loss(input, target)
output.backward()

nn.CrossEntropyLoss는 로짓을 받아 내부에서 소프트맥스와 로그를 함께 계산하고, 정답은 원-핫 대신 클래스 번호로 받는다. 따라서 input의 첫 차원(샘플 수)과 target의 길이가 같아야 하고, 정답 번호는 클래스 수보다 작아야 한다(책의 코드는 target 길이가 3이라 그대로 실행하면 크기가 맞지 않는다는 오류가 난다).

4.2.2 딥러닝 학습

📖 thebook.io

딥러닝 학습은 순전파와 역전파 두 단계의 반복이다.

순전파  : 입력층 ──▶ 은닉층 ──▶ 출력층 ──▶ 예측값 ŷ
                                           │
                                     손실 L(ŷ, y)
                                           │
역전파  : 입력층 ◀── 은닉층 ◀── 출력층 ◀────┘   (∂L/∂w 계산 후 w 갱신)

순전파(feedforward) 에서는 훈련 데이터가 입력층으로 들어가 각 층을 차례로 통과한다. 각 뉴런은 이전 층에서 받은 값에 가중합과 활성화 함수를 적용해 다음 층으로 보내고, 모든 층을 지나면 출력층에 예측값이 나온다.

그다음 손실 함수로 예측값과 실제 값의 차이를 계산한다. 이상적인 손실은 0이므로, 손실을 0에 가깝게 만드는 방향으로 가중치를 고쳐야 한다.

역전파(backpropagation) 는 손실 정보를 출력층 → 은닉층 → 입력층 방향으로 거꾸로 보내며 각 가중치를 얼마나 고칠지 계산한다. 은닉층의 각 뉴런은 출력에 기여한 정도(연결 가중치의 크기)에 비례해 오차를 나누어 받는다. 수학적으로는 손실을 각 가중치로 미분한 값(기울기)을 구해, 학습률을 곱해 기존 가중치에서 뺀다.

\[w \leftarrow w - \eta \frac{\partial L}{\partial w}\]

층이 여러 개일 때 이 미분은 연쇄 법칙(chain rule) 으로 계산된다. 예를 들어 \(z = w x + b\), \(a = f(z)\), 손실 \(L(a)\)라면

\[\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} = \frac{\partial L}{\partial a} \cdot f'(z) \cdot x\]

출력층에서 구한 \(\frac{\partial L}{\partial a}\)를 재사용하며 한 층씩 거슬러 올라가므로 계산이 효율적이다. 갱신된 가중치로 다시 순전파를 하고, 이 과정을 반복한다.

4.2.3 딥러닝의 문제점과 해결 방안

📖 thebook.io

딥러닝의 힘은 활성화 함수가 들어간 은닉층을 여러 개 겹쳐 복잡한 비선형 경계를 표현하는 데 있다. 은닉층이 없으면 직선 경계만, 하나면 몇 번 꺾인 경계, 여러 개면 훨씬 복잡한 모양의 경계를 그릴 수 있다. 하지만 층이 많아질수록 세 가지 문제가 생긴다.

과적합

과적합(overfitting) 은 훈련 데이터를 지나치게 학습해서 생긴다. 훈련 데이터는 실제 데이터의 일부일 뿐인데, 그 안의 잡음까지 외워 버리면 훈련 오차는 계속 줄어도 검증 데이터나 실제 데이터에서의 오차는 오히려 늘어난다. 학습 곡선으로 보면 훈련 손실은 내려가는데 검증 손실이 어느 시점부터 다시 올라가는 모습이다.

대표적인 해결책이 드롭아웃(dropout) 이다. 학습할 때마다 일부 노드를 무작위로 꺼서(출력을 0으로) 학습에서 제외한다. 특정 노드에 지나치게 의존하지 못하게 되어, 여러 개의 작은 신경망을 함께 학습시켜 평균 내는 것과 비슷한 효과가 난다. 평가할 때(model.eval())는 모든 노드를 사용한다.

import torch
import torch.nn.functional as F

class DropoutModel(torch.nn.Module):
    def __init__(self):
        super(DropoutModel, self).__init__()
        self.layer1 = torch.nn.Linear(784, 1200)
        self.dropout1 = torch.nn.Dropout(0.5)    # 학습 시 노드의 50%를 무작위로 끔
        self.layer2 = torch.nn.Linear(1200, 1200)
        self.dropout2 = torch.nn.Dropout(0.5)
        self.layer3 = torch.nn.Linear(1200, 10)

    def forward(self, x):
        x = F.relu(self.layer1(x))
        x = self.dropout1(x)
        x = F.relu(self.layer2(x))
        x = self.dropout2(x)
        return self.layer3(x)

28×28 이미지(784픽셀)를 받아 10개 클래스로 분류하는 구조다. 파이토치의 Dropout은 학습 중 남은 노드의 출력을 \(\frac{1}{1-p}\)배 키워 두기 때문에, 평가 시에는 아무 보정 없이 모든 노드를 쓰면 된다.

기울기 소멸

기울기 소멸은 은닉층이 많을 때, 출력층에서 거꾸로 전달되는 오차(기울기)가 앞쪽 층으로 갈수록 점점 작아져 앞쪽 층이 거의 학습되지 않는 현상이다. 갱신량이 0에 가까워지니 학습이 더디다가 오차를 충분히 줄이지 못한 채 멈춘다. 연쇄 법칙에서 활성화 함수의 도함수를 층마다 곱하는데, 시그모이드처럼 도함수가 1보다 한참 작으면(최대 0.25) 곱할수록 0으로 사라진다. 은닉층의 활성화 함수를 시그모이드나 tanh 대신 렐루로 바꾸면 양수 구간 기울기가 1이라 이 문제가 크게 줄어든다.

성능 저하와 경사 하강법의 종류

경사 하강법은 손실 함수 곡면에서 기울기가 낮은 쪽으로 조금씩 내려가며 최소점을 찾는다. 이때 한 번 갱신하는 데 데이터를 얼마나 쓰느냐에 따라 속도와 안정성이 달라진다.

배치 경사 하강법(Batch Gradient Descent, BGD) 은 전체 훈련 데이터의 오차를 모두 구해 평균 기울기를 한 번 계산하고 파라미터를 한 번 갱신한다.

\[w \leftarrow w - \eta \, \nabla_w \frac{1}{N} \sum_{i=1}^{N} L_i(w)\]

방향은 정확하지만 한 걸음에 데이터 전체를 봐야 하므로 데이터가 크면 매우 느리고 메모리도 많이 든다.

확률적 경사 하강법(Stochastic Gradient Descent, SGD) 은 무작위로 고른 샘플 하나로 기울기를 구해 바로 갱신한다.

\[w \leftarrow w - \eta \, \nabla_w L_i(w)\]

계산이 빠르지만 샘플마다 방향이 달라 경로가 크게 요동치고, 때로는 BGD보다 정확도가 떨어진다. 대신 이 요동 덕분에 얕은 지역 최소점을 빠져나오기도 한다.

미니 배치 경사 하강법(mini-batch gradient descent) 은 데이터를 작은 묶음(미니 배치)으로 나누고, 묶음마다 평균 기울기로 갱신한다.

\[w \leftarrow w - \eta \, \nabla_w \frac{1}{B} \sum_{i \in \mathcal{B}} L_i(w)\]

전체 데이터를 쓰는 것보다 빠르고, 샘플 하나를 쓰는 것보다 안정적이며, GPU 병렬 계산과도 잘 맞아 실제로 가장 많이 쓴다. 딥러닝 문맥에서 “SGD”라고 하면 보통 이 미니 배치 방식을 가리킨다. 파이토치에서는 DataLoader의 batch_size로 미니 배치를 만든다.

import torch
from torch.utils.data import Dataset, DataLoader

class CustomDataset(Dataset):
    def __init__(self):
        self.x_data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
        self.y_data = [[12], [18], [11]]

    def __len__(self):
        return len(self.x_data)

    def __getitem__(self, idx):
        x = torch.FloatTensor(self.x_data[idx])
        y = torch.FloatTensor(self.y_data[idx])
        return x, y

dataset = CustomDataset()
dataloader = DataLoader(
    dataset,
    batch_size=2,    # 미니 배치 크기 (보통 2의 거듭제곱)
    shuffle=True,    # 에포크마다 순서를 섞음
)

옵티마이저

SGD의 요동과 느린 수렴을 개선하려고 다양한 옵티마이저(optimizer) 가 나왔다. 크게 학습률(속도)을 조정하는 계열, 이동 방향(운동량)을 조정하는 계열, 둘을 합친 계열로 나눌 수 있다. 아래 식에서 \(g_t = \nabla_w L(w_t)\)는 \(t\)번째 단계의 기울기, \(\eta\)는 학습률, \(\epsilon\)은 0으로 나누는 것을 막는 작은 수다.

속도(학습률) 조정 : Adagrad ──▶ Adadelta, RMSProp ─┐
                                                 ├──▶ Adam
운동량(방향) 조정 : Momentum ──▶ NAG ──────────────┘

아다그라드(Adagrad, Adaptive Gradient). 파라미터마다 학습률을 따로 조정한다. 지금까지의 기울기 제곱을 누적한 \(G\)로 학습률을 나눈다.

\[G_t = G_{t-1} + g_t^2, \qquad w_{t+1} = w_t - \frac{\eta}{\sqrt{G_t + \epsilon}} \, g_t\]

많이 변화한(기울기가 컸던) 파라미터는 \(G\)가 커져 학습률이 작아지고, 거의 변하지 않은 파라미터는 학습률이 크게 유지된다. 이미 많이 움직인 파라미터는 최적값 근처에 왔을 것이니 세밀하게, 덜 움직인 파라미터는 개선 여지가 크니 과감하게 움직인다는 발상이다. 문제는 \(G\)가 계속 커지기만 해서 학습이 진행될수록 학습률이 0에 수렴해 결국 학습이 멈춘다는 점이다.

optimizer = torch.optim.Adagrad(model.parameters(), lr=0.01)   # 기본 학습률 1e-2

아다델타(Adadelta, Adaptive Delta). 아다그라드에서 \(G\)가 무한히 커져 학습이 멈추는 문제를 고친다. 기울기 제곱을 전부 더하는 대신 지수 이동 평균으로 최근 값 위주로 누적하고, 분자의 학습률 \(\eta\) 자리에 가중치 변화량 \(\Delta w\) 제곱의 이동 평균 \(D\)를 쓴다. 그래서 원래 논문 형태에서는 학습률 하이퍼파라미터가 필요 없다.

\[\Delta w_t = - \frac{\sqrt{D_{t-1} + \epsilon}}{\sqrt{G_t + \epsilon}} \, g_t, \qquad w_{t+1} = w_t + \Delta w_t\]
optimizer = torch.optim.Adadelta(model.parameters(), lr=1.0)   # 기본값 1.0 (Δw에 곱하는 배율)

알엠에스프롭(RMSProp). 역시 \(G\)가 무한히 커지는 것을 막기 위해, 누적을 감쇠 계수 \(\gamma\)를 쓴 지수 이동 평균으로 바꾼다. 오래된 기울기의 영향은 점점 줄고 최근 기울기 크기가 학습률을 결정한다.

\[G_t = \gamma G_{t-1} + (1 - \gamma) g_t^2, \qquad w_{t+1} = w_t - \frac{\eta}{\sqrt{G_t + \epsilon}} \, g_t\]
optimizer = torch.optim.RMSprop(model.parameters(), lr=0.01)   # 기본 학습률 1e-2

모멘텀(Momentum). 기울기를 매번 구하되, 바로 그 방향으로 가지 않고 이전에 움직이던 방향을 일정 비율 섞는다. 물리의 관성처럼 같은 방향으로 계속 내려가면 속도가 붙고, 방향이 번갈아 바뀌는 지그재그 성분은 서로 상쇄되어 줄어든다.

\[v_t = \gamma v_{t-1} + \eta \, g_t, \qquad w_{t+1} = w_t - v_t\]

\(v\)는 속도(velocity)이고, \(\gamma\)가 모멘텀 계수다. 보통 0.9로 시작하며 0.95, 0.99처럼 키워 보기도 한다. 파이토치에서는 SGD의 옵션이다.

optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

네스테로프 모멘텀(Nesterov Accelerated Gradient, NAG). 모멘텀은 관성 때문에 멈춰야 할 곳을 지나쳐 버릴 수 있다. NAG는 현재 위치가 아니라 관성으로 이동할 예정인 지점에서 기울기를 계산한다. 미리 한 발 내다보고 그곳의 경사를 확인한 뒤 방향을 보정하므로, 모멘텀의 빠른 속도는 유지하면서 최저점 근처에서 제동을 더 잘 건다.

\[v_t = \gamma v_{t-1} + \eta \, \nabla_w L(w_t - \gamma v_{t-1}), \qquad w_{t+1} = w_t - v_t\]
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, nesterov=True)   # 기본 False

아담(Adam, Adaptive Moment Estimation). 모멘텀과 RMSProp을 합친 방법이다. 기울기의 이동 평균 \(m\)(모멘텀처럼 방향)과 기울기 제곱의 이동 평균 \(v\)(RMSProp처럼 크기에 따른 학습률 조정)를 함께 쓴다.

\[m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t, \qquad v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2\] \[\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}, \qquad w_{t+1} = w_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \, \hat{m}_t\]

\(\hat{m}\), \(\hat{v}\)는 초기값을 0으로 시작해서 생기는 초반의 편향을 보정한 값이다. 기본값은 \(\beta_1 = 0.9\), \(\beta_2 = 0.999\)이며, 대부분의 문제에서 무난하게 잘 동작해 가장 널리 쓰인다.

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)   # 기본 학습률 1e-3
옵티마이저 조정 대상 핵심 아이디어 파이토치
Adagrad 학습률 기울기 제곱 누적으로 파라미터별 학습률 optim.Adagrad
Adadelta 학습률 누적을 이동 평균으로, 학습률 대신 변화량 사용 optim.Adadelta
RMSProp 학습률 기울기 제곱의 지수 이동 평균 optim.RMSprop
Momentum 방향 이전 이동 방향을 관성으로 반영 optim.SGD(momentum=...)
NAG 방향 관성으로 이동할 지점에서 기울기 계산 optim.SGD(nesterov=True)
Adam 둘 다 Momentum + RMSProp, 편향 보정 optim.Adam

4.2.4 딥러닝을 사용할 때 이점

📖 thebook.io

특성 추출의 자동화. 컴퓨터가 패턴을 찾으려면 데이터를 컴퓨터가 다룰 수 있는 벡터로 바꾸는 특성 추출이 필요하다. 딥러닝 이전에 많이 쓰던 SVM, 나이브 베이즈(Naïve Bayes), 로지스틱 회귀에서는 이 과정이 복잡하고, 제조나 의료처럼 데이터가 나온 분야의 전문 지식이 있어야 좋은 특성을 설계할 수 있었다. 딥러닝은 은닉층을 깊게 쌓아 파라미터를 늘림으로써 특성 추출을 모델 학습 안으로 흡수했다. 앞쪽 층은 단순한 특징을, 뒤쪽 층은 그것을 조합한 복잡한 특징을 스스로 배운다.

빅데이터의 효율적 활용. 특성 추출을 학습으로 해결할 수 있는 것은 데이터가 많기 때문이다. 딥러닝의 특성 학습은 사례가 많을수록 좋아진다. 거꾸로 말하면 데이터가 적을 때는 딥러닝의 이점을 기대하기 어렵고, 3장의 머신 러닝 기법을 먼저 고려하는 것이 낫다.

4.3 딥러닝 알고리즘

📖 thebook.io

딥러닝 알고리즘은 모두 심층 신경망을 바탕으로 하며, 목적에 따라 합성곱 신경망(CNN), 순환 신경망(RNN), 제한된 볼츠만 머신(RBM), 심층 신뢰 신경망(DBN) 등으로 나뉜다.

4.3.1 심층 신경망

심층 신경망(DNN) 은 입력층과 출력층 사이에 은닉층이 여러 개 있는 신경망이다. 머신 러닝에서는 비선형 분류를 위해 커널 트릭 같은 별도의 기법이 필요했지만, 심층 신경망은 은닉층을 쌓는 것만으로 비선형 관계를 학습할 수 있다. 대신 연산량이 많고 기울기 소멸 같은 문제가 생기므로, 앞에서 본 드롭아웃, 렐루, 배치 정규화 등을 함께 적용한다.

4.3.2 합성곱 신경망

📖 thebook.io

합성곱 신경망(Convolutional Neural Network, CNN) 은 합성곱층(convolutional layer) 과 풀링층(pooling layer) 을 포함하는 신경망으로, 이미지 처리에 강하다. 사진이나 영상에서 객체, 얼굴, 장면을 인식하거나 객체의 위치를 찾는 데 쓴다. 대표 모델로 LeNet-5, AlexNet이 있고, 더 깊게 쌓은 모델로 VGG, GoogLeNet, ResNet이 있다.

일반적인 완전 연결 신경망과 비교한 특징은 다음과 같다.

  • 이미지를 1차원으로 펼치지 않고 입력과 출력의 공간 구조(높이 × 너비 × 채널)를 유지한다.
  • 공간 정보를 유지한 채 이웃 픽셀 사이의 차이(경계, 질감 등)를 효과적으로 잡아낸다.
  • 여러 개의 필터로 다양한 특징을 추출하고 학습한다.
  • 풀링층이 추출한 특징을 요약하고 강조한다.
  • 같은 필터를 이미지 전체에 공유해서 쓰므로 학습할 파라미터 수가 훨씬 적다.

자세한 내용은 5~6장에서 다룬다.

4.3.3 순환 신경망

📖 thebook.io

순환 신경망(Recurrent Neural Network, RNN) 은 음악, 영상, 문장처럼 시간 순서에 따라 변하는 데이터를 학습한다. “순환”은 자기 자신의 이전 출력을 다시 참조한다는 뜻으로, 현재 결과가 이전 결과의 영향을 받는다.

\[h_t = \tanh(W_x x_t + W_h h_{t-1} + b)\]

\(h_t\)는 시점 \(t\)의 은닉 상태로, 현재 입력 \(x_t\)와 직전 은닉 상태 \(h_{t-1}\)을 함께 받아 만들어진다. 특징은 다음과 같다.

  • 시간성(temporal property)을 가진 데이터를 다룬다.
  • 시간 정보를 이용해 데이터의 흐름을 잘 포착한다.
  • 데이터가 시간에 따라 바뀌므로 동적이고 길이가 가변적이다.
  • 매우 긴 시퀀스를 처리하는 방법이 활발히 연구되고 있다.

긴 시퀀스를 역전파할 때 기울기 소멸이 심해 학습이 잘 안 되므로, 기억을 조절하는 게이트(메모리 셀)를 도입한 LSTM(Long Short-Term Memory) 이 널리 쓰인다. 자연어 처리와 잘 맞으며 언어 모델링, 텍스트 생성, 기계 번역, 음성 인식, 이미지 캡션 생성 등에 쓰인다. 7장에서 자세히 다룬다.

4.3.4 제한된 볼츠만 머신

📖 thebook.io

볼츠만 머신(Boltzmann machine) 은 가시층(visible layer) 과 은닉층으로 이루어진 확률적 모델이다. 여기서 같은 층 안의 연결(가시층끼리, 은닉층끼리)을 모두 없애고 가시층과 은닉층 사이에만 연결을 둔 것이 제한된 볼츠만 머신(Restricted Boltzmann Machine, RBM) 이다.

은닉층   (h1)   (h2)   (h3)        같은 층 안에는 연결 없음
          │ ╲  ╱ │ ╲  ╱ │
          │  ╳   │  ╳   │          층 사이는 모두 연결 (양방향)
          │ ╱  ╲ │ ╱  ╲ │
가시층   (v1)   (v2)   (v3)   (v4)
  • 차원 축소, 분류, 선형 회귀, 협업 필터링(collaborative filtering), 특성 학습(feature learning), 주제 모델링(topic modeling) 등에 쓰인다.
  • 기울기 소멸 문제를 피하기 위한 사전 학습(pre-training) 용도로 쓸 수 있다.
  • 심층 신뢰 신경망의 구성 블록이 된다.

현재 딥러닝에서 주로 쓰는 것은 CNN과 RNN이고, RBM과 DBN은 상대적으로 덜 쓰이므로 개념만 알아 둔다.

4.3.5 심층 신뢰 신경망

📖 thebook.io

심층 신뢰 신경망(Deep Belief Network, DBN) 은 사전 훈련한 RBM을 블록처럼 여러 층 쌓아 올린 신경망이다. 레이블 없는 데이터로 비지도 학습이 가능하며, 부분적인 정보에서 전체를 떠올리는 일반화·추상화 과정을 구현하는 데 쓰인다. 학습 절차는 다음과 같다.

  1. 가시층과 첫 번째 은닉층을 하나의 RBM으로 보고 사전 훈련한다.
  2. 첫 번째 층의 파라미터를 고정하고, 그 은닉층 출력을 입력으로 삼아 두 번째 RBM을 사전 훈련한다.
  3. 원하는 층 수만큼 이를 반복해 쌓아 전체 DBN을 완성한다.

특징은 다음과 같다.

  • 층을 하나씩 순차적으로 학습시키며 계층 구조를 만든다(층별 탐욕적 학습).
  • 비지도 학습으로 학습한다.
  • 위층으로 갈수록 더 추상적인 특성을 뽑는다.
  • 이렇게 학습한 가중치를 다층 퍼셉트론의 초깃값으로 쓰고 지도 학습으로 미세 조정할 수 있다.

4.4 우리는 무엇을 배워야 할까?

📖 thebook.io

머신 러닝과 딥러닝 중 무엇을 쓸지는 데이터로 무엇을 얻고 싶은지에 달려 있다. 간단한 선형 회귀나 분류로 원하는 답을 얻을 수 있다면 머신 러닝으로 충분하고, 복잡한 비선형 데이터를 분류하거나 예측해야 한다면 딥러닝이 필요하다. 둘 다 원하는 결과를 얻기 위한 도구이며, 어떤 도구가 더 효과적인지는 데이터를 직접 모으고 분석하는 사람이 판단해야 한다. 이 책은 다음 장부터 딥러닝 도구를 하나씩 실습한다.

정리

  • 단층 퍼셉트론의 결정 경계는 직선이라 AND, OR은 풀지만 XOR은 풀 수 없다. 은닉층을 추가한 다층 퍼셉트론이 이를 해결했고, 은닉층이 여러 개인 신경망이 심층 신경망(딥러닝)이다.
  • 신경망은 가중합 \(z = \sum w_i x_i + b\)에 비선형 활성화 함수를 적용하는 층을 쌓은 것이다. 은닉층에는 ReLU(기울기 소멸 완화), 출력층에는 시그모이드(이진)나 소프트맥스(다중)를 주로 쓴다.
  • 손실 함수는 회귀에 MSE, 분류에 크로스 엔트로피를 쓴다. 파이토치 nn.CrossEntropyLoss는 로짓과 클래스 번호를 받고 소프트맥스를 내부에서 계산한다.
  • 학습은 순전파로 예측과 손실을 구하고, 역전파(연쇄 법칙)로 각 가중치의 기울기를 구해 \(w \leftarrow w - \eta \, \partial L / \partial w\)로 갱신하는 과정의 반복이다.
  • 층이 깊어지면 과적합(드롭아웃으로 완화), 기울기 소멸(ReLU로 완화), 느리고 불안정한 학습(미니 배치 경사 하강법과 옵티마이저로 완화) 문제가 생긴다.
  • 경사 하강법은 데이터 사용량에 따라 배치(정확하지만 느림), 확률적(빠르지만 요동), 미니 배치(실무 표준)로 나뉜다.
  • 옵티마이저는 학습률을 조정하는 Adagrad·Adadelta·RMSProp, 방향을 조정하는 Momentum·NAG, 둘을 합친 Adam으로 정리된다.
  • 딥러닝은 특성 추출을 학습에 통합하고 데이터가 많을수록 강해진다. 대표 알고리즘은 이미지용 CNN, 시계열용 RNN(LSTM)이며, RBM과 이를 쌓은 DBN은 사전 학습 기법으로 의미가 있다.