Regressione lineare utilizzando PyTorch

criterio = torch.nn.MSELoss (size_average = Falso )

ottimizzatore = torch.optim.SGD (our_model.parameters()), lr = 0.01 )

Ora arriviamo alla nostra fase di apprendimento. Eseguiamo le seguenti attività 500 volte durante l`allenamento:

1. Eseguiamo un trasferimento in tempo reale passando i nostri dati e calcolando il valore y previsto.
2. Calcola la perdita utilizzando MSE.
3. Reimposta tutti i gradienti su 0, propaga indietro e quindi aggiorna i pesi.

for epoch in range ( 500 ):

# Forward pass: calcola la y prevista passando

#x al modello

pred_y = our_model (x_data)

# Calcola e perdi stampa

perdita = criterio (pred_y, y_data)

# Zero gradienti, backtrack

# e aggiorna il peso.

optimizer.zero_grad ()

loss.backward()

optimizer.step()

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

Dopo aver completato la formazione controlliamo se stiamo ottenendo i risultati corretti utilizzando il modello che abbiamo definito. Quindi controlliamo un valore x_data sconosciuto, in questo caso 4.0.

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

pred_y = our_model ( new_var)

print ( "predict ( dopo l`allenamento) " , 4 , our_model ( nuova_var) .data [ 0 ] [ 0 ])

Se hai seguito correttamente tutti i passaggi, vedrai che per l`immissione 4.0 ottieni un valore molto vicino a 8,0, come mostrato di seguito. Pertanto, il nostro modello apprende essenzialmente la relazione tra input e output senza una programmazione esplicita.

predict (dopo l`addestramento) 4 7.966438293457031

Per riferimento, puoi trovare tutto il codice per questo articolo qui sotto:

import torcia

from torch.autograd import Variabile

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

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

classe LinearRegressionModel (torch.nn.Module):

def __ init __ ( self ):

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

self . lineare = torch.nn.Linear ( 1 , 1 ) # Un input e un output

def forward ( self , x):

y_pred = self . lineare (x)

return y_pred

# il nostro modello

our_model = LinearRegressionModel()

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

ottimizzatore = torcia.ottim. SGD (our_model.parameters (), lr = 0.01 )

for epoch in range ( 500 ):

# Passaggio in avanti: calcola la y prevista passando

# —Ö per modellare

pred_y = our_model (x_data)

loss = < codice classe ="plain "> criterio (pred_y, y_data)

# Zero gradienti, back pass,

# e aggiorna il peso.

optimizer.zero_grad()

loss.backward()

optimizer.step()

print ( `epoca {}, perdita {}` . formato (epoca, loss.data [ 0 ]))

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

pred_y = our_model (new_var)

print ( "predict (dopo l`allenamento)" , 4 , our_model (new_var) .data [ 0 ] [ 0 ])