Improving Deep Neural Networks学习笔记(二)

文章作者：Tyan
博客：noahsnail.com  |  CSDN  |  简书

4. Optimization algorithms

4.1 Mini-batch gradient descent

xt，yt is used to index into different mini batches. x[t]，y[t] is used to index into different layer. x(t)，y(t) is used to index into different examples.

Batch gradient descent is to process entire training set at the same time. Mini-batch gradient descent is to process single mini batch xt，yt at the same time.

Run forward propagation and back propagation once on mini batch is called one iteration.

Mini-batch gradient descent runs much faster than batch gradient descent.

4.2 Understanding mini-batch gradient descent

If mini-batch size = m, it’s batch gradient descend.
If mini-batch size = 1, it’s stochastic gradient descend.
In pracice, mini-batch size between 1 and m.

Batch gradient descend: too long per iteration.
Stochastic gradient descend: lose speed up from vectorization.
Mini-batch gradient descend: Faster learning, 1. vectorization 2. Make progress without needing to wait.

Choosing mini-batch size:

If small training set(m <= 2000), use batch gradient descend.
Typical mini-batch size: 64, 128, 256, 512, 1024(rare).

4.3 Exponentially weighted averages

Vt=βVt−1+(1−β)θt

View Vt as approximately averaging over 11−β.

It’s called moving average in the statistics literature.

β=0.9：

β=0.9(red)，β=0.98(green)，β=0.5(yellow)：

4.4 Understanding exponentially weighted averages

θ is the temperature of the day.

v100=0.9v99+0.1θ100

v99=0.9v98+0.1θ99

...

So

v100=0.1\*θ100+0.1\*0.9\*θ99+...+0.1\*0.9i\*θ100−i+...

Th coefficients is

0.1+0.1\*0.9+0.1\*0.92+...

All of these coefficients, add up to one or add up to very close to one. It is called bias correction.

(1−ϵ)1ϵ≈1e

1e≈0.3679

Implement exponentially weighted average:

v0=0

v1=βv0+(1−β)θ1

v2=βv1+(1−β)θ2

...

Exponentially weighted average takes very low memory.

4.5 Bias correction in exponentially weighted averages

It’s not a very good estimate of the first several day’s temperature. Bias correction is used to mofity this estimate that makes it much better. The formula is:

vt1−βt=βvt−1+(1−β)θt.

4.6 Gradient descent with momentum

Gradient descent with momentum almost always works faster than the standard gradient descent algorithm. The basic idea is to compute an exponentially weighted average of gradients, and then use that gradient to update weights instead.

On iteration t:

1. compute dw, db on current mini-batch.
2. compute vdw, vdb
   
   vdw=βvdw+(1−β)dw
   vdb=βvdb+(1−β)db
3. update dw, db
   
   w=w−αvdw
   b=b−αvdb

There are two hyperparameters, the most common value for β is 0.9.

Another formula is vdw=βvdw+dw, you need to modify corresponding α.

4.7 RMSprop

RMSprop stands for root mean square prop, that can also speed up gradient descent.

On iteration t:

1. compute dw, db on current mini-batch.
2. compute sdw, sdb
   
   sdw=βsdw+(1−β)dw2
   sdb=βsdb+(1−β)db2
3. update dw, db
   
   w=w−αdwsdw‾‾‾√
   b=b−αdbsdb‾‾‾√

In practice, in order to avoid sdw‾‾‾√ being very close zero:

w=w−αdwsdw‾‾‾√+ϵ

b=b−αdbsdb‾‾‾√+ϵ

Usually

ϵ=10−8

4.8 Adam optimization algorithm

vdw=0,sdw=0,vdb,sdb=0

On iteration t:

vdw=β1vdw+(1−β1)dw

vdb=β1vdb+(1−β1)db

sdw=β2sdw+(1−β2)dw2

sdb=β2sdb+(1−β2)db2

Bias correction:

vbcdw=vdw1−βt1,vbcdb=vdb1−βt1

sbcdw=sdw1−βt2,sbcdb=sdb1−βt2

Update weight:

w=w−αvbcdwsbcdw‾‾‾√+ϵ

b=b−αvbcdbsbcdb‾‾‾√+ϵ

Adam combines the effect of gradient descent with momentum together with gradient descent with RMSprop. It’s a commonly used learning algorithm that is proven to be very effective for many different neural networks of a very wide variety of architectures.\

α needs to be tuned. β1=0.9, β2=0.999, ϵ=10−8.

Adam stands for Adaptive Moment Estimation.

4.9 Learning rate decay

Learning rate decay is slowly reduce the learning rate.

α=11+decayrate\*epochsα0

α0 is the initial learning rate.

Other learning rate decay methods:

α=0.95epochsα0, this is called exponentially decay.

α=kepochs√α0, α=kt√α0.

α=12epochsα0, this is called a discrete staircase.

4.10 The problem of local optima

In very high-dimensional spaces you’re actually much more likely to run into a saddle point, rather than local optimum.

• Unlikely to get stuck in a bad local optima.
• Plateaus can make learning slow.