[D&A 운영진 딥러닝 스터디] 2주차 1차시

순전파(Forward Propagation)

• 올바른 순서대로 학습을 진행
• 최초 입력값으로부터 각 층마다 존재하는 가중치와 연산하고 활성화 함수를 통과하는 과정을 순서대로 이어나가 최종 layer까지 계산한 후 실제 label과 오차를 계산하는 것

역전파(Backward Propagation)

• 반대 방향으로 학습을 진행

• 순전파에서 계산한 오차를 기반으로 기울기를 사용하여 가중치 업데이트를 위해 시행

• 신호 E에 극소적 미분 $\cfrac{\partial y}{\partial x}$를 곱해 다음 노드로 전달

  • 중첩 시, 연쇄법칙(Chain rule)과 같아짐

(1) 덧셈 노드의 역전파

$z = x+y \\ \cfrac{\partial{z}}{\partial{x}} = 1 \\ \cfrac{\partial{z}}{\partial{y}} = 1$

역전파 시, 입력된 값 그대로 출력

(2) 곱셈 노드의 역전파

$z = xy \\ \cfrac{\partial{z}}{\partial{x}} = y \\ \cfrac{\partial{z}}{\partial{y}} = x$

입력된 신호의 서로 바꾼 값 출력

오차역전파법 사용하여 활성화 함수 구현

(1) ReLU

(2) Sigmoid

(3) Affine: 신경망의 순전파 때 사용하는 행렬곱

미니배치 단위로 계산할 때, 형상(shape)은 X = (n,x), Y = (n,y)

(4) Softmax with CEE

(y-t) 형태 = 현재 출력과 정답 레이블의 오차 그대로 드러냄
	-> 앞 계층들은 이를 통해 큰 깨달음 얻음
항등함수 SSE 조합도 (y-t) 형태로 나옴
	-> Softmax&CEE, 항등함수&SSE 사용하는 이유
    

실제 신경망 예시

최적화

매개변수의 최적값 찾는 문제

1. 확률적 경사하강법(Stochastic Gradient Descending)
   $W \larr W - \eta \cfrac{\partial L}{\partial W}$

• 기울어진 방향으로 일정 거리만 이동
• 단순하지만 비효율적(특히 비등방성 함수에서 비효율적)
• Batch 단위로 Back Propagation하기 때문에 일직선으로 이동하지 않음

2. 모멘텀(Momentum)
   $\begin{aligned} v &\larr \alpha v - \eta \cfrac{\partial L}{\partial W}\;\;\;\; (속도)\\ W &\larr W + v \end{aligned}$

• 운동량, 물리법칙을 응용한 방법
• 내려 오던 관성 방향으로 또 가자
• 지역해를 지나칠 수 있다는 장점 보유

3. NAG(Nestrov Accelrated Gradient)
   $v \larr \alpha v - \eta \cfrac{\partial L}{\partial (W-\alpha v)}\\ W \larr W + v$

• 모멘텀은 update과정에서 관성에 의해 최적점을 지나칠 수 있다.
• NAG는 모멘텀으로 이동된 지점에서 기울기를 활용하여 update를 수행하기 때문에 이러한 문제 해소(멈춰야하는 곳에서 제동)

4. AdaGrad(Adaptive Gradient)
   $h \larr h + \cfrac{\partial L}{\partial W} @\cfrac{\partial L}{\partial W}\\ W \larr W - \eta \cfrac{1}{\sqrt{h}} \cfrac{\partial L}{\partial W}$

• 학습률 감소기법 사용
• 처음에는 크게 학습하다가 점점 작게 학습
• 학습률 감소가 매개변수의 원소마다 다르게 적용
• 학습할수록 갱신량이 0에 수렴

5. RMSProp
   $G_t = \gamma G_{t-1} + (1-\gamma)(\cfrac{\partial L}{\partial W})^2\\ W_{t+1} = W_t - \cfrac{\eta}{\sqrt{G_t+\epsilon}}\cfrac{\partial L}{\partial W}$

• AdaGrad를 지수이동평균을 이용하여 개선
• 먼 과거의 기울기는 잊고, 새로운 기울기를 크게 반영한다.

6. AdaDelta(Adaptive Delta)
   $G_t = \gamma G_{t-1} + (1-\gamma)(\nabla_\theta J(\theta_t))^2\\ \Delta_\theta = \cfrac{\sqrt{s+\epsilon}}{G+\epsilon} \nabla_\theta J(\theta_t)\\ \theta_{t+1} \larr \theta_t - \Delta_\theta\\ s = \gamma s + (1-\gamma) \Delta_\theta ^2$

• Adagrad의 Gradient 양이 너무 적어져 움직임이 멈추는 단점 보완

7. Adam(Adaptive Moment Estimation)
   $m_t = \beta_1m_{t-1} + (1-\beta_1)\cfrac{\partial L}{\partial W}\\ v_t = \beta_2m_{t-1} + (1-\beta_2)(\cfrac{\partial L}{\partial W})^2\\ w_{t+1} = w_t - m_t \cfrac{\eta}{\sqrt{v_t+\epsilon}}$

• RMSprop과 Momentum을 합친 기법
• 초기 몇 번의 update에서 0으로 편향되어 있어 하이퍼파라미터 편향 보정 진행
• 하이퍼파라미터 3개 설정 ($\eta$-학습률, $\beta_1$-1차 모멘텀용 계수, $\beta_2$-2차 모멘텀용 계수)
• $\epsilon = 0.1^{-8}$, $\beta_1 = 0.9$, $\beta_2 = 0.999$ 추천

8. Nadam
   $m_t = \beta_1 m_{t-1} + (1 - \beta_1)\cfrac{\partial L}{\partial W_t}\\ \hat{m_t} = \cfrac{m_t}{1-\beta_1^t}\\ \theta_{t+1} = \theta_t - \cfrac{\eta}{\sqrt{\hat{v_t}}+\epsilon}\hat{m_t}\\ \theta_{t+1} = \theta_t - \cfrac{\eta}{\sqrt{\hat{v_t}}+\epsilon}(\cfrac{\beta_1m_{t-1}}{1-\beta_1^t}+\cfrac{(1-\beta_1)\cfrac{\partial L}{\partial W_t}}{1-\beta_1^t})\\ \theta_{t+1} = \theta_t - \cfrac{\eta}{\sqrt{\hat{v_t}}+\epsilon}(\beta_1\hat{m_{t-1}}+\cfrac{(1-\beta_1)\cfrac{\partial L}{\partial W_t}}{1-\beta_1^t})\\ \therefore \theta_{t+1} = \theta_t - \cfrac{\eta}{\sqrt{\hat{v_t}}+\epsilon}(\beta_1\hat{m_{t}}+\cfrac{(1-\beta_1)\cfrac{\partial L}{\partial W_t}}{1-\beta_1^t})$

• Adam은 RMSprop과 Momentum을 합친 기법이지만, Nadam은 RMSprop과 NAG를 합친 방법
• NAG는 변형하여 사용
  • $m_{t-1}$을 gradient를 업데이트 할 때와, $w$를 업데이트할 때 2번 사용
  • $m_{t-1}$ 대신 $m_t$ 사용

9. RAdam(Rectified Adam)

• 학습 초기에 샘플이 매우 부족하여 Adaptive Learning Rate의 분산이 매우 커지고 graident가 매우 작아짐
• 그로 인해 bad local optimum에 수렴하는 문제가 발생하는 것을 보완
• 이를 해결하기 위해 Adaptive Learning Rate Term의 분산을 교정
• learning rate를 어떻게 설정하든 성능이 비슷

가중치 초기값 설정

가중치 감소기법(weight decay)

• 오버피팅을 억제해 범용 성능 높이는 테크닉
• 가중치 매개변수의 값이 작아지도록 학습
• 그렇게 하기 위해 초깃값도 최대한 작은 값에서 시작
  • 그렇다고 하여 초기값을 0으로 설정할 시, 학습이 올바르게 시행되지 않음
  • 오차역전파법에서 모든 가중치의 값이 똑같이 갱신되기 때문

$\therefore$ 초기값을 무작위로 설정해야 함.

• 가중치를 표준편차($\sigma$)가 1인 정규분포로 초기화
  • 0과 1에 치우쳐 분포(= 기울기 소실)
• 가중치를 표준편차($\sigma$)가 0.01인 정규분포로 초기화
  • 0.5 부근에 집중됨 $\rarr$ 다수의 뉴런이 거의 같은 값 출력, 표현력이 제한됨

$\therefore$ 이 사이의 적당한 표준편차 값 지정하여 sampling해야 함!

LeCun 초기값

Xavier 초기값

• n은 앞 계층의 노드 개수이다.
• S자형 함수(Sigmoid, tanh)에 적합.

torch.nn.init.xavier_uniform_(linear1.weight)
torch.nn.init.xavier_normal_(linear1.weight)

He 초기값

• n은 앞 계층의 노드 개수이다.
• ReLU에 특화된 초기값
• 음이 영역이 0이라서 더 넓게 분포시키기 위해 2배의 계수가 필요

torch.nn.init.kaiming_uniform_(linear1.weight)
torch.nn.init.kaiming_normal_(linear1.weight)

RBM(Restricted Boltzmann Machine)

현재는 잘 사용하지 않지만 Xavier/He Initialization이 사용되기 전에는 RBM이 사용됨.

• Fully-Connected Layer을 학습시켜가며 가중치 학습(순전파(Encoding), 역전파(Decoding) 방법으로 학습)
• Pre-training

1. 우선 2개의 레이어 RBM으로 학습 ($X \rarr Y, Y \rarr X'$)
2. 그 다음 레이어를 1개 더 쌓는다. (이전 층의 가중치는 고정 후, 그 다음 층만 학습)
3. 위 단계를 마지막 레이어까지 반복
4. 그 후, 해당 weight를 사용하여 Fine-tuning

배치 정규화(Batch Normalization)

Internal Covariate Shift

각 Layer마다 Input의 분포가 달라짐에 따라 학습 속도가 느려지는 현상

• Covariate Shift: Train(Input)과 Test(Output)의 분포 차이가 문제를 발생시킴
• 딥러닝에서는 레이어 통과시마다 분포가 변화됨
• 레이어들 간에 Covariate Shift가 발생하기 때문에 이를 방지하기 위해 Batch Normalization을 진행

Batch Normalization

활성화 값이 적당히 분포되도록 조정

• 이점
  • 학습 속도 개선
  • 초기값에 크게 의존하지 않는다.
  • 오버피팅 억제
• 미니배치 단위로 평균이 0, 표준편차가 1이 되도록 정규화
  $\hat{x} \larr \cfrac{x-\mu}{\sqrt{\sigma+\epsilon}}$
• 활성화 함수의 앞 또는 뒤에 위치함으로써 분포가 덜 치우치게 함
• 정규화된 데이터에 고유한 확대(scale)와 이동(shift) 변환 수행
  $y \larr \gamma \hat{x} + \beta$
  • $\gamma$가 확대(scale), $\beta$가 이동(shift)을 담당
  • $\gamma = 1$, $\beta = 0$(원본 그대로)부터 시작하여 학습하면서 적합한 값으로 조정
  • 계속하여 normalization을 하게 되면 비선형성을 잃게 되는데, 이를 완화하기 위해 시행
    • ReLU 함수는 0 이하는 0, 0 이상은 x로 가져가는데, 선형 결합을 할 때 마다 분포가 우측으로 이동 해 비선형 활성 함수 사용의 의미 사라짐
• Batch Normalization의 단점 극복한 Layer Normalization 기법 등장

linear1 = torch.nn.Linear(784,32,bias=True)
linear2 = torch.nn.Linear(32,32,bias=True)
linear3 = torch.nn.Linear(32,10,bias=True)
relu = torch.nn.ReLU()
bn1 = torch.nn.BatchNorm1d(32)
bn2 = torch.nn.BatchNorm1d(32)

torch.nn.Sequential(linear1, bn1, relu,
                   linear2, bn2, relu,
                   linear3).to(device)

오버피팅

• 발생하는 경우
  • 매개변수가 많고 표현력이 높은 모델 사용
  • 훈련 데이터가 적음

1. 가중치 감소
   학습 과정에서 큰 가중치에 대해서는 그에 상응하는 큰 penalty 부여

• $L_2\, norm$ 활용한 예시
  • 모든 가중치 각각의 손실 함수에 $\cfrac{1}{2}\lambda W^2$을 더함($\lambda$: 정규화 정도 정함)
  • 기울기를 구하는 계산에서는 오차역전파법의 결과에 $\lambda W$(정규화항 미분값) 곱함

$L_1\,norm$: $|w_1| + |w_2| + ... + |w_n|$
$L_2\,norm$: $\sqrt{w_1^2 + w_2^2 + ... + w_n^2}$
$L_{\inf}\,norm$: 각 원소의 절대값 중 가장 큰 값

2. 드롭아웃(Dropout)

• 학습 시마다 은닉층의 뉴런을 무작위 삭제(weight matrix에 0 삽입)
• 시험 때는 모든 뉴런 사용 후, 각 뉴런의 출력에 훈련 때 삭제안한 비율 곱
  • model.tain()과 model.eval()은 실행 방법이 다르다.
• 뉴런을 무작위로 삭제하는 행위는 매번 다른 모델을 학습하는 것과 같은 효과($\sim$ 앙상블 학습)

torch.nn.Dropout(p=.3)

model = torch.nn.Sequential(linear1, relu, dropout,
                           linear2, relu, dropout,
                           linear3, relu, dropout,
                           linear4, relu, dropout,
                           linear5).to(device)

적절한 하이퍼파라미터 값 찾기

1. 검증 데이터 사용

• 하이퍼파라미터 성능 검증 시 시험 데이터를 사용하면 안됨($\because$ 오버피팅)
• 훈련데이터는 매개변수 학습, 검증데이터는 하이퍼파라미터 성능 평가, 시험데이터는 신경망의 범용 성능 평가에 사용

2. 하이퍼파라미터 최적화

• 그리드 서치(Grid Search)
• 랜덤 서치(Randomized Search)
• 베이지안 최적화(Bayesian Optimization)

여러가지 딥러닝 학습 관련 기술 사용하여 pytorch로 모델링

# Modeling
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 10)
        self.dropout_prob = 0.5
        self.batch_norm1 = nn.Batchnorm1d(512)
        self.batch_norm2 = nn.Batchnorm1d(256)
        
    def forward(self, x):
        x = x.view(-1, 28*28)
        x = self.fc1(x)
        x = self.batch_norm1(x)
        x = self.nn.functional.relu(x)
        x = self.nn.functional.dropout(x, training=self.training, p=self.dropout_prob)
        # self.training은 학습 중인지 여부를 판단하여 Boolean 반환
        # training 인자는 학습 시와 평가 시에 dropout의 작동방법 다르게 시행
        x = self.fc2(x)
        x = self.batch_norm2(x)
        x = self.nn.functional.relu(x)
        x = self.nn.functional.dropout(x, training=self.training, p=self.dropout_prob)
        x = self.fc3(x)
        return x

# Initialization&Optimizer&Loss
def weight_init(m): # weight 초기화 할 부분 설정(m)
    if isinstance(m): # 여러 파라미터 중 nn.Linear에 해당하는 파라미터 값에 대해서만 지정
        init.kaiming_uniform_(m.weight.data) # he_initialization 적용
        
model = Net().to(device)
model.apply(weight_init) # 해당 함수를 model에 적용
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
criterion = nn.CrossEntropyLoss()

참고
밑바닥부터 시작하는 딥러닝 (사이토 고키)
파이썬 딥러닝 파이토치 (이경택, 방성수, 안상준)
모두를 위한 딥러닝 시즌 2 Lab 9-2, 9-3, 9-4
https://onevision.tistory.com/entry/Optimizer-%EC%9D%98-%EC%A2%85%EB%A5%98%EC%99%80-%ED%8A%B9%EC%84%B1-Momentum-RMSProp-Adam
https://hiddenbeginner.github.io/deeplearning/2019/09/22/optimization_algorithms_in_deep_learning.html#NAdam