Cómo calcular la arpillera en PyTorch

Una array hessiana o hessiana es una array cuadrada de derivadas parciales de segundo orden de una función. La función debe ser una función con valores escalares. Una función con valores escalares es una función que toma uno o más valores y devuelve un único valor. Por ejemplo   , es una función escalar ya que toma dos valores x e y pero devuelve un solo valor (valor calculado de  ).  

Cálculo de Hessian en PyTorch

Para calcular Hessian de una función de valor escalar en PyTorch.

función de valor escalar():

Sintaxis: torch.autograd.function.hessian(func, inputs, create_graph=False, strict=False, vectorize=False)

Parámetros:

• func: una función de Python. Toma entradas de tensor y devuelve un tensor con un solo elemento.
• entradas: entrada a la función func . Es un tensor o tupla de tensores.
• create_graph: es un booleano opcional. El valor predeterminado es falso. Si es Verdadero, se creará un gráfico de las derivadas.
• estricto: si es Verdadero, se lanzará un error cuando se detecte que existe una entrada tal que todas las salidas son independientes de ella. Si es False, devuelve un Tensor de ceros como la arpillera para dichas entradas.
• vectorizar: todavía en su fase experimental si es Verdadero, la función usa la función de prototipo vmap para calcular los gradientes. Invoca autograd.grad solo una vez en lugar de una vez por fila del Hessian.

Return: devuelve el Hessian de la entrada. Tensor si la entrada es un solo tensor, una tupla de tuplas si la entrada es una tupla.

Ejemplo 1: 

En este ejemplo, usamos una función de valor escalar de una sola variable (función univariada). Calculamos la arpillera de esta función para un tensor de entrada con elementos individuales y también para un tensor de entrada con elementos múltiples. Vea cómo la arpillera busca estas entradas para la misma función. La función de valor escalar se define para una sola variable. La entrada es un tensor y nota que el Hessian también es un tensor. Cuando el tensor de entrada tiene un solo elemento, la arpillera es un tensor con un solo elemento. Cuando el tensor de entrada tiene tres elementos, la arpillera es un tensor de tamaño [3, 3]. De la misma manera, la arpillera para el tensor de entrada de tamaño [2, 2] es un tensor de tamaño [2,2,2,2].

# Python program to compute Hessian in PyTorch
# importing libraries
import torch
from torch.autograd.functional import hessian
  
# defining a function
def func(x):
    return (2*x.pow(3) - x.pow(2)).sum()
  
# defining the input tensor
input = torch.tensor([3.])
print("Input:\n", input)
  
# computing the hessian
output = hessian(func, input)
  
# printing the above computed tensor
print("Hessian:\n", output)
  
# .....New input
input = torch.tensor([2., 3., 4.])
print("Input:\n", input)
  
# computing the hessian
output = hessian(func, input)
  
# printing the above computed tensor
print("Hessian:\n", output)
  
# .....New input
input = torch.tensor([[2., 3.], [4., 7]])
print("Input:\n", input)
  
# computing the hessian
output = hessian(func, input)
  
# printing the above computed tensor
print("Hessian:\n", output)

Producción:

Input:
 tensor([3.])
Hessian:
 tensor([[34.]])
Input:
 tensor([2., 3., 4.])
Hessian:
 tensor([[22.,  0.,  0.],
        [ 0., 34.,  0.],
        [ 0.,  0., 46.]])
Input:
 tensor([[2., 3.],
        [4., 7.]])
Hessian:
 tensor([[[[22.,  0.],
          [ 0.,  0.]],

         [[ 0., 34.],
          [ 0.,  0.]]],


        [[[ 0.,  0.],
          [46.,  0.]],

         [[ 0.,  0.],
          [ 0., 82.]]]])

Ejemplo 2:

En el siguiente ejemplo, definimos una función de valor escalar de dos variables (función bivariada). Introducimos una tupla de dos tensores. La función con valores escalares se define para dos variables. La entrada es una tupla de dos tensores y observa que la salida (la arpillera) es una tupla de tuplas de tensores. Cada tupla interior tiene dos elementos (tensores). Aquí Hessian[i][j] contiene el Hessian de la i-ésima entrada y la j-ésima entrada.

# Python program to compute Hessian in PyTorch
# importing libraries
import torch
from torch.autograd.functional import hessian
  
# defining a function
def func(x, y):
    return (2*x*y.pow(2) + x.pow(3) - 10).sum()
  
# defining the inputs
input_x = torch.tensor([2.])
input_y = torch.tensor([-3.])
inputs = (input_x, input_y)
print("inputs:\n", inputs)
  
# compute the hessian
output = hessian(func, inputs)
  
# printing the above computed hessian
print("Hessian:\n", output)

Producción:

inputs:
 (tensor([2.]), tensor([-3.]))
Hessian:
 ((tensor([[12.]]), tensor([[-12.]])), 
 (tensor([[-12.]]), tensor([[8.]])))

Ejemplo 3:

En el siguiente ejemplo, definimos una función con valores escalares de tres variables. Introducimos una tupla de tres tensores. La función de valores escalares se define para tres variables. La entrada es una tupla de tres tensores y observe que la salida (la arpillera) es una tupla de tuplas de tensores. Aquí Hessian[i][j] contiene el Hessian de la i-ésima entrada y la j-ésima entrada.

# Python program to compute Hessian in PyTorch
# importing libraries
import torch
from torch.autograd.functional import hessian
  
# defining a function
def func(x, y, z):
    return (2*x.pow(2)*y + x*z.pow(3) - 10).sum()
  
# defining the inputs
input_x = torch.tensor([1.])
input_y = torch.tensor([2.])
input_z = torch.tensor([3.])
  
#inputs = (input_x, input_y, input_z)
  
# compute the hessian
output = hessian(func, (input_x, input_y, input_z))
  
# printing the above computed hessian
print("Hessian Tensor:\n", output)

Producción:

Hessian Tensor:
 ((tensor([[8.]]), tensor([[4.]]), tensor([[27.]])), 
 (tensor([[4.]]), tensor([[0.]]), tensor([[0.]])), 
 (tensor([[27.]]), tensor([[0.]]), tensor([[18.]])))