Regresión lineal usando PyTorch

criterio = antorcha.nn.MSELoss (tamaño_promedio = Falso )

optimizador = torch.optim.SGD (nuestro_modelo.parámetros()), lr = 0.01 )

Ahora llegamos a nuestra etapa de aprendizaje. Realizamos las siguientes tareas 500 veces durante el entrenamiento:

1. Realizar una transferencia en vivo pasando nuestros datos y calculando el valor y previsto.
2. Calcule la pérdida usando MSE.
3. Restablecer todos los gradientes a 0, propagar hacia atrás y luego actualizar los pesos.

para época en rango ( 500 ):

# Pase adelante: calcule y pronosticado pasando

#x al modelo

pred_y = nuestro_modelo (x_data)

# Calcular y perder impresión

pérdida = criterio (pred_y, y_data)

# Gradientes cero, retroceso

# y actualice el peso.

Optimizer.zero_grad ()

pérdida.hacia atrás()

optimizador.paso()

imprimir ( ` epoch {}, loss {} ` . formato (época, pérdida.datos [ 0 ]))

Después de completar el entrenamiento comprobamos si estamos obteniendo los resultados correctos usando el modelo que hemos definido. Así que buscamos un valor x_data desconocido, en este caso 4.0.

new_var < código clase = "palabra clave"> = Variable (antorcha.Tensor ([[[ 4.0 ] ]))

pred_y = nuestro_modelo ( new_var)

print ( "predecir (después del entrenamiento)" , 4 , nuestro_modelo ( new_var) .data [ 0 ] [ 0 ])

Si seguiste todos los pasos correctamente, verás que para la entrada 4.0 obtienes un valor muy cercano a 8.0, como se muestra a continuación. Por lo tanto, nuestro modelo esencialmente aprende la relación entre la entrada y la salida sin programación explícita.

predict (después del entrenamiento) 4 7.966438293457031

Para referencia, puede encontrar todo el código de este artículo a continuación:

import torch

de torch.autograd importar Variable

x_data < código clase = "palabra clave"> = Variable (antorcha.Tensor ([[ 1.0 ], [ 2.0 ], [ 3.0 ]]))

y_data = V ariable (torch.Tensor ([[ 2.0 ], [ 4.0 < /código> ], [ 6.0 ]]))

clase LinearRegressionModel (torch.nn.Module):

def __ init __ ( self ):

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

self . lineal = torch.nn.Linear ( 1 < clase de código = "simple">, 1 ) # Una entrada y una salida

def adelante ( self , x):

y_pred = self . lineal (x)

return y_pred

# nuestro modelo

nuestro_modelo = < código class="simple"> Modelo de regresión lineal ()

criterio = torch.nn.MSELoss (size_average = Falso < clase de código = "simple"> )

optimizador = antorcha.optim. SGD (nuestro_modelo.parámetros()), lr = 0.01 )

para época en rango ( 500 ):

# Pase adelante: calcula y predicho pasando

# —Ö modelar

pred_y = nuestro_modelo (x_data)

< código clase = "comentarios"> # Calcular y perder imprimir

pérdida = < código clase ="normal "> criterio (pred_y, y_data)

# Gradientes cero, paso atrás,

# y actualizar el peso.

Optimizer.zero_grad()

loss.backward()

Optimizer.step ()

imprimir ( `época {}, pérdida {}` . formato (época, pérdida.datos [ 0 < clase de código = "simple">]))

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

pred_y = nuestro_modelo (nueva_var)

imprimir ( "predecir (después del entrenamiento)" , 4 , nuestro_modelo (nueva_var) .data [ 0 ] [ 0 ])