Adam(Adaptive Moment Estimation)计算实例详解,帮助你理解Adam算法!
一、Adam算法原理
Adam(Adaptive Moment Estimation)是一种结合了动量(momentum)和自适应学习率调整的优化算法,它能够在深度学习模型的训练中更快地收敛并且对超参数的选择相对不那么敏感。
Adam算法原理概述
Adam算法结合了RMSProp和动量优化的优点,具体来说,它维护了两个动态调整的学习率:一个是基于梯度一阶矩估计的动量项,另一个是基于梯度二阶矩估计(类似于RMSProp)的自适应学习率。
二、Adam具体步骤和计算示例
2.1构建损失函数
假设我们要最小化一个简单的损失函数:
J ( θ ) = 1 2 ( θ 2 − 2 θ + 1 ) J(\theta) = \frac{1}{2} (\theta^2 - 2\theta + 1) J(θ)=21(θ2−2θ+1)
我们使用Adam算法来优化参数 θ \theta θ。
2.2初始化Adam算法的参数和变量:
初始化:
参数
θ
=
0
\theta = 0
θ=0,一阶矩估计
m
=
0
m = 0
m=0(动量项)和二阶矩估计
v
=
0
v = 0
v=0。
设定超参数:
设定学习率
η
=
0.1
\eta = 0.1
η=0.1。
设定动量项的衰减率
β
1
=
0.9
\beta_1 = 0.9
β1=0.9。
设定二阶矩估计(RMSProp)的衰减率
β
2
=
0.999
\beta_2 = 0.999
β2=0.999。
设定一个很小的数值
ϵ
=
1
0
−
8
\epsilon = 10^{-8}
ϵ=10−8(避免除以零)。
2.3迭代更新参数:
2.3.1计算梯度
对每个时间步 t t t,计算损失函数关于参数 θ \theta θ 的梯度:
∂ J ( θ ) ∂ θ = θ − 1 \frac{\partial J(\theta)}{\partial \theta}= \theta - 1 ∂θ∂J(θ)=θ−1
2.3.2更新一阶矩估计 m m m(动量项)和二阶矩估计 v v v(类似于RMSProp的更新):
m t = β 1 m t − 1 + ( 1 − β 1 ) ∂ J ( θ ) ∂ θ m_t = \beta_1 m_{t-1} + (1 - \beta_1) \frac{\partial J(\theta)}{\partial \theta} mt=β1mt−1+(1−β1)∂θ∂J(θ)
v t = β 2 v t − 1 + ( 1 − β 2 ) ∂ J ( θ ) ∂ θ 2 v_t = \beta_2 v_{t-1} + (1 - \beta_2) \frac{\partial J(\theta)}{\partial \theta}^2 vt=β2vt−1+(1−β2)∂θ∂J(θ)2
2.3.3校正偏差
由于一阶和二阶矩估计在初始时会偏向于零,需要进行校正:
m ^ t = m t 1 − β 1 t \hat{m}_t = \frac{m_t}{1 - \beta_1^t} m^t=1−β1tmt
v ^ t = v t 1 − β 2 t \hat{v}_t = \frac{v_t}{1 - \beta_2^t} v^t=1−β2tvt
2.3.4更新参数 θ \theta θ
根据校正后的一阶矩估计
m
^
t
\hat{m}_t
m^t 和二阶矩估计
v
^
t
\hat{v}t
v^t,
更新参数
θ
\theta
θ:
θ
t
+
1
=
θ
t
−
η
v
^
t
+
ϵ
m
^
t
\theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t
θt+1=θt−v^t+ϵηm^t
2.4实际计算过程
假设开始时 θ = 0 \theta = 0 θ=0,进行第一个时间步的更新:
计算损失函数 J ( θ ) J(\theta) J(θ) 的梯度 ∂ J ( θ ) ∂ θ = θ − 1 = 0 − 1 = − 1 \frac{\partial J(\theta)}{\partial \theta} = \theta - 1 = 0 - 1 = -1 ∂θ∂J(θ)=θ−1=0−1=−1。
更新一阶矩估计 m 1 = 0.9 ⋅ 0 + 0.1 ⋅ ( − 1 ) = − 0.1 m_1 = 0.9 \cdot 0 + 0.1 \cdot (-1) = -0.1 m1=0.9⋅0+0.1⋅(−1)=−0.1
更新二阶矩估计 v 1 = 0.999 ⋅ 0 + 0.001 ⋅ ( − 1 ) 2 = 0.001 v_1 = 0.999 \cdot 0 + 0.001 \cdot (-1)^2 = 0.001 v1=0.999⋅0+0.001⋅(−1)2=0.001
校正偏差: m ^ 1 = − 0.1 1 − 0. 9 1 = − 1 \hat{m}_1 = \frac{-0.1}{1 - 0.9^1} = -1 m^1=1−0.91−0.1=−1
v ^ 1 = 0.001 1 − 0.99 9 1 = 1 \hat{v}_1 = \frac{0.001}{1 - 0.999^1} = 1 v^1=1−0.99910.001=1
更新参数: θ 1 = 0 − 0.1 1 + 1 0 − 8 ⋅ ( − 1 ) = 0.1 \theta_1 = 0 - \frac{0.1}{\sqrt{1} + 10^{-8}} \cdot (-1) = 0.1 θ1=0−1+10−80.1⋅(−1)=0.1
然后,重复这些步骤直到收敛或达到预定的迭代次数。
这个例子展示了Adam算法如何利用动量和自适应学习率来优化参数,并且在不同的学习率和梯度条件下,自动调整步长以加快收敛速度。