Optimization 최적화 기본 용어와 Optimizer 종류

<목차>
1. Generalization
2. Under- fitting, Balanced, Over-fitting
3. Cross validation
- hyper parameter VS parameter
4. Bias-variance tradeoff
- bias
- variance
5. Bootstraping
6. Bagging, Boosting

 

Optimization이란?

딥러닝 학습에서는 최대한 틀리지 않는 방향으로 학습해 나가야한다.

이때 얼마나 틀렸는 지를 확인하는 함수가 loss function이고, 다시 말해 loss func의 최소값을 찾는 것이 학습의 목표임.

loss function의 최솟값을 찾는 과정을 최적화라고 하고

이를 수행하는 알고리즘이 최적화 알고리즘 Optimizer임.

---

 

• Generalization

generalization gap: Test error와 Training error 사이 gap

일반화 성능을 높이는 게 좋을까?

network가 안 좋아서 학습데이터의 성능이 안 좋으면 일반화 성능이 좋다고 해서 test 성능이 좋은 거 아님

---

• Under-fitting
• Over-fitting : Training data에는 잘 동작. Test data에서는 잘 동작 안함

 

---

• Cross Validation:

보통은 train set 으로 모델을 훈련, test set으로 모델을 검증한다. 고정된 test set을 통해 모델의 성능을 검증하고 수정하는 과정을 반복하면, 결국 내가 만든 모델은 test set 에만 잘 동작하는 모델이 된다. 즉, test set에 과적합(overfitting)하게 되므로, 다른 실제 데이터를 가져와 예측을 수행하면 엉망인 결과가 나와버리게 된다. 이를 해결하고자 하는 것이 바로 교차 검증(cross validation)이다. 교차 검증은 train set을 train set + validation set으로 분리한 뒤, validation set을 사용해 검증하는 방식이다.

 

어떤 경우에 쓰이냐

-> NN 학습하는데 있어서 많은 hyper parameter 존재. Parameter은 최적해서 찾고 싶은 값(ex. convolution filter의 값, multi layer perceptron weight) <-> hyper parameter은 정하는 값(ex. learning rate, loss function) 어떻게 좋은 지 모름. 그래서 cross validation을 통해 최적 hyper parameter찾고 고정해서 학습할 때 모든 data 다 사용

 

Test data를 사용해서 cross validation 포함 활용을 절대 안함!!

 

<Cross Validation의 방법>

1) holdout CV
특정 비율로 train/validation을 1회 분할하는 방법

2) k-fold CV
(가장 일반적인 방법) 전체 데이터셋을 k개의 fold로 나누어
fold 1개를 validation data로, 나머지 (k-1)개의 fold를 train data로 분할하는 과정을 반복함으로써 train 및 validation data를 교차 변경하는 방법
따라서 모델을 학습 및 훈련하는데 총 k번의 Iteration이 필요하고, 각 데이터 폴드 세트에 대해서 나온 검증 결과들을 평균내어 최종적인 검증 결과를 도출하는 것이 일반적임.

3) Leave P out CV
전체 데이터 N개 중에서 p개의 샘플을 선택하여 모델 검증에 활용하는 방법
k-겹 교차 검증 방법과 마찬가지로, 각 데이터 폴드 세트에 대해서 나온 검증 결과들을 평균내어 최종적인 검증 결과를 도출하는 것이 일반적임
구성할 수 있는 데이터 폴드 세트의 경우의 수가 매우 크기 때문에, 계산 시간에 대한 부담이 매우 큼

4) Leave one out CV
leave-p-out cross validation에서 p=1일 때의 경우를 말한다.

주황색: train / 초록색: validation

 

Time Series(시계열 데이터)는 k-fold 교차 검증을 사용할 수 없는 이유   참고

[1] Temporal dependency     시간적 종속성
     시계열 데이터는 시간의 순서를 고려해야 하는데 k-fold는 시간의 흐름이 바뀐다.
[2] Arbitrary choice of test set       테스트 세트의 임의 선택
     k-fold는 임의적으로 test set을 선택하고 이는 오류가 독립적인 test set에 대해서는 잘못된 추정값임

=> 해결책은 Nested Cross-Validation (Rolling이라고도 불림)
Nested CV는 outer loop에서 error estimation을 진행하고, inner loop에서는 parameter tuning이 진행됨.

Nested CV의 문제점은 각 loop마다 모델의 input shape가 달라진다는 것임.
따라서 실제 필드에서 이가 문제가 될 경우 blocking 방식을 통해 데이터를 블록화해서 해결함.

---

 

• Bias-variance tradeoff

Variance: 비슷한 입력을 넣었을 때 출력이 얼마나 일관적인가. 정답과 상관없이 predict값들이 얼마나 떨어져있냐를 나타낸 정도이다. variance가 높다는 것은 feature가 조금만 달라져도 predict값이 크게 달라진다는 뜻이기에 민감도가 높다. 때문에 overfitting인 경우 variance가 높다.

Bias: 평균적으로 target에 유사

 

Bias-variance tradeoff: 노이즈가 있는 학습 data. cost를 minimize하는 건 세 가지로 나뉨

cost = bias^2+ variance + noise

variance가 낮아지면 bias가 커짐. bias가 낮아지면 variance가 커짐.

 

---

• Bootstrapping

any test or metric that uses random sampling with replacement

학습 데이터가 고정되어 있을 때 sub sampling을 통해서 학습 데이터를 여러 개를 만들어 여러 모델로 만들어서 무언 갈 하겠다 

---

• Ensemble (조화, 통일을 의미하기도 함)

어떤 데이터의 값을 예측한다고 할 때, 하나의 모델을 사용하기 보다 여러 개의 모델을 조화롭게 학습시켜 그 모델들의 예측 결과들을 이용한다면 더 정확한 예측값을 구할 수 있을 것임

핵심: Weak Classifier을 결합하여 Strong Classifier을 만듦

앙상블 학습법에는 Bagging과 Boosting이 있음

---

• Bagging and Boosting

Bagging (Bootstrapping aggregating) : 샘플을 여러 번 뽑아(Bootstrap) 각 모델을 학습시켜 결과물을 집계(Aggregration)하는 방법

학습 데이터를 전부 사용해서 모델을 하나 학습하는 게 아님. random sampling을 통해 여러 개의 모델을 만들고 여러 모델을 가지고 output을 평균 내겠다

 

Boosting : 학습데이터가 100개가 있으면 sequential 하게 바라봐서 모델 하나 간단한 걸 만들고 이 모델을 학습 데이터에 대해 돌려봄. 그 결과 20개에 대해 잘 안됨. 다음 모델을 만들 때는 20개에 대해서 잘 되게. ... 이렇게 여러 개 모델을 만들어서 합침. 

weak learner을 sequence하게 합쳐서 하나의 strong model을 만듦.

 

Bagging	- 병렬로 학습 - 오버 피팅이 문제라면 배깅이 적합
Boosting	- 순차적으로 학습 - 한번 학습이 끝난 후 결과에 따라 가중치를 부여합니다. 그렇게 부여된 가중치가 다음 모델의 결과 예측에 영향을 줍니다. 오답에 대해서는 높은 가중치를 부여하고, 정답에 대해서는 낮은 가중치를 부여합니다. 따라서 오답을 정답으로 맞추기 위해 오답에 더 집중할 수 있게 되는 것입니다.  -  배깅에 비해 error가 적습니다. 즉, 성능이 좋습니다. 하지만 속도가 느리고 오버 피팅이 될 가능성이 있습니다. - 개별 결정 트리의 낮은 성능이 문제라면 부스팅이 적합

---

<목차>
1. Stochastic, Mini-batch, Batch Gradient Descent
-  flat minimizer(작은 batch size) VS sharp minimizer
2. stochastic gradient descent
    Momentum VS Nesterov accelerated gradient
    Adagrad, Adadelta, RMSprop
    Adam

 

1. Stochastic Gradient Descent

Single sample로부터 gradient를 계산해서 update

2. Mini-batch Gradient Descent

Subset of data로부터 gradient를 계산해서 update

3. Batch Gradient Descent

전체 data로부터 gradient를 계산해서 update

 

올바르게 training한 사례: total-batch를 적용할 수 있는 사양이 충분함에도 mini-batch algorithm을 적용하였다
이유: full-batch 보다 mini-batch를 적용하는 것이 속도, generalization의 측면에서 훨씬 효율적인 경우가 많습니다.

 

 

우리는 batch 기반 최적화를 할 때, batch-size matters를 고려할 줄 알아야 함

• 큰 batch size를 사용하게 되면 sharp minimizer에 도달하게 됨
• 작은 batch size를 사용하게 되면 flat minimizer에 도달하게 됨

Flat minimizer에 도달하는 게 더 좋다

Flat minimizer에 도달하는 게 더 좋다

Flat minimizer= generalization performance이 높음(training,testing func가 비슷)

---

Optimizer

• Stochastic gradient descent

NN, 딥러닝 프레임워크가 기본적으로 Gradient는 계산해줌

문제: learning rate, step size를 찾기가 어려움

 

 

• Momentum : 관성

한 번 이 방향으로 흐르면 다음 번에 쪼끔 다르게 흘러도 그 방향으로 흐르게 하자(정보를 이어가자)

g라는 gradient가 현재 들어왔다면 다음 번에 들어온 정보 버리고 a라고 불리는 momentum에 해당하는 값 사용

(장점) gradient가 크게 왔다갔다해도 어느 정도 잘 학습이 되는 효과

(장점) Momentum 방식을 이용할 경우 위의 그림과 같이 local minima를 빠져나오는 효과가 있을 것이라고도 기대할 수 있다. 기존의 SGD를 이용할 경우 좌측의 local minima에 빠지면 gradient가 0이 되어 이동할 수가 없지만, momentum 방식의 경우 기존에 이동했던 방향에 관성이 있어 이 local minima를 빠져나오고 더 좋은 minima로 이동할 것을 기대할 수 있게 된다.

(단점) 반면 momentum 방식을 이용할 경우 기존의 변수들 외에도 과거에 이동했던 양을 변수별로 저장해야하므로 변수에 대한 메모리가 기존의 두 배로 필요하게 된다.

 

 

• Nesterov accelerated gradient

Momentum은 현재 주어져 있는 parameter에서 gradient를 계산해서 그 gradient를 가지고 momentum을 accumulation을 함

<->

a라고 불리는 accumulated gradient가 결국 gradient descent를 하는 것

한 번 이동. a라고 불리는 현재 정보 대로 한 번 가보고 그 gradient를 가지고 accumulation

momentum에서는 local minimum에서 converge를 못하는 현상 발생 

<-> NAG는 한 번 지나간 점에서 계산하므로 local minimum 지나서 아래로 다시 흐름

 

NAG의 장점

봉우리의 가장 끝점인 local minimum에 빨리 converge하는 효과

 

 

• Adagrad

변수들을 update할 때 각각의 변수마다 step size를 다르게 설정해서 이동하는 방식

NN의 parameter가 얼만큼 지금까지 많이 변해왔는지, 안 변해왔는지 확인

많이 변해온 parameter은 앞으로 적게 변화시킴 (안 변한 parameter은 많이 변화시킴)

얼만큼 변했는 지 저장하는 값이 G(얼마나 변했는지를 제곱해서 더 한 값. 클수록 많이 변했다는 뜻)

 

문제: Adagrad에는 학습을 계속 진행하면 step size가 너무 줄어든다.

G가 계속 커지니까 G가 무한대로 가게 되면 W가 업데이트 안됨. 뒤로 갈 수록 학습이 멈춰짐

해결: Adadelta, RMSProp

 

 

• Adadelta

Wt 는 실제로 업데이트 하려고 하는 weight의 변화값. 바꿀 수 있는 요소가 많이 없어 활용 잘 안됨

- No learning rate in Adadelta

현재 timestep t가 주어졌을 때 window size만큼의 parameter(시간에 대한 gradient 제곱의 변화)를 보겠다

Adagrad의 식에서 gradient의 제곱값을 더해나가면서 구한 Gt 부분을 합이 아니라 지수평균으로 바꾸어서 대체한 방법

G를 구할 때 합을 구하는 대신 지수평균을 구한다

 

(문제) window size만큼 g라는 정보를 저장하고 있어야함

(해결) exponential moving average  = Gt

 

 

 

• RMSprop

Gradient square를 그냥 더하지 않고 exponential moving average를 구함

Adadelta와의 차이: stepsize가 있음

 

 

• Adam

RMSProp과 Momentum 방식을 합친 것 같은 알고리즘

Momentum 방식과 유사하게 지금까지 계산해온 기울기의 지수평균을 저장하며, RMSProp과 유사하게 기울기의 제곱값의 지수평균을 저장

squared gradient와  momentum 모두 사용

 

 

 

실습으로 Optimizer 정확도 비교해보기

결과는 성능 차이가 꽤 난다. adam이 짱이다. sgd보다는 momentum이 낫다.

 

dataset (얘를 맞춰야함)

n_data = 10000
x_numpy = -3+6*np.random.rand(n_data,1)
y_numpy = np.exp(-(x_numpy**2))*np.cos(10*x_numpy) + 3e-2*np.random.randn(n_data,1)
plt.figure(figsize=(8,5))
plt.plot(x_numpy,y_numpy,'r.',ms=2)
plt.show()
x_torch = torch.Tensor(x_numpy).to(device)
y_torch = torch.Tensor(y_numpy).to(device)
print ("Done.")

 

define model

class Model(nn.Module):
    def __init__(self,name='mlp',xdim=1,hdims=[16,16],ydim=1):
        super(Model, self).__init__()
        self.name = name
        self.xdim = xdim
        self.hdims = hdims
        self.ydim = ydim

        self.layers = []
        prev_hdim = self.xdim
        for hdim in self.hdims:
            self.layers.append(nn.Linear(prev_hdim, hdim, bias=True))
            self.layers.append(nn.Tanh())  # activation
            prev_hdim = hdim
        # Final layer (without activation)
        self.layers.append(nn.Linear(prev_hdim,self.ydim,bias=True))

        # Concatenate all layers 
        self.net = nn.Sequential()
        for l_idx,layer in enumerate(self.layers):
            layer_name = "%s_%02d"%(type(layer).__name__.lower(),l_idx)
            self.net.add_module(layer_name,layer)

        self.init_param() # initialize parameters
    
    def init_param(self):
        for m in self.modules():
            if isinstance(m,nn.Conv2d): # init conv
                nn.init.kaiming_normal_(m.weight)
                nn.init.zeros_(m.bias)
            elif isinstance(m,nn.Linear): # lnit dense
                nn.init.kaiming_normal_(m.weight)
                nn.init.zeros_(m.bias)
    
    def forward(self,x):
        return self.net(x)

print ("Done.")

LEARNING_RATE = 1e-2
# Instantiate models
model_sgd = Model(name='mlp_sgd',xdim=1,hdims=[64,64],ydim=1).to(device)
model_momentum = Model(name='mlp_momentum',xdim=1,hdims=[64,64],ydim=1).to(device)
model_adam = Model(name='mlp_adam',xdim=1,hdims=[64,64],ydim=1).to(device)
# Optimizers
loss = nn.MSELoss()
optm_sgd = optim.SGD(model_sgd.parameters(), lr = LEARNING_RATE)
optm_momentum = optim.SGD(model_momentum.parameters(), lr = LEARNING_RATE)
optm_adam = optim.Adam(model_adam.parameters(), lr = LEARNING_RATE)
print ("Done.")

 

 

Train (하면서 그래프로 결과 확인)

MAX_ITER,BATCH_SIZE,PLOT_EVERY = 1e4,64,500

model_sgd.init_param()
model_momentum.init_param()
model_adam.init_param()

model_sgd.train()
model_momentum.train()
model_adam.train()

for it in range(int(MAX_ITER)):
    r_idx = np.random.permutation(n_data)[:BATCH_SIZE]
    batch_x,batch_y = x_torch[r_idx],y_torch[r_idx] # 전체 torch에서 batch를 뜯어옴
    
    # Update with Adam
    y_pred_adam = model_adam.forward(batch_x)
    loss_adam = loss(y_pred_adam,batch_y)
    optm_adam.zero_grad()
    loss_adam.backward()
    optm_adam.step()

    # Update with Momentum
    y_pred_momentum = model_momentum.forward(batch_x)
    loss_momentum = loss(y_pred_momentum,batch_y)
    optm_momentum.zero_grad()
    loss_momentum.backward()
    optm_momentum.step()

    # Update with SGD
    y_pred_sgd = model_sgd.forward(batch_x)
    loss_sgd = loss(y_pred_sgd,batch_y)
    optm_sgd.zero_grad()
    loss_sgd.backward()
    optm_sgd.step()
    

    # Plot
    if ((it%PLOT_EVERY)==0) or (it==0) or (it==(MAX_ITER-1)):
        with torch.no_grad():
            y_sgd_numpy = model_sgd.forward(x_torch).cpu().detach().numpy()
            y_momentum_numpy = model_momentum.forward(x_torch).cpu().detach().numpy()
            y_adam_numpy = model_adam.forward(x_torch).cpu().detach().numpy()
            
            plt.figure(figsize=(8,4))
            plt.plot(x_numpy,y_numpy,'r.',ms=4,label='GT')
            plt.plot(x_numpy,y_sgd_numpy,'g.',ms=2,label='SGD')
            plt.plot(x_numpy,y_momentum_numpy,'b.',ms=2,label='Momentum')
            plt.plot(x_numpy,y_adam_numpy,'k.',ms=2,label='ADAM')
            plt.title("[%d/%d]"%(it,MAX_ITER),fontsize=15)
            #plt.legend(labelcolor='linecolor',loc='upper right',fontsize=15)
            plt.show()

print ("Done.")