torch.autograd.functional.hessian

torch.autograd.functional.hessian(func, inputs, create_graph=False, strict=False, vectorize=False, outer_jacobian_strategy='reverse-mode')

计算给定标量函数的 Hessian。

参数:

• func (函数) – 一个接受 Tensor 输入并返回单个元素 Tensor 的 Python 函数。

• inputs (输入，可以是 Tensors 的元组或 Tensor) – 函数 func 的输入。

• create_graph (bool, 可选) – 如果 True ，Hessian 将以可微分的方式计算。注意，当 strict 为 False 时，结果可能不需要梯度或与输入断开连接。默认为 False 。

• strict (bool, 可选) – 如果 True ，当我们检测到存在一个输入，所有输出都与它无关时，将引发错误。如果 False ，我们返回一个零 Tensor 作为这些输入的 Hessian，这是预期的数学值。默认为 False 。

• vectorize（bool，可选）- 此功能为实验性。如果您正在寻找更少实验性且性能更优的替代方案，请考虑使用 torch.func.hessian() 。在计算 Hessian 时，通常我们每行 Hessian 调用 autograd.grad 一次。如果此标志为 True ，则使用 vmap 原型功能作为后端来向量化对 autograd.grad 的调用，因此我们只调用一次而不是每行调用一次。这应该会在许多用例中提高性能，但由于此功能尚不完整，可能会出现性能悬崖。请使用 torch._C._debug_only_display_vmap_fallback_warnings(True)来显示任何性能警告，并在存在警告的情况下为我们提交问题。默认为 False 。

• outer_jacobian_strategy（str，可选）- Hessian 是通过计算 Jacobian 的 Jacobian 来计算的。内部 Jacobian 始终使用反向模式 AD 计算。将策略设置为 "forward-mode" 或 "reverse-mode" 确定外部 Jacobian 是否使用正向或反向模式 AD 计算。目前，在 "forward-mode" 中计算外部 Jacobian 需要 vectorized=True 。默认为 "reverse-mode" 。

返回值:

如果只有一个输入，这将是一个包含输入 Hessian 的单个 Tensor。如果是元组，则 Hessian 将是一个元组，其中 Hessian[i][j] 将包含第 i 个输入和第 j 个输入的 Hessian，其大小为第 i 个输入的大小加上第 j 个输入的大小。 Hessian[i][j] 将与相应的 i 个输入具有相同的 dtype 和 device。

返回类型:

Hessian（Tensor 或 Tensor 的元组）

示例

>>> def pow_reducer(x):
...     return x.pow(3).sum()
>>> inputs = torch.rand(2, 2)
>>> hessian(pow_reducer, inputs)
tensor([[[[5.2265, 0.0000],
          [0.0000, 0.0000]],
         [[0.0000, 4.8221],
          [0.0000, 0.0000]]],
        [[[0.0000, 0.0000],
          [1.9456, 0.0000]],
         [[0.0000, 0.0000],
          [0.0000, 3.2550]]]])

>>> hessian(pow_reducer, inputs, create_graph=True)
tensor([[[[5.2265, 0.0000],
          [0.0000, 0.0000]],
         [[0.0000, 4.8221],
          [0.0000, 0.0000]]],
        [[[0.0000, 0.0000],
          [1.9456, 0.0000]],
         [[0.0000, 0.0000],
          [0.0000, 3.2550]]]], grad_fn=<ViewBackward>)

>>> def pow_adder_reducer(x, y):
...     return (2 * x.pow(2) + 3 * y.pow(2)).sum()
>>> inputs = (torch.rand(2), torch.rand(2))
>>> hessian(pow_adder_reducer, inputs)
((tensor([[4., 0.],
          [0., 4.]]),
  tensor([[0., 0.],
          [0., 0.]])),
 (tensor([[0., 0.],
          [0., 0.]]),
  tensor([[6., 0.],
          [0., 6.]])))