Pytorch, was sind die Argumente Farbverlauf

Erklärung

Für neuronale Netze, verwenden wir normalerweise loss zu beurteilen, wie gut das Netz gelernt hat, zu klassifizieren, das input-Bild (oder andere Aufgaben). Die loss Begriff ist in der Regel eine skalaren Wert. Um die änderung der Parameter von dem Netzwerk, wir berechnen den Gradienten der loss w.r.t, um die Parameter, die tatsächlich leaf node in der computation-graph (by the way, sind diese Parameter meist das Gewicht und die Ausrichtung der verschiedenen Schichten wie Faltung, Lineare und so weiter).

Laut Kettenregel, zur Berechnung der Gradienten der loss w.r.t zu einem Blatt-Knoten, lässt sich berechnen, Ableitung von loss w.r.t einige temporäre Variablen und Gradienten der Zwischengröße w.r.t-leaf-variable, machen Sie eine dot-Produkt und die Summe aller dieser bis.

Den gradient Argumente eines Variable's backward() Methode wird verwendet, um berechnen einer gewichteten Summe der einzelnen Elemente einer Variablen w.r.t die Blatt-Variable. Diese Gewicht ist nur das Derivat der Letzte loss w.r.t jedes element der Zwischengröße.

Ein konkretes Beispiel

Nehmen wir ein konkretes und einfaches Beispiel zu verstehen.

from torch.autograd import Variable
import torch
x = Variable(torch.FloatTensor([[1, 2, 3, 4]]), requires_grad=True)
z = 2*x
loss = z.sum(dim=1)

# do backward for first element of z
z.backward(torch.FloatTensor([[1, 0, 0, 0]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_() #remove gradient in x.grad, or it will be accumulated

# do backward for second element of z
z.backward(torch.FloatTensor([[0, 1, 0, 0]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_()

# do backward for all elements of z, with weight equal to the derivative of
# loss w.r.t z_1, z_2, z_3 and z_4
z.backward(torch.FloatTensor([[1, 1, 1, 1]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_()

# or we can directly backprop using loss
loss.backward() # equivalent to loss.backward(torch.FloatTensor([1.0]))
print(x.grad.data)    

Im obigen Beispiel wird das Ergebnis der ersten print ist

2 0 0 0

[Fackel.FloatTensor der Größe 1x4]

das ist genau die Ableitung von z_1 w.r.t x.

Das Ergebnis der zweiten print ist :

0 2 0 0

[Fackel.FloatTensor der Größe 1x4]

was ist die Ableitung von z_2 w.r.t x.

Nun, wenn verwenden Sie ein Gewicht, von [1, 1, 1, 1] berechnen Sie die Ableitung von z w.r.t auf x, das Ergebnis ist 1*dz_1/dx + 1*dz_2/dx + 1*dz_3/dx + 1*dz_4/dx. Also nicht überraschend, dass die Ausgabe der 3. print ist:

2 2 2 2

[Fackel.FloatTensor der Größe 1x4]

Es sollte angemerkt werden, dass das Gewicht den Vektor [1, 1, 1, 1] ist genau das, Derivat von loss w.r.t z_1, z_2, z_3 und z_4. Die Ableitung von loss w.r.t x wird wie folgt berechnet:

d(loss)/dx = d(loss)/dz_1 * dz_1/dx + d(loss)/dz_2 * dz_2/dx + d(loss)/dz_3 * dz_3/dx + d(loss)/dz_4 * dz_4/dx

Also die Ausgabe des 4. print ist der gleiche wie der 3.print:

2 2 2 2

[Fackel.FloatTensor der Größe 1x4]

Hier wird die Ausgabe des vorwärts - (), d.h. y ist ein 3-Vektor.

Die drei Werte sind die Verläufe am Ausgang des Netzes. Sie sind in der Regel auf 1.0 gesetzt, wenn y ist die Letzte Ausgabe, können aber auch andere Werte, vor allem, wenn y ist Teil eines größeren Netzwerks.

ZB. wenn x die Eingabe, y = [y1, y2, y3] ist eine intermediate-Ausgang, die verwendet wird zum berechnen der endgültigen Ausgabe z,

Dann,

dz/dx = dz/dy1 * dy1/dx + dz/dy2 * dy2/dx + dz/dy3 * dy3/dx

So, hier die drei Werte sind rückwärts

[dz/dy1, dz/dy2, dz/dy3]

und dann rückwärts() berechnet dz/dx