Table of Contents
Shortcuts

# torch.autograd.functional.vhp

torch.autograd.functional.vhp(func, inputs, v=None, create_graph=False, strict=False)

  Function that computes the dot product between a vector `v` and the Hessian of a given scalar function at the point given by the inputs.

  Parameters:

    - func (function) – a Python function that takes Tensor inputs and returns a Tensor with a single element.

    - inputs (tuple of Tensors or Tensor) – inputs to the function `func`.

    - v (tuple of Tensors or Tensor) – The vector for which the vector Hessian product is computed. Must be the same size as the input of `func`. This argument is optional when `func`’s input contains a single element and (if it is not provided) will be set as a Tensor containing a single `1`.

    - create_graph (bool, optional) – If `True`, both the output and result will be computed in a differentiable way. Note that when `strict` is `False`, the result can not require gradients or be disconnected from the inputs. Defaults to `False`.

    - strict (bool, optional) – If `True`, an error will be raised when we detect that there exists an input such that all the outputs are independent of it. If `False`, we return a Tensor of zeros as the vhp for said inputs, which is the expected mathematical value. Defaults to `False`.

  Returns:

    tuple with:

      func_output (tuple of Tensors or Tensor): output of `func(inputs)`

      vhp (tuple of Tensors or Tensor): result of the dot product with the same shape as the inputs.

  Return type:

    output (tuple)

  Example

      >>> def pow_reducer(x):
      ...     return x.pow(3).sum()
      >>> inputs = torch.rand(2, 2)
      >>> v = torch.ones(2, 2)
      >>> vhp(pow_reducer, inputs, v)
      (tensor(0.5591),
       tensor([[1.0689, 1.2431],
               [3.0989, 4.4456]]))
      >>> vhp(pow_reducer, inputs, v, create_graph=True)
      (tensor(0.5591, grad_fn=<SumBackward0>),
       tensor([[1.0689, 1.2431],
               [3.0989, 4.4456]], grad_fn=<MulBackward0>))
      >>> def pow_adder_reducer(x, y):
      ...     return (2 * x.pow(2) + 3 * y.pow(2)).sum()
      >>> inputs = (torch.rand(2), torch.rand(2))
      >>> v = (torch.zeros(2), torch.ones(2))
      >>> vhp(pow_adder_reducer, inputs, v)
      (tensor(4.8053),
       (tensor([0., 0.]),
        tensor([6., 6.])))

## Docs

Access comprehensive developer documentation for PyTorch

View Docs

## Tutorials

Get in-depth tutorials for beginners and advanced developers

View Tutorials

## Resources

Find development resources and get your questions answered

View Resources

To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.