Lineare Regression mit PyTorch

| | | | | | | | | | | | | | | | | | | |

Zuerst müssen Sie PyTorch in Ihrer Python-Umgebung installieren. Der einfachste Weg, dies zu tun, ist — Verwenden Sie das Tool pip oder conda . Besuchen Sie pytorch.org und installieren Sie die Version Ihres Python-Interpreters und Paketmanagers, die Sie verwenden möchten.


# Wir können diesen Python-Code auf einem Jupyter-Notebook ausführen
# um automatisch die richtige Version zu installieren
# PyTorch.


# http://pytorch.org / vom Betriebssystem-Importpfad

von wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag

Plattform = `{} {} - {}` . format (get_abbr_impl (), get_impl_ver (), get_abi_tag ())

Beschleuniger = `cu80` if path.exists ( `/ opt / bin / nvidia-smi` ) else `cpu`


! pip install - q http: / / download.pytorch.org / whl / {beschleuniger} / Taschenlampe - 0.3 . 0.post4 - {platform} - linux_x86_64.whl Torchvision

Lassen Sie uns jetzt mit installiertem PyTorch beginnen Sehen Sie sich den Code an.
Schreiben Sie die beiden Zeilen unten, um die erforderlichen Bibliotheksfunktionen und -objekte zu importieren.


import Torch

aus Torch.autograd importieren Variable

Wir definieren auch einige Daten und weisen sie den Variablen x_data und y_data zu. em> wie folgt:


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

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

Hier x_data & #8212; unsere unabhängige Variable und y_data — unsere abhängige Variable. Dies wird vorerst unser Datensatz sein. Als nächstes müssen wir unser Modell definieren. Die Definition unseres Modells besteht aus zwei Hauptschritten. Sie sind:

  1. Initialisieren unseres Modells.
  2. Ansagen eines Vorwärtspasses.

Wir verwenden die folgende Klasse:

class LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

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

self . linear = Torch.nn.Linear ( 1 , 1 ) # Eine Eingabe und ein Ausgang


def forward ( self , x):

y_pred = self . linear (x)

return y_pred

Wie Sie sehen können, ist unsere Klasse Model eine Unterklasse von torch.nn.module. Da wir hier außerdem nur einen Eingang und einen Ausgang haben, verwenden wir ein lineares Modell mit einer Eingangs- und Ausgangsgröße von 1.

Als nächstes erstellen wir ein Objekt dieses Modells.

# unser Modell

our_model = LinearRegressionModel ()

Danach wählen Sie einen Optimierer und Verlustkriterien. Hier verwenden wir den mittleren quadratischen Fehler (MSE) als unsere Verlustfunktion und den stochastischen Gradientenabstieg (SGD) als unseren Optimierer. Außerdem legen wir die Lernrate willkürlich auf 0,01 fest.


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 ])

Links