Lineaire regressie met PyTorch

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

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

Nu komen we bij onze leerfase. We voeren de volgende taken 500 keer uit tijdens de training:

1. Voer een live overdracht uit door onze gegevens door te geven en de voorspelde y-waarde te berekenen.
2. Bereken verlies met MSE.
3. Stel alle gradiënten terug op 0, propageer terug en werk de gewichten bij.

voor tijdperk in bereik ( 500 ):

# Forward pass: bereken voorspeld y door

#x naar het model

pred_y = our_model (x_data)

# Bereken en verlies print

verlies = criterium (pred_y, y_data)

# Geen hellingen, terug

# en werk het gewicht bij.

optimizer.zero_grad ()

loss.backward ()

optimizer.step ()

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

Na het voltooien van de training controleren we of we de juiste resultaten behalen met behulp van de model dat we hebben gedefinieerd. We controleren het dus op een onbekende x_data waarde, in dit geval 4.0.

new_var = Variabele (toorts.Tensor ([[[ 4.0 ] ]))

pred_y = our_model ( new_var)

print ( "voorspellen ( na training) " , 4 , our_model ( new_var) .data [ 0 ] [ 0 ])

Als je alle stappen correct hebt gevolgd, zul je zien dat je voor invoer 4.0 een waarde zeer dicht bij 8,0, zoals hieronder weergegeven. Ons model leert dus in wezen de relatie tussen invoer en uitvoer zonder expliciete programmering.

predict (na training) 4 7.966438293457031

Ter referentie vindt u alle code voor dit artikel hieronder:

import torch

van torch.autograd importeren Variabele

x_data = Variabele (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 __ ( zelf ):

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

zelf . linear = torch.nn.Linear ( 1 , 1 ) # Eén invoer en één uitvoer

def forward ( zelf , x):

y_pred = zelf . lineair (x)

return y_pred

# ons model

our_model = LinearRegressionModel ()

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

optimizer = toorts.optim. SGD (our_model.parameters (), lr = 0,01 )

voor tijdperk in bereik ( 500 ):

# Forward pass: bereken voorspelde y door passeren

# —Ö om te modelleren

pred_y = our_model (x_data)