Regresión lineal usando PyTorch

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

Primero, deberá instalar PyTorch en su entorno de Python. La forma más fácil de hacer esto es — use la herramienta pip o conda . Visite pytorch.org e instale la versión de su intérprete de Python y administrador de paquetes que le gustaría usar.


# Podemos ejecutar este código de Python en un cuaderno Jupyter
# para instalar automáticamente la versión correcta
# PyTorch.


# http://pytorch.org / desde la ruta de importación del sistema operativo

desde < clase de código = "simple"> rueda.pep425tags importar get_abbr_impl, get_impl_ver, get_abi_tag

plataforma = `{} {} - {}` . formato (get_abbr_impl(), get_impl_ver()), get_abi_tag())

acelerador = < /código> `cu80` si ruta.existe ( `/ opt / bin / nvidia-smi` ) else `cpu`


! pip install - q http: / / download.pytorch.org / whl < /código> / {acelerador} / antorcha - 0.3 . 0.post4 - {plataforma} - linux_x86_64.whl torchvision

Con PyTorch instalado, ahora mire el código.
Escriba las dos líneas a continuación para importar las funciones y los objetos de biblioteca requeridos.


importar antorcha

de torch.autograd importar Variable

También definimos algunos datos y los asignamos a las variables x_data y y_data, como sigue:


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

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

Aquí x_data & #8212; nuestra variable independiente, y y_data — nuestra variable dependiente. Este será nuestro conjunto de datos por ahora. A continuación, necesitamos definir nuestro modelo. Hay dos pasos principales involucrados en la definición de nuestro modelo. Ellos son:

  1. Inicializar nuestro modelo.
  2. Declarar un pase adelantado.

Usamos la siguiente clase:

class LinearRegressionModel (torch.nn.Module):


def __ init __ ( self ):

super (Modelo de regresión lineal, self ) .__ init __ ()

self . lineal = antorcha.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

Como puede ver, nuestra clase Model es una subclase de torch.nn.module. Además, dado que aquí solo tenemos una entrada y una salida, usamos un modelo lineal con un tamaño de entrada y salida de 1.

A continuación, creamos un objeto de este modelo.

# nuestro modelo

nuestro_modelo = LinearRegressionModel ()

Después de eso, elija un optimizador y criterios de pérdida. Aquí usaremos el error cuadrático medio (MSE) como nuestra función de pérdida y el descenso de gradiente estocástico (SGD) como nuestro optimizador. También fijamos arbitrariamente la tasa de aprendizaje en 0,01.


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

Enlaces