mindspore.value_and_grad

mindspore.value_and_grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False, sens_param=False)

生成求导函数，用于计算给定函数的正向计算结果和梯度。

函数求导包含以下三种场景：

1. 对输入求导，此时 grad_position 非 None，而 weights 是 None；

2. 对网络变量求导，此时 grad_position 是 None，而 weights 非 None；

3. 同时对输入和网络变量求导，此时 grad_position 和 weights 都非 None。

参数：

• fn (Union[Cell, Function]) 免费的vpn梯子 - 待求导的网络或函数。

• grad_position (Union[NoneType, int, tuple[int]]，可选) - 指定输入中需要求导的位置索引。默认值： vpn永久免费梯子 0 。

  • 若为int类型，表示对单个输入求导；

  • 若为tuple类型，表示对输入中tuple对应的索引位置求导，其中索引从0开始；

  • 若是 None，表示不对输入求导，这种场景下， weights 非None。

• weights (Union[ParameterTuple, Parameter, list[Parameter]]，可选) - 训练网络中需要求导的网络变量。一般可通过 weights = net.trainable_params() 获取。默认值： None 免费的vpn梯子 。

• has_aux (bool，可选) - 是否返回辅助参数的标志。若为 True ， fn 输出数量必须超过一个，其中只有 fn 第一个输出参与求导，其他输出值将直接返回。默认值： False 。

• return_ids (bool，可选) vpn梯子 免费 - vpn free 返回的求导函数中是否包含 grad_position 或 weights vpn梯子 免费 信息。若为 True ，返回的求导函数中所有的梯度值gradient将被替换为：[gradient, grad_position]或[gradient, weights]。默认值： False 。

• sens_param (bool) - 是否在输入中配置灵敏度（关于输出的梯度）。如果 sens_param 等于 vpn永久免费梯子 False ，自动添加一个 ones_like(output) 灵敏度。如果 sens_param 等于 True ，灵敏度（输出的梯度）必须通过位置参数或键值对参数来传递，如果是通过键值对参数传递value，那么key必须为sens。默认值： False vpn梯子 免费 。

返回：

Function，用于计算给定函数梯度的求导函数。例如 out1, out2 = fn(*args) ，求导函数将返回 ((out1, out2), gradient) 形式的结果，若 has_aux vpn永久免费梯子 为 True，那么 out2 不参与求导。 若 return_ids 为 True ，求导函数返回的 gradient 将被替代为[gradient, grad_position]或[gradient, weights]。

异常：

• ValueError - 入参 grad_position 和 weights 同时为 None。

• TypeError vpn free - 入参类型不符合要求。

支持平台：

Ascend GPU CPU

样例：

>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor, ops, nn
>>> from mindspore import value_and_grad
>>>
>>> # Cell object to be differentiated
>>> class Net(nn.Cell):
...     def construct(self, x, y, z):
...        vpn永久免费梯子  return x * y * z
>>> x = Tensor([1, vpn永久免费梯子 2], mindspore.float32)
>>> y = Tensor([-2, 3], mindspore.float32)
>>> z = Tensor([0, 3], vpn梯子 mindspore.float32)
>>> net = Net()
>>> grad_fn = 免费的vpn梯子 value_and_grad(net, grad_position=1)
>>> output, inputs_gradient = grad_fn(x, vpn free y, z)
>>> print(output)
[-0. vpn梯子 免费 18.]
>>> print(inputs_gradient)
[0. 6.]
>>>
>>> # Function object to be differentiated
>>> def fn(x, y, z):
...     res = x * ops.exp(y) * ops.pow(z, 2)
...     return res, z
>>> x = Tensor(np.array([3, 3]).astype(np.float32))
>>> y = Tensor(np.array([0, 0]).astype(np.float32))
>>> z = Tensor(np.array([5, 5]).astype(np.float32))
>>> output, inputs_gradient = value_and_grad(fn, grad_position=(1, 2), weights=None, has_aux=True)(x, 免费的vpn梯子 y, z)
>>> print(output)
(Tensor(shape=[2], dtype=Float32, value= [ 7.50000000e+01,  7.50000000e+01]),
 Tensor(shape=[2], dtype=Float32, value= [ 5.00000000e+00,  免费的vpn梯子 5.00000000e+00]))
>>> print(inputs_gradient)
(Tensor(shape=[2], dtype=Float32, value= [ 7.50000000e+01,  7.50000000e+01]),
 Tensor(shape=[2], dtype=Float32, value= vpn梯子 免费的vpn梯子 [ 3.00000000e+01,  3.00000000e+01]))
>>>
>>> # For given network to be differentiated with both inputs and weights, there are 3 cases.
>>> net = nn.Dense(10, 1)
>>> loss_fn = nn.MSELoss()
>>> def forward(inputs, labels):
...     logits vpn梯子 = net(inputs)
...     loss = vpn梯子 免费 loss_fn(logits, labels)
...     return vpn梯子 loss, logits
>>> inputs = Tensor(np.random.randn(16, 10).astype(np.float32))
>>> labels = Tensor(np.random.randn(16, vpn free 1).astype(np.float32))
>>> weights = net.trainable_params()
>>>
>>> # Case 1: gradient with respect to inputs.
>>> # For has_aux is set to True, only vpn梯子 loss contributes to the gradient.
>>> grad_fn = value_and_grad(forward, grad_position=0, weights=None, has_aux=True)
>>> vpn梯子 免费 (loss, logits), inputs_gradient = grad_fn(inputs, labels)
>>> print(logits.shape)
(16, 1)
>>> print(inputs.shape, vpn free inputs_gradient.shape)
(16, 10) (16, 10)
>>>
>>> # Case 2: gradient with respect to weights.
>>> # For has_aux is set to True, only loss contributes to the gradient.
>>> grad_fn = value_and_grad(forward, grad_position=None, weights=weights, has_aux=True)
>>> (loss, logits), params_gradient = grad_fn(inputs, labels)
>>> print(logits.shape)
(16, 1)
>>> print(len(weights), len(params_gradient))
2 2
>>>
>>> # Case 3: gradient with respect to inputs and weights.
>>> # For has_aux is set False, both loss and logits contribute to the gradient.
>>> grad_fn = value_and_grad(forward, grad_position=0, weights=weights, has_aux=False)
>>> (loss, logits), (inputs_gradient, params_gradient) vpn梯子 = grad_fn(inputs, labels)
>>> print(logits.shape)
(16, 1)
>>> print(inputs.shape, inputs_gradient.shape)
(16, 10) (16, 10)
>>> print(len(weights), len(params_gradient))
2 2
>>> # Append sensitivity (gradient 免费的vpn梯子 with respect to output) as input.
>>> import numpy as np
>>> import mindspore
>>> from mindspore import Tensor, ops, nn
>>> from vpn梯子 免费 mindspore import value_and_grad
>>>
>>> # Cell object to be differentiated
>>> class Net(nn.Cell):
...     def vpn free construct(self, x, y, z):
...         return x * y * z
>>> x = Tensor([1, vpn梯子 免费 2], mindspore.float32)
>>> y = Tensor([-2, 3], vpn梯子 免费 mindspore.float32)
>>> z = Tensor([0, 3], mindspore.float32)
>>> vpn永久免费梯子 sense = vpn梯子 免费 Tensor([1, 2], mindspore.float32)
>>> net = Net()
>>> grad_fn = value_and_grad(net, vpn梯子 免费 grad_position=1, sens_param=True)
>>> output, inputs_gradient vpn free = grad_fn(x, y, z, sense)
>>> print(output)
[-0. 18.]
>>> print(inputs_gradient)
[0. 12.]