mindspore.ops.SparseApplyFtrlV2

class mindspore.ops.SparseApplyFtrlV2(lr, l1, l2, l2_shrinkage, lr_power, use_locking=False)

根据FTRL-proximal算法更新相关参数。这个类比SpaseApplyFtrl类多了一个属性 l2_shrinkage 。

除 indices 外，所有输入都遵守隐式类型转换规则，以使数据类型一致。如果它们数据类型不相同，则低精度数据类型将转换为相对最高精度的数据类型。

参数：

• lr (float) - 学习率，必须为正值。

• l1 (float) - L1正则化，必须大于或等于零。

• l2 (float) - L2正则化，必须大于或等于零。

• l2_shrinkage (float) - L2收缩正则化。

• lr_power (float) - 在训练期间控制降低学习率，必须小于或等于零。如果 lr_power 为零，则使用固定学习率。

• use_locking (bool, 可选) - 如果为True，则 var 和 accum 将受到保护，不被更新。默认值：False。

输入：

• var (Parameter) - 要更新的权重。数据类型必须为float16或float32。shape为 \((N, *)\) ，其中 \(*\) 表示任意数量的附加维度。

• accum (Parameter) - 要更新的累加值，shape和数据类型必须与 var 相同。

• linear (Parameter) - 要更新的线性系数，shape和数据类型必须与 var 相同。

• grad (Tensor) - 梯度，为一个Tensor。数据类型必须与 var 相同，且需要满足当 var.shape > 1 时 \(grad.shape[1:] = var.shape[1:]\)。

• indices (Tensor) - var 和 accum 第一维度的索引向量，数据类型为int32，且需要保证 \(indices.shape[0] = grad.shape[0]\)。

输出：

3个Tensor组成的tuple，更新后的参数。

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

• accum (Tensor) - Tensor，shape和数据类型与输入 accum 相同。

• linear (Tensor) - Tensor，shape和数据类型与输入 linear 相同。

异常：

• TypeError - 如果 lr 、 l1 、 l2 、 lr_power 或 use_locking 不是float。

• TypeError - 如果 use_locking 不是bool。

• TypeError - 如果 var 、 accum 、 linear 或 grad 的数据类型既不是float16也不是float32。

• TypeError - 如果 indices 的数据类型不是int32。

• RuntimeError - 如果除 indices 参数外，其他的所有输入不支持数据类型转换。

支持平台：

Ascend

样例：

>>> class SparseApplyFtrlV2Net(nn.Cell):
...     def __init__(self):
...         super(SparseApplyFtrlV2Net, self).__init__()
...         self.sparse_apply_ftrl_v2 = ops.SparseApplyFtrlV2(lr=0.01, l1=0.0, l2=0.0,
...                                                         l2_shrinkage=0.0, lr_power=-0.5)
...         self.var = Parameter(Tensor(np.array([[0.2, 0.3]]).astype(np.float32)), name="var")
...         self.accum = Parameter(Tensor(np.array([[0.5, 0.9]]).astype(np.float32)), name="accum")
...         self.linear = Parameter(Tensor(np.array([[0.7, 0.5]]).astype(np.float32)), name="linear")
...
...     def construct(self, grad, indices):
...         out = self.sparse_apply_ftrl_v2(self.var, self.accum, self.linear, grad, indices)
...         return out
...
>>> net = SparseApplyFtrlV2Net()
>>> grad = Tensor(np.array([[0.8, 0.5]]).astype(np.float32))
>>> indices = Tensor(np.ones([1]), mindspore.int32)
>>> output = net(grad, indices)
>>> print(output)
(Tensor(shape=[1, 2], dtype=Float32, value=
[[ 2.00000003e-01,  3.00000012e-01]]), Tensor(shape=[1, 2], dtype=Float32, value=
[[ 5.00000000e-01,  8.99999976e-01]]), Tensor(shape=[1, 2], dtype=Float32, value=
[[ 6.99999988e-01,  5.00000000e-01]]))