Producto vector-jacobiano de autograd en pytorch

autograd es una parte importante de Pytorch, el producto vector-jacobiano es la clave

Tome la función de valor vectorial tridimensional como ejemplo:

$X = \ left [x_ {1}, x_ {2}, x_ {3} \ right] Y = X ^ {2}$

Según el mecanismo Tensor, Elemento-Sabio, en realidad significa:

$Y = \ left [y_ {1} = x_ {1} ^ {2}, y_ {2} = x_ {2} ^ {2}, y_ {3} = x_ {3} ^ {2} \ right]$

La derivada de Y a X no es 2X sino una matriz jacobiana (porque X e Y son vectores, no números reales unidimensionales):

$J = \ left (\ begin {array} {ccc} \ frac {\ partial y_ {1}} {\ partial x_ {1}} & \ frac {\ partial y_ {1}} {\ partial x_ {2}} & \ frac {\ partial y_ {1}} {\ partial x_ {3}} \\ \ frac {\ partial y_ {2}} {\ partial x_ {1}} & \ frac {\ partial y_ {2}} {\ partial x_ {2}} & \ frac {\ partial y_ {2}} {\ partial x_ {3}} \\ \ frac {\ partial y_ {3}} {\ partial x_ {1}} & \ frac {\ partial y_ {3}} {\ partial x_ {2}} & \ frac {\ partial y_ {3}} {\ partial x_ {3}} \ end {array} \ right) = \ left (\ begin { array} {ccc} 2 x_ {1} & 0 & 0 \\ 0 & 2 x_ {2} & 0 \\ 0 & 0 & 2 x_ {3} \ end {array} \ right)$

Entre ellos $y_ {1} = f_ {1} \ left (x_ {1}, x_ {2}, x_ {3} \ right) = x_ {1} ^ {2}$ , se trata de $\ left (x_ {1}, x_ {2}, x_ {3} \ right)$ la función, no solo de x1, la particularidad aquí es causada por el mecanismo de operación Element-Wise, la misma razón y2, y3

La derivada (tasa de cambio ) de d (Y) para cada componente es la derivada parcial de cada función de componente , y = 1,2,3

La acumulación de v a lo largo de una determinada dirección. En general, la dirección predeterminada de v es .

También puede pasar en diferentes direcciones, que es el gradiente externo de alimentación fácil reclamado en documentos oficiales.

Aquí, puede entenderse como: la proyección del vector derivado parcial en la dirección v ;

Puede entenderse como: una función de cada componente de la derivada parcial de los pesos .

v Una vez determinados, los pesos para cada uno están determinados y son los mismos.

Experimenta con:

Jacobio implícito simple

>>> x = torch.randn(3, requires_grad = True)
>>> x
tensor([-0.9238,  0.4353, -1.3626], requires_grad=True)
>>> y = x**2
>>> y.backward(torch.ones(3))
>>> x.grad
tensor([-1.8476,  0.8706, -2.7252])
>>> x
tensor([-0.9238,  0.4353, -1.3626], requires_grad=True)
>>>

Visualización de dos simples de verificación jacobiana

>>> x1=torch.tensor(1, requires_grad=True, dtype = torch.float)
>>> x2=torch.tensor(2, requires_grad=True, dtype = torch.float)
>>> x3=torch.tensor(3, requires_grad=True, dtype = torch.float)
>>> y=torch.randn(3) # produce a random vector for vector function define
>>> y[0]=x1**2+2*x2+x3 # define each vector function
>>> y[1]=x1+x2**3+x3**2
>>> y[2]=2*x1+x2**2+x3**3
>>> y.backward(torch.ones(3))
>>> x1.grad
tensor(5.)
>>> x2.grad
tensor(18.)
>>> x3.grad
tensor(34.)

La matriz jacobiana en el código anterior es: $J = \ left (\ begin {array} {ccc} 2 x_ {1} & 2 & 1 \\ 1 & 3 x_ {2} ^ {2} & 2 x_ {3} \\ 2 & 2 x_ {2} & 3 x_ {3} ^ {2} \ end {array} \ right)$

Las funciones del componente son: $\ left \ {\ begin {array} {l} y_ {1} = x_ {1} ^ {2} +2 x_ {2} + x_ {3} \\ y_ {2} = x_ {1} + x_ { 2} ^ {3} + x_ {3} ^ {2} \\ y_ {3} = 2 x_ {1} + x_ {2} ^ {2} + x_ {3} ^ {3} \ end {array} \derecho.$

Dirección de proyección: $v = (1,1,1)$

$v \ circ J = \ left [2 x_ {1} + 1 + 2,2 + 3 x_ {2} ^ {2} +2 x_ {2}, 1 + 2 x_ {3} +3 x_ {3} ^ {2} \ right] = [5,18,34]$ Los resultados del código y el análisis se confirman

Tres --- proyección a diferentes direcciones $v = (3,2,1)$

Análisis previo:

$v \ circ J = \ left [3 * 2 x_ {1} +2 * 1 + 1 * 2,3 * 2 + 2 * 3 x_ {2} ^ {2} +1 * 2 x_ {2}, 3 * 1 + 2 * 2 x_ {3} +1 * 3 x_ {3} ^ {2} \ right] = [10,34,42]$

Verificación de código:

>>> x1=torch.tensor(1, requires_grad=True, dtype = torch.float)
>>> x2=torch.tensor(2, requires_grad=True, dtype = torch.float)
>>> x3=torch.tensor(3, requires_grad=True, dtype = torch.float)
>>> y=torch.randn(3)
>>> y[0]=x1**2+2*x2+x3
>>> y[1]=x1+x2**3+x3**2
>>> y[2]=2*x1+x2**2+x3**3
>>> v=torch.tensor([3,2,1],dtype=torch.float)
>>> y.backward(v)
>>> x1.grad
tensor(10.)
>>> x2.grad
tensor(34.)
>>> x3.grad
tensor(42.)

Cumplimiento total

experto en blogs estrella fría

Publicado 469 artículos originales · elogiados 329 · 600,000 visitas

Sus tablero de mensajes preocupaciones