mindspore.ops.ApplyAdamWithAmsgradV2

class mindspore.ops.ApplyAdamWithAmsgradV2(use_locking=False)[源代码]

根据Adam算法更新变量var。

更新公式如下:

\[\begin{split}\begin{array}{l1} \\ lr_t:=learning\_rate*\sqrt{1-\beta_2^t}/(1-\beta_1^t) \\ m_t:=\beta_1*m_{t-1}+(1-\beta_1)*g \\ v_t:=\beta_2*v_{t-1}+(1-\beta_2)*g*g \\ \hat v_t:=\max(\hat v_{t-1}, v_t) \\ var:=var-lr_t*m_t/(\sqrt{\hat v_t}+\epsilon) \\ \end{array}\end{split}\]

所有输入符合隐式类型转换规则,使数据类型一致。如果它们具有不同的数据类型,则低精度数据类型将转换为相对最高精度的数据类型。

参数:
  • use_locking (bool) - 如果为 Truevarmv 的更新将受到锁的保护。否则,行为为未定义,很可能出现较少的冲突。默认值为 False

输入:
  • var (Parameter) - 待更新的网络参数,为任意维度。数据类型为float16、float32或float64。

  • m (Parameter) - 一阶矩,shape与 var 相同。

  • v (Parameter) - 二阶矩。shape与 var 相同。

  • vhat (Parameter) - 公式中的 \(\hat v_t\) 。shape和类型与 var 相同。

  • beta1_power (Union[float, Tensor]) - 公式中的 \(beta_1^t(\beta_1^{t})\) ,数据类型为float16、float32或float64。

  • beta2_power (Union[float, Tensor]) - 公式中的 \(beta_2^t(\beta_2^{t})\) ,数据类型为float16、float32或float64。

  • lr (Union[float, Tensor]) - 学习率。数据类型为float16、float32或float64的Tensor。

  • beta1 (Union[float, Tensor]) - 一阶矩的指数衰减率。数据类型为float16、float32或float64。

  • beta2 (Union[float, Tensor]) - 二阶矩的指数衰减率。数据类型为float16、float32或float64。

  • epsilon (Union[float, Tensor]) - 加在分母上的值,以确保数值稳定。数据类型为float16、float32或float64。

  • grad (Tensor) - 为梯度,shape与 var 相同。

输出:

4个Tensor组成的tuple,更新后的数据。

  • var (Tensor) - shape和数据类型与 var 相同。

  • m (Tensor) - shape和数据类型与 m 相同。

  • v (Tensor) - shape和数据类型与 v 相同。

  • vhat (Tensor) - shape和数据类型与 vhat 相同。

异常:
  • TypeError - 如果 varmvvhat 不是Parameter。

  • TypeError - 如果 varmvvhatbeta1_powerbeta2_powerlrbeta1beta2epsilongrad 的数据类型既不是float16也不是float32,也不是float64。

  • RuntimeError - 如果 varmvvhatgrad 不支持数据类型转换。

支持平台:

Ascend GPU CPU

样例:

>>> import mindspore.ops as ops
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> import numpy as np
>>> class ApplyAdamWithAmsgradNet(nn.Cell):
...     def __init__(self, use_locking=False):
...         super(ApplyAdamWithAmsgradNet, self).__init__()
...         self.apply_adam_with_amsgrad = ops.ApplyAdamWithAmsgradV2(use_locking)
...         self.var = Parameter(Tensor(np.array([[0.2, 0.2], [0.2, 0.2]]).astype(np.float32)), name="var")
...         self.m = Parameter(Tensor(np.array([[0.1, 0.2], [0.4, 0.3]]).astype(np.float32)), name="m")
...         self.v = Parameter(Tensor(np.array([[0.2, 0.1], [0.3, 0.4]]).astype(np.float32)), name="v")
...         self.vhat = Parameter(Tensor(np.array([[0.1, 0.2], [0.6, 0.2]]).astype(np.float32)), name="vhat")
...         self.beta1 = 0.8
...         self.beta2 = 0.999
...         self.epsilon = 1e-8
...         self.beta1_power = 0.9
...         self.beta2_power = 0.999
...         self.lr = 0.01
...
...     def construct(self, grad):
...         out = self.apply_adam_with_amsgrad(self.var, self.m, self.v, self.vhat,
...                                            self.beta1_power, self.beta2_power, self.lr,
...                                            self.beta1, self.beta2, self.epsilon, grad)
...         return out
>>> net = ApplyAdamWithAmsgradNet()
>>> grad = Tensor(np.array([[0.4, 0.2], [0.2, 0.3]]).astype(np.float32))
>>> output = net(grad)
>>> print(net.var.asnumpy())
[[0.19886853 0.1985858 ]
[0.19853032 0.19849943]]