Regresja liniowa przy użyciu PyTorch

kryterium = torch.nn.MSELoss (size_average = False )

optymalizator = torch.optim.SGD (our_model.parameters (), lr = 0,01 )

Teraz dochodzimy do etapu nauki. Podczas szkolenia 500 razy wykonujemy następujące zadania:

1. Wykonaj transfer na żywo, przekazując nasze dane i obliczając przewidywaną wartość y.
2. Oblicz straty za pomocą MSE.
3. Zresetuj wszystkie gradienty do 0, propaguj wstecz, a następnie zaktualizuj wagi.

for epoch w zakresie ( 500 ):

# Przejście do przodu: oblicz przewidywane y przez przekazanie

#x do modelu

pred_y = our_model (x_data)

# Oblicz i trać wydruk

strata = kryterium (pred_y, y_data)

# Zero gradientów, cofanie się

# i zaktualizuj wagę.

optimr.zero_grad()

loss.backward ()

Optimizer.step ()

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

Po ukończeniu szkolenia sprawdzamy, czy otrzymujemy poprawne wyniki za pomocą zdefiniowany przez nas model. Sprawdzamy więc, czy nie ma nieznanej wartości x_data, w tym przypadku 4.0.

new_var = Zmienna (latarka.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "przewiduj (po szkoleniu) " , 4 , nasz_model ( new_var) .data [ 0 ] [ 0 ])

Jeśli poprawnie wykonałeś wszystkie kroki, zobaczysz, że dla wpisu 4.0 otrzymasz wartość bardzo bliska 8,0, jak pokazano poniżej. W ten sposób nasz model zasadniczo uczy się relacji między wejściem a wyjściem bez wyraźnego programowania.

przewiduj (po szkoleniu) 4 7.966438293457031

Dla odniesienia można znaleźć cały kod tego artykułu poniżej:

import latarka

z torch.autograd importuj Zmienna

x_data = Zmienna (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 ) # Jedno wejście i jedno wyjście

def forward ( self , x):

y_pred = self . linear (x)

return y_pred

# nasz model

nasz_model = LinearRegressionModel ()

kryterium = torch.nn.MSELoss (size_average = False )

optymalizator = latarka.optim. SGD (our_model.parameters (), lr = 0,01 )

for epoch in range ( 500 ):

# Przejście do przodu: oblicz przewidywane y przez przekazanie

# —Ö do modelu

pred_y = nasz_model (x_data)

loss = < klasa kodu ="plain "> kryterium (pred_y, y_data)

# Zero gradientów, wsteczne podanie,

# i zaktualizuj wagę.

optimer.zero_grad()

loss.backward ()

optimer.step ()

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

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

pred_y = our_model (new_var)

print ( "przewidywanie (po szkoleniu)" , 4 , nasz_model (nowa_zmienna) .data [ 0 ] [ 0 ])