TensorFlow의 기울기 하강 vs Adagrad vs Momentum

TensorFlow의 기울기 하강 vs Adagrad vs Momentum

---

저는 신경망과 딥 러닝의 전문가가 아니더라도 TensorFlow 와 사용 방법을 연구하고 있습니다 (기본 사항).

튜토리얼에 따르면 손실에 대한 세 가지 최적화 프로그램의 실제적이고 실제적인 차이점을 이해하지 못합니다. API를 보고 원칙을 이해하지만 질문은 다음과 같습니다.

1. 다른 것 대신 하나를 사용하는 것이 언제 더 좋습니까?

2. 알아야 할 중요한 차이점이 있습니까?

---

내 이해를 바탕으로 한 간단한 설명은 다음과 같습니다.

• 모멘텀 은 SGD가 관련 방향을 따라 탐색하고 관련없는 진동을 완화하는 데 도움 이됩니다. 단순히 이전 단계의 방향의 일부를 현재 단계에 추가합니다. 이를 통해 올바른 방향으로 속도를 증폭하고 잘못된 방향으로 진동을 완화합니다. 이 분수는 일반적으로 (0, 1) 범위에 있습니다. 또한 적응 운동량을 사용하는 것이 좋습니다. 학습 초기에 큰 추진력은 진행을 방해 할 뿐이므로 0.01과 같은 것을 사용하는 것이 합리적이며 모든 높은 기울기가 사라지면 더 큰 추진력을 사용할 수 있습니다. 운동량에는 한 가지 문제가 있습니다. 우리가 목표에 매우 가까워지면 대부분의 경우 운동량이 매우 높고 속도를 늦춰야한다는 사실을 모릅니다. 이로 인해 최소값을 놓치거나 진동 할 수 있습니다.
• nesterov 가속 그라디언트 는 일찍 속도를 늦추기 시작하여이 문제를 극복합니다. 운동량에서 우리는 먼저 기울기를 계산 한 다음 이전에 가졌던 운동량으로 증폭 된 방향으로 점프합니다. NAG는 동일한 작업을 수행하지만 다른 순서로 수행합니다. 처음에는 저장된 정보를 기반으로 크게 점프 한 다음 그라디언트를 계산하고 작은 수정을합니다. 겉보기에 무관 해 보이는이 변화는 실질적인 속도 향상을 가져옵니다.
• AdaGrad 또는 적응 형 기울기를 사용하면 매개 변수에 따라 학습률을 조정할 수 있습니다. 자주 사용하지 않는 매개 변수에 대해서는 더 큰 업데이트를 수행하고 빈번한 매개 변수에는 작은 업데이트를 수행합니다. 이 때문에 희소 데이터 (NLP 또는 이미지 인식)에 적합합니다. 또 다른 장점은 기본적으로 학습률을 조정할 필요가 없다는 것입니다. 각 매개 변수에는 자체 학습률이 있으며 알고리즘의 특성으로 인해 학습률은 단조롭게 감소합니다. 이로 인해 가장 큰 문제가 발생합니다. 어떤 시점에서 학습률이 너무 작아서 시스템이 학습을 중단합니다.
• AdaDelta 는 AdaGrad에서 학습률이 단조롭게 감소하는 문제를 해결합니다 . AdaGrad에서 학습률은 대략 1을 제곱근의 합으로 나눈 값으로 계산되었습니다. 각 단계에서 합계에 또 다른 제곱근을 추가하면 분모가 지속적으로 증가합니다. AdaDelta에서는 과거 제곱근을 모두 합하는 대신 합계를 줄일 수있는 슬라이딩 윈도우를 사용합니다. RMSprop 는 AdaDelta 와 매우 유사합니다.

• Adam 또는 적응 운동량은 AdaDelta와 유사한 알고리즘입니다. 그러나 각 매개 변수에 대한 학습률을 저장하는 것 외에도 각 매개 변수에 대한 운동량 변화를 개별적으로 저장합니다.

  몇 시각화 :

SGD, Momentum 및 Nesterov는 지난 3 개보다 열등하다고 말할 수 있습니다.

---

Salvador Dali의 답변은 이미 일부 인기있는 방법 (예 : 최적화 프로그램)의 차이점에 대해 설명하지만 좀 더 자세히 설명하려고합니다.
(특히 ADAGRAD와 관련하여 일부 요점에 대한 답변이 일치하지 않습니다.)

클래식 모멘텀 (CM)과 Nesterov의 가속 기울기 (NAG)

(대부분 딥 러닝에서 초기화 및 모멘텀의 중요성 에 대한 논문의 섹션 2를 기반으로합니다 .)

CM과 NAG의 각 단계는 실제로 두 개의 하위 단계로 구성됩니다.

• 모멘텀 하위 단계-이것은 단순히 [0.9,1)마지막 단계 의 일부 (일반적으로 범위에 있음 )입니다.
• 기울기 종속 하위 단계-이것은 SGD 의 일반적인 단계와 유사합니다 . 학습률과 기울기 반대 벡터의 곱이며 기울기는이 하위 단계가 시작되는 위치에서 계산됩니다.

CM은 기울기 하위 단계를 먼저 수행하고 NAG는 모멘텀 하위 단계를 먼저 수행합니다.

다음은 CM 및 NAG에 대한 직관에 대한 답변 의 데모입니다 .

그래서 NAG가 (적어도 이미지에서) 더 나은 것 같지만 왜?

주목해야 할 중요한 점은 모멘텀 하위 단계가 언제 오든 중요하지 않다는 것입니다. 어느 쪽이든 동일 할 것입니다. 따라서 우리는 모멘텀 하위 단계가 이미 수행 된 경우 행동 할 수 있습니다.

따라서 실제로 질문은 다음과 같습니다. 기울기 하위 단계가 운동량 하위 단계 이후에 취해 졌다고 가정하면 기울기 하위 단계가 운동량 하위 단계를 취하기 전이나 후에 시작된 것처럼 기울기 하위 단계를 계산해야합니까?

"그 후"는 정답 인 것 같습니다. 일반적으로 어떤 지점의 그래디언트는 θ대략적 θ으로 최소 (상대적으로 올바른 크기) 방향을 가리키는 반면 다른 지점의 그래디언트는 사용자를 가리킬 가능성이 적습니다. θ최소 방향 (상대적으로 올바른 크기).

다음은 데모입니다 (아래 gif에서) :

• 최소값은 별이있는 곳이고 곡선은 등고선입니다 . (등고선이 그래디언트에 수직 인 이유에 대한 설명은 전설적인 3Blue1Brown의 비디오 1 과 2 를 참조하십시오 .)
• (긴) 보라색 화살표는 모멘텀 하위 단계입니다.
• 투명한 빨간색 화살표는 운동량 하위 단계 이전에 시작되는 경우 그라데이션 하위 단계입니다.
• 검은 색 화살표는 운동량 하위 단계 이후에 시작되는 경우 그라데이션 하위 단계입니다.
• CM은 짙은 빨간색 화살표의 대상에 도달합니다.
• NAG는 검은 색 화살표의 표적이됩니다.

NAG가 더 나은 이유에 대한이 주장은 알고리즘이 최소값에 가까운 지 여부와 무관합니다.
일반적으로 NAG와 CM은 모두 자신에게 좋은 것보다 더 많은 모멘텀을 축적하는 문제가 있기 때문에 방향을 바꿔야 할 때마다 당황스러운 "응답 시간"이 있습니다. 설명했던 CM보다 NAG의 장점은 문제를 예방하는 것이 아니라 NAG의 "응답 시간"을 덜 부끄럽게 만들뿐입니다 (그러나 여전히 부끄럽습니다).

이 "응답 시간"문제는 Alec Radford ( Salvador Dali의 답변 ) 의 gif에서 아름답게 설명됩니다 .

ADAGRAD

(대부분 ADADELTA : A Adaptive Learning Rate Method (원본 ADADELTA 논문)의 섹션 2.2.2를 기반으로하며 , Adaptive Subgradient Methods for Online Learning and Stochastic Optimization (원본 ADAGRAD 논문) 보다 훨씬 더 접근 하기 쉽습니다.)

에서는 SGD , 단계는 다음과 같이 주어진다 - learning_rate * gradient동안 learning_ratehyperparameter이다.
ADAGRAD에는 learning_rate하이퍼 파라미터도 있지만 그래디언트의 각 구성 요소에 대한 실제 학습률은 개별적으로 계산됩니다. -th 단계
의 i-th 구성 요소는 다음과 같이 t지정됩니다.

              learning_rate 
- --------------------------------------- * gradient_i_t
  norm((gradient_i_1, ..., gradient_i_t))

동안:

• gradient_i_k-th 단계 i에서 그라디언트 의 -th 구성 요소입니다.k
• (gradient_i_1, ..., gradient_i_t)t성분 이있는 벡터입니다 . 이러한 벡터를 구성하는 것이 타당하다는 것은 (적어도 나에게는) 직관적이지 않지만 알고리즘이 (개념적으로)하는 일입니다.
• norm(vector)의 Eucldiean norm (일명 l2norm) vector은 길이에 대한 직관적 인 개념입니다 vector.
• 혼란스럽게도 ADAGRAD (및 일부 다른 방법)에서 곱해지는 표현식 gradient_i_t(이 경우 learning_rate / norm(...))은 종종 "학습률"이라고합니다 (사실 이전 단락에서 "실제 학습률"이라고했습니다. ). SGD 에서 learning_rate하이퍼 파라미터와이 표현식이 하나이고 동일 하기 때문이라고 생각합니다 .
• 실제 구현에서는 0으로 나누는 것을 방지하기 위해 일부 상수가 분모에 추가됩니다.

예 :

• 첫 i번째 단계에서 그라디언트 의- 번째 구성 요소는1.15
• 두 i번째 단계에서 그라디언트 의- 번째 구성 요소는1.35
• i세 번째 단계에서 그라디언트 의- 번째 구성 요소는0.9

그런 다음의 표준은 (1.15, 1.35, 0.9)노란색 선의 길이입니다
sqrt(1.15^2 + 1.35^2 + 0.9^2) = 1.989.
따라서 i세 번째 단계 의- 번째 구성 요소는 다음과 같습니다.- learning_rate / 1.989 * 0.9

i단계 의- 번째 구성 요소에 대한 두 가지 사항에 유의하십시오 .

1. 에 비례합니다 learning_rate.
2. 계산에서 표준이 증가하고 있으므로 학습률이 감소하고 있습니다.

이것은 ADAGRAD가 하이퍼 파라미터의 선택에 민감하다는 것을 의미합니다 learning_rate.
또한 시간이 지나면 단계가 너무 작아 져 ADAGRAD가 사실상 멈출 수 있습니다.

ADADELTA 및 RMSProp

From the ADADELTA paper:

The idea presented in this paper was derived from ADAGRAD in order to improve upon the two main drawbacks of the method: 1) the continual decay of learning rates throughout training, and 2) the need for a manually selected global learning rate.

The paper then explains an improvement that is meant to tackle the first drawback:

Instead of accumulating the sum of squared gradients over all time, we restricted the window of past gradients that are accumulated to be some fixed size w [...]. This ensures that learning continues to make progress even after many iterations of updates have been done.
Since storing w previous squared gradients is inefficient, our methods implements this accumulation as an exponentially decaying average of the squared gradients.

By "exponentially decaying average of the squared gradients" the paper means that for each i we compute a weighted average of all of the squared i-th components of all of the gradients that were calculated.
The weight of each squared i-th component is bigger than the weight of the squared i-th component in the previous step.

This is an approximation of a window of size w because the weights in earlier steps are very small.

(When I think about an exponentially decaying average, I like to visualize a comet's trail, which becomes dimmer and dimmer as it gets further from the comet:

)

If you make only this change to ADAGRAD, then you will get RMSProp, which is a method that was proposed by Geoff Hinton in Lecture 6e of his Coursera Class.

So in RMSProp, the i-th component of the t-th step is given by:

                   learning_rate
- ------------------------------------------------ * gradient_i_t
  sqrt(exp_decay_avg_of_squared_grads_i + epsilon)

while:

• epsilon is a hyperparameter that prevents a division by zero.
• exp_decay_avg_of_squared_grads_i is an exponentially decaying average of the squared i-th components of all of the gradients calculated (including gradient_i_t).

But as aforementioned, ADADELTA also aims to get rid of the learning_rate hyperparameter, so there must be more stuff going on in it.

In ADADELTA, the i-th component of the t-th step is given by:

  sqrt(exp_decay_avg_of_squared_steps_i + epsilon)
- ------------------------------------------------ * gradient_i_t
  sqrt(exp_decay_avg_of_squared_grads_i + epsilon) 

while exp_decay_avg_of_squared_steps_i is an exponentially decaying average of the squared i-th components of all of the steps calculated (until the t-1-th step).
sqrt(exp_decay_avg_of_squared_steps_i + epsilon) is somewhat similar to momentum, and according to the paper, it "acts as an acceleration term". (The paper also gives another reason for why it was added, but my answer is already too long, so if you are curious, check out section 3.2.)

Adam

(Mostly based on Adam: A Method for Stochastic Optimization, the original Adam paper.)

Adam is short for Adaptive Moment Estimation (see this answer for an explanation about the name).
The i-th component of the t-th step is given by:

                   learning_rate
- ------------------------------------------------ * exp_decay_avg_of_grads_i
  sqrt(exp_decay_avg_of_squared_grads_i) + epsilon

while:

• exp_decay_avg_of_grads_i is an exponentially decaying average of the i-th components of all of the gradients calculated (including gradient_i_t).
• Actually, both exp_decay_avg_of_grads_i and exp_decay_avg_of_squared_grads_i are also corrected to account for a bias toward 0 (for more about that, see section 3 in the paper, and also an answer in stats.stackexchange).

Note that Adam uses an exponentially decaying average of the i-th components of the gradients where most SGD methods use the i-th component of the current gradient. This causes Adam to behave like "a heavy ball with friction", as explained in the paper GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium.
See this answer for more about how Adam's momentum-like behavior is different from the usual momentum-like behavior.

---

Let's boil it down to a couple of simple question:

Which optimizer would give me the best result/accuracy?

There is no silver bullet. Some optimizers for your task would probably work better than the others. There is no way to tell beforehand, you have to try a few to find the best one. Good news is that the results of different optimizers would probably be close to each other. You have to find the best hyperparameters for any single optimizer you choose, though.

Which optimizer should I use right now?

Maybe, take AdamOptimizer and run it for learning_rate 0.001 and 0.0001. If you want better results, try running for other learning rates. Or try other optimizers and tune their hyperparameters.

Long story

There are a few aspects to consider when choosing your optimizer:

• Easy of use (i.e. how fast you can find parameters that work for you);
• Convergence speed (basic as SGD or faster as any other);
• Memory footprint (typically between 0 and x2 sizes of your model);
• Relation to other parts of the training process.

Plain SGD is the bare minimum that can be done: it simply multiplies the gradients by the learning rate and adds the result to the weights. SGD has a number of beautiful qualities: it has only 1 hyperparameter; it does not need any additional memory; it has minimal effect on the other parts of training. It also has 2 drawbacks: it might be too sensitive to learning rate choice and training can take longer than with other methods.

From these drawbacks of plain SGD we can see what are the more complicated update rules (optimizers) are for: we sacrifice a part of our memory to achieve faster training and, possibly, simplify the choice of hyperparameters.

Memory overhead is typically non-significant and can be ignored. Unless the model is extremely large, or you are training on GTX760, or fighting for ImageNet leadership. Simpler methods like momentum or Nesterov accelerated gradient need 1.0 or less of model size (size of the model hyperparameters). Second order methods (Adam, might need twice as much memory and computation.

Convergence speed-wise pretty much anything is better than SGD and anything else is hard to compare. One note might be that AdamOptimizer is good at starting training almost immediately, without a warm-up.

I consider easy-of-use to be the most important in the choice of an optimizer. Different optimizers have a different number of hyperparameters and have a different sensibility to them. I consider Adam the most simple of all readily-available ones. You typically need to check 2-4 learning_rates between 0.001 and 0.0001 to figure out if the model converges nicely. For comparison for SGD (and momentum) I typically try [0.1, 0.01, ... 10e-5]. Adam has 2 more hyperparameters that rarely have to be changed.

최적화 프로그램과 교육의 다른 부분 간의 관계 . 초 매개 변수 조정에는 일반적으로 {learning_rate, weight_decay, batch_size, droupout_rate}동시에 선택이 포함됩니다 . 이들 모두는 상호 연관되어 있으며 각각은 모델 정규화의 한 형태로 볼 수 있습니다. 하나는, 예를 들어, 정확하게, weight_decay 또는 L2-표준을 사용하는 가능성이 선택하는 경우 세심한주의를 지불하는 AdamWOptimizer대신 AdamOptimizer.

참고 URL : https://stackoverflow.com/questions/36162180/gradient-descent-vs-adagrad-vs-momentum-in-tensorflow