## 4. Optimization algorithms

$x^{\{t\}}$，$y^{\{t\}}$ 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 $x^{\{t\}}$，$y^{\{t\}}$ at the same time.

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

#### 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

$$V_t = \beta V_{t-1} + (1-\beta)\theta_t$$

View $V_t$ as approximately averaging over $\frac {1} {1 - \beta}$.

It’s called moving average in the statistics literature.

$\beta = 0.9$：

$\beta = 0.9(red)$，$\beta = 0.98(green)$，$\beta = 0.5(yellow)$：

#### 4.4 Understanding exponentially weighted averages

$\theta$ is the temperature of the day.

$$v_{100} = 0.9v_{99} + 0.1 \theta_{100}$$$$v_{99} = 0.9v_{98} + 0.1 \theta_{99}$$$$…$$

So $$v_{100} = 0.1 * \theta _{100} + 0.1 * 0.9 * \theta _{99} + … + 0.1 * 0.9^{i} * \theta _{100-i} + …$$

Th coefficients is $$0.1 + 0.1 * 0.9 + 0.1 * 0.9^2 + …$$

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

$$(1 - \epsilon)^{\frac {1} {\epsilon}} \approx \frac {1} {e}$$ $$\frac {1} {e} \approx 0.3679$$

Implement exponentially weighted average:

$$v_0 = 0$$$$v_1 = \beta v_0 + (1- \beta) \theta _1$$$$v_2 = \beta v_1 + (1- \beta) \theta _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: $$\frac {v_t} {1 - \beta^t} = \beta v_{t-1} + (1- \beta) \theta _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 $v_{dw}$, $v_{db}$
$$v_{dw} = \beta v_{dw} + (1 - \beta)dw$$$$v_{db} = \beta v_{db} + (1 - \beta)db$$
3. update dw, db
$$w = w - \alpha v_{dw}$$$$b = b - \alpha v_{db}$$

There are two hyperparameters, the most common value for $\beta$ is 0.9.

Another formula is $v_{dw} = \beta v_{dw} + dw$, you need to modify corresponding $\alpha$.

#### 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 $s_{dw}$, $s_{db}$
$$s_{dw} = \beta s_{dw} + (1 - \beta){dw}^2$$$$s_{db} = \beta s_{db} + (1 - \beta){db}^2$$
3. update dw, db
$$w = w - \alpha \frac {dw} {\sqrt {s_{dw}}}$$$$b = b - \alpha \frac {db} {\sqrt {s_{db}}}$$

In practice, in order to avoid $\sqrt {s_{dw}}$ being very close zero:

$$w = w - \alpha \frac {dw} {\sqrt {s_{dw}} + \epsilon}$$$$b = b - \alpha \frac {db} {\sqrt {s_{db}} + \epsilon}$$

Usually $$\epsilon = 10^{-8}$$

$$v_{dw}=0, s_{dw}=0,v_{db},s_{db}=0$$

On iteration t:

$$v_{dw} = \beta_1 v_{dw} + (1 - \beta_1)dw$$$$v_{db} = \beta_1 v_{db} + (1 - \beta_1)db$$

$$s_{dw} = \beta_2 s_{dw} + (1 - \beta_2){dw}^2$$$$s_{db} = \beta_2 s_{db} + (1 - \beta_2){db}^2$$

Bias correction:

$$v_{dw}^{bc} = \frac {v_{dw}} {1 - \beta_1^t}, v_{db}^{bc} = \frac {v_{db}} {1 - \beta_1^t}$$$$s_{dw}^{bc} = \frac {s_{dw}} {1 - \beta_2^t}, s_{db}^{bc} = \frac {s_{db}} {1 - \beta_2^t}$$

Update weight:

$$w = w - \alpha \frac {v_{dw}^{bc}} {\sqrt {s_{dw}^{bc}} + \epsilon}$$$$b = b - \alpha \frac {v_{db}^{bc}} {\sqrt {s_{db}^{bc}} + \epsilon}$$

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.\

$\alpha$ needs to be tuned. $\beta_1 = 0.9$, $\beta_2 = 0.999$, $\epsilon = 10^{-8}$.

#### 4.9 Learning rate decay

Learning rate decay is slowly reduce the learning rate.

$$\alpha = \frac {1} {1 + {decay rate} * epochs} \alpha_0$$

$\alpha_0$ is the initial learning rate.

Other learning rate decay methods:

$\alpha = 0.95^{epochs}\alpha_0$, this is called exponentially decay.

$\alpha = \frac {k} {\sqrt {epochs} } \alpha_0$, $\alpha = \frac {k} {\sqrt t} \alpha_0$.

$\alpha = {\frac {1} {2}}^{epochs} \alpha _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.