Lineare Regression mit PyTorch

Kriterium = Torch.nn.MSELoss (size_average = Falsch )

Optimierer = Torch.optim.SGD (our_model.parameters (), lr = 0,01 )

Nun kommen wir zu unserer Lernphase. Wir führen die folgenden Aufgaben 500 Mal während des Trainings durch:

1. Führen Sie eine Live-Übertragung durch, indem Sie unsere Daten übergeben und den vorhergesagten y-Wert ermitteln.
2. Berechnen Sie den Verlust mit MSE.
3. Setzen Sie alle Gradienten auf 0 zurück, übertragen Sie sie zurück und aktualisieren Sie dann die Gewichtungen.

für Epoche im Bereich ( 500 ):

# Forward pass: berechnet das vorhergesagte y durch Übergeben von

#x zum Modell

pred_y = our_model (x_data)

# Berechnen und Druck verlieren

verlust = Kriterium (pred_y, y_data)

# Nullgradienten, Backtrack

# und aktualisiere das Gewicht.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

print ( ` Epoche {}, Verlust {} ` . format (epoch, loss.data [ 0 ]))

Nach Abschluss des Trainings prüfen wir, ob wir mit dem die richtigen Ergebnisse erzielen Modell, das wir definiert haben. Also prüfen wir es auf einen unbekannten x_data-Wert, in diesem Fall 4.0.

new_var = Variable (torch.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "vorhersagen (nach dem Training) " , 4 , our_model ( new_var) .data [ 0 ] [ 0 ])

Wenn Sie alle Schritte korrekt befolgt haben, werden Sie sehen, dass Sie für Eintrag 4.0 eine erhalten Wert sehr nahe bei 8,0, wie unten gezeigt. Somit lernt unser Modell im Wesentlichen die Beziehung zwischen Eingabe und Ausgabe ohne explizite Programmierung.

predict (after training) 4 7.966438293457031

Als Referenz finden Sie den gesamten Code für diesen Artikel unten:

import Torch

aus Torch.autograd import Variable

x_data = Variable (torch.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = V ariable (torch.Tensor ([[ 2.0 ], [ 4.0 ], [ 6.0 ]]))

class LinearRegressionModel (torch.nn.Module):

def __ init __ ( self ):

super (LinearRegressionModel, self ) .__ init __ ()

self . linear = Torch.nn.Linear ( 1 , 1 ) # Eine Eingabe und eine Ausgabe

def forward ( self , x):

y_pred = self . linear (x)

return y_pred

# unser Modell

our_model = LinearRegressionModel ()

Kriterium = Torch.nn.MSELoss (size_average = False )

Optimizer = taschenlampe.optim. SGD (our_model.parameters (), lr = 0.01 )

für Epoche in range ( 500 ):

# Vorwärtspass: berechnet vorhergesagtes y durch Übergeben

# —Ö zu modellieren

pred_y = our_model (x_data)

# Berechnen und verlieren print

verlust = Kriterium (pred_y, y_data)

# Nullgradienten, Rückpass,

# und Gewicht aktualisieren.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

print ( `epoch {}, loss {}` . format (epoch, loss.data [ 0 ]))

new_var = Variable (torch.Tensor ([[ 4.0 ]]))

pred_y = our_model (new_var)

print ( "predict (after training)" , 4 , our_model (new_var) .data [ 0 ] [ 0 ])