优化问题是解决形如

的问题，g(x)$g(x)$是损失函数，h(x)$h(x)$是正则化约束，X$X$是可行域。
我们令f(x)=g(x)+h(x)$f(x)=g(x)+h(x)$，对f(x)$f(x)$已知信息的多少可把这个问题分为

• 2阶问题：已知f(x)$f(x)$的函数值、1阶、2阶导数（值、梯度、hessen矩阵）
• 1阶问题：已知f(x)$f(x)$的函数值、1阶导数（值、梯度）
• 0阶问题：只知道f(x)$f(x)$的函数值（值）
• -1阶问题：只知道f(x)$f(x)$的估计值F[f(x),ξ]$F[f(x),\xi ]$

当可行域X$X$为整个空间时，优化问题被成为无约束的最优化问题；当可行域X$X$受到限制时，优化问题被成为有约束的最优化问题。

无约束最优化问题的解法

我们希望得到minxf(x)$mi{n}_{x}f(x)$，我们把f(x)$f(x)$泰勒展开可得

1阶问题中用于神经网络的常见算法

当∇f(x)$\mathrm{\nabla }f(x)$已知时，我们可知，将x$x$往与∇f(x)$\mathrm{\nabla }f(x)$相反的方向走一小步Δ$\mathrm{\Delta }$，f(x+Δ)$f(x+\mathrm{\Delta })$会下降，那么我们可以得到递推公式

η$\eta$为步长大小。观察递推公式，我们可知可以从步长η$\eta$和梯度∇f(xt)$\mathrm{\nabla }f(x_t)$进行优化。

Gradient Descent Optimizer

tf.train.GradientDescentOptimizer(learning_rate, name=’GradientDescent’)

最朴素的算法，直接利用梯度递推公式进行优化，步长可为定值或指数衰减。
他的缺点很明显：

• 很难选择出合适的学习率
• 相同的学习率并不适用于所有的参数
• 在神经网络中，非凸问题关键是要避免陷入局部最小值或自鞍点，梯度下降法并不能很好的解决

Momentum Optimizer

tf.train.MomentumOptimizer(learning_rate, momentum, use_nesterov=False, name=’Momentum’)

添加上步的更新分量到当前，可以一定程度上避免陷入局部最小值或自鞍点。直观的理解就是给运动加上了惯性。与梯度下降相比，加速收敛，提高精度(减少收敛过程中的振荡)。递推公式为

γ$\gamma$一般设置为0.9。

Nesterov Momentum Optimizer

tf.train.MomentumOptimizer(learning_rate, momentum, use_nesterov=True, name=’Momentum’)

添加上步的更新分量到当前，并预测下一时刻的动量来修正。递推公式为

Adagrad

tf.train.AdagradOptimizer(learning_rate, initial_accumulator_value=0.1, name=’Adagrad’)

对稀疏参数(例如神经网络中有些**函数**的概率很低，那相应通路上的参数就很难进行更新)进行大幅更新和对频率参数小幅更新，适合处理稀疏数据。递推公式：

gt,i$g_{t,i}$是梯度的第i$i$个分量。梯度较大的减小步长，防止跑过，梯度较小增加步长，加速。缺点步长总是在衰减。
直观的理解各分量步长不同可以想象优化的loss函数等高线并不是一个球，而是一个椭球，当然最快的下降线路并不是沿等高线的法线（梯度方向），而是有个偏斜，Adagrad就是解决这个问题的。

Adadelta

tf.train.AdadeltaOptimizer(learning_rate=0.001, rho=0.95, epsilon=1e-08, name=’Adadelta’)

训练初中期，加速效果很好，后期会抖动，不需要设置步长。递推公式为：

Adadelta的直观理解是使得更新的Δx$\mathrm{\Delta }x$的量纲与x$x$相同，而且g2τ,i$g_{\tau ,i}^2$对Gt,i$G_{t,i}$的影响指数衰减，所以采用这种形式。

RMSprop

tf.train.RMSPropOptimizer(learning_rate, decay=0.9, momentum=0.0, epsilon=1e-10, name=’RMSProp’)

与Adadelta对于Gt,i$G_{t,i}$处理想法相同， g2τ,i$g_{\tau ,i}^2$对Gt,i$G_{t,i}$的影响指数衰减。

Adam

tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, name=’Adam’)

相当于给梯度加入了动量。

梯度的一阶矩估计：mt=μmt−1+(1−μ)gt$m_t=\mu m_{t-1}+(1-\mu )g_t$
梯度的二阶矩估计：nt=μnt−1+(1−γ)g2t$n_t=\mu n_{t-1}+(1-\gamma )g_t^2$
校正：m^t=mt1−μt,n^t=nt1−γt${\hat{m}}_t=\frac{m_t}{1-{\mu }^t},{\hat{n}}_t=\frac{n_t}{1-{\gamma }^t}$
校正的原因是因为初始时mt=nt=0$m_t=n_t=0$，mt$m_t$会偏小，放大修正。
递推公式：xt+1=xt−αm^tn^t√+ϵ$x_{t+1}=x_t-\alpha \frac{{\hat{m}}_t}{\sqrt{{\hat{n}}_t}+ϵ}$

Adam的变体

Adamax：nt=max(γnt−1,|gt|),xt+1=xt−αm^tnt+ϵ$n_t=max(\gamma n_{t-1},|g_t|),x_{t+1}=x_t-\alpha \frac{{\hat{m}}_t}{n_t+ϵ}$
对梯度的学习率范围有了更好的约束

Nadam：带有Nesterov动量项的Adam
梯度：g^t=gt1−μt${\hat{g}}_t=\frac{g_t}{1-{\mu }^t}$
梯度的一阶矩估计：mt=μmt−1+(1−μ)gt,m^t=mt1−μt,m¯t=(1−μ)g^t+μm^t$m_t=\mu m_{t-1}+(1-\mu )g_t,{\hat{m}}_t=\frac{m_t}{1-{\mu }^t},{\overline{m}}_t=(1-\mu ){\hat{g}}_t+\mu {\hat{m}}_t$
梯度的二阶矩估计：nt=μnt−1+(1−γ)g2t,n^t=nt1−γt$n_t=\mu n_{t-1}+(1-\gamma )g_t^2,{\hat{n}}_t=\frac{n_t}{1-{\gamma }^t}$
递推公式：xt+1=xt−αm¯tn^t√+ϵ$x_{t+1}=x_t-\alpha \frac{{\overline{m}}_t}{\sqrt{{\hat{n}}_t}+ϵ}$

Adam+GD

由于GD一般训练时间更长，容易陷入鞍点， 但在好的初始化和学习率调度方案下，结果更可靠。
更为复杂的方法收敛速度快，但是在最优点附近没有GD收敛的效果好。
那么我们可以先Nadam到最优点附近，再切换SGD，具体做法是
先用Nadam进行优化，每隔150步学习速率衰减10倍，计算Nadam及等效学习速率，当学习速率几乎不变时，切换GD，GD的学习速率为Nadam此时的等效学习速率。

• Inputs: Objective function f$f$, initial point θ0${\theta }_0$, learning rate α=10−3$\alpha ={10}^{-3}$, accumulator
  (β1,β2)=(0.9,0.999)$({\beta }_1,{\beta }_2)=(0.9,0.999)$,ϵ=10−9$ϵ={10}^{-9}$, phase=Adam
• Initialize: k=0$k=0$, m0=0$m_0=0$, n0=0$n_0=0$, λ0=0${\lambda }_0=0$
• while stopping criterion not met do
  
  • k=k+1$k=k+1$
  • Compute stochastic gradient gk=∇f(θk−1)$g_k=\mathrm{\nabla }f({\theta }_{k-1})$
  • If phase=SGD then
    
    • vk=β1vk−1+gk$v_k={\beta }_1{v}_{k-1}+g_k$
    • θk=θk−1−(1−β1)ηvk${\theta }_k={\theta }_{k-1}-(1-{\beta }_1)\eta v_k$
    • continue
  • End if
  • mk=β1mk−1+(1−β1)gk$m_k={\beta }_1{m}_{k-1}+(1-{\beta }_1)g_k$
  • αk=β2αk−1+(1−β2)g2t${\alpha }_k={\beta }_2{\alpha }_{k-1}+(1-{\beta }_2)g_t^2$
  • pk=−αk1−βk2√1−βk1mkαk√+ϵ$p_k=-{\alpha }_k\frac{\sqrt{1-{\beta }_2^k}1-{\beta }_1^k}{}\frac{m_k}{\sqrt{{\alpha }_k}+ϵ}$
  • if pTkgk≠0$p_k^T{g}_k\ne 0$ then
    
    • γk=pTkpk−pTkgk${\gamma }_k=\frac{p_k^T{p}_k}{-p_k^T{g}_k}$
    • λk=β2λk−1+(1−β2)γk${\lambda }_k={\beta }_2{\lambda }_{k-1}+(1-{\beta }_2){\gamma }_k$
    • if k>1$k>1$ and |λk1−β22−λk−1|<ϵ$|\frac{{\lambda }_k}{1-{\beta }_2^2}-{\lambda }_{k-1}|<ϵ$ then
      
      • phase = SGD
      • $v_k=0
      • η=λk1−β22$\eta =\frac{{\lambda }_k}{1-{\beta }_2^2}$
    • end if
  • else
    
    • λk=λk−1${\lambda }_k={\lambda }_{k-1}$
  • end if
• end while
• return θk${\theta }_k$

一般形式

梯度的一阶矩估计：mt$m_t$
梯度的二阶矩估计：nt$n_t$
递推公式：xt+1=xt−αmtnt√+ϵ$x_{t+1}=x_t-\alpha \frac{m_t}{\sqrt{n_t}+ϵ}$

两招加速：动量（Nesterov），二阶矩

可视化

加了二阶矩的优化算法看起来比只加动量的从收敛速度和最终精度来看，都要好一些。

tf中的其他Optimizer

tf.train.SyncReplicasOptimizer # 多个Optimizer同步
tf.train.FtrlOptimizer # FTRL算法，加L1正则的感觉
tf.train.ProximalGradientDescentOptimizer # 加L1,L2正则
tf.train.ProximalAdagradOptimizer # 加L1,L2正则