Regresión lineal usando PyTorch

La Regresión Lineal es un método estadístico muy utilizado que nos permite determinar y estudiar la relación entre dos variables continuas. Las diversas propiedades de la regresión lineal y su implementación en Python se han cubierto en este artículo anteriormente. Ahora, descubriremos cómo implementar esto en PyTorch, una biblioteca de aprendizaje profundo muy popular que está siendo desarrollada por Facebook.
En primer lugar, deberá instalar PyTorch en su entorno de Python. La forma más fácil de hacer esto es usar la herramienta pip o conda. Visite pytorch.org e instale la versión de su intérprete de Python y el administrador de paquetes que le gustaría usar. 
 

# We can run this Python code on a Jupyter notebook
# to automatically install the correct version of
# PyTorch.
 
# http://pytorch.org / from os import path
from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag
platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())
 
accelerator = 'cu80' if path.exists('/opt / bin / nvidia-smi') else 'cpu'
 
! pip install -q http://download.pytorch.org / whl/{accelerator}/torch-1.3.1.post4-{platform}-linux_x86_64.whl torchvision

Con PyTorch instalado, ahora echemos un vistazo al código. 
Escriba las dos líneas dadas a continuación para importar las funciones y objetos de biblioteca necesarios. 
 

import torch
from torch.autograd import Variable

También definimos algunos datos y los asignamos a las variables x_data e y_data como se indica a continuación: 
 

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

Aquí, x_data es nuestra variable independiente y y_data es nuestra variable dependiente. Este será nuestro conjunto de datos por ahora. A continuación, necesitamos definir nuestro modelo. Hay dos pasos principales asociados con la definición de nuestro modelo. Están: 
 

1. Inicializando nuestro modelo.
2. Declarar el pase adelantado.

Usamos la clase dada a continuación: 
 

class LinearRegressionModel(torch.nn.Module):
 
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)  # One in and one out
 
    def forward(self, x):
        y_pred = self.linear(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 la dimensión de entrada y salida como 1.
A continuación, creamos un objeto de este modelo. 
 

# our model
our_model = LinearRegressionModel()

Después de esto, seleccionamos el optimizador y los 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. Además, fijamos arbitrariamente una tasa de aprendizaje de 0,01.
 

criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(our_model.parameters(), lr = 0.01)

Ahora llegamos a nuestro paso de entrenamiento. Realizamos las siguientes tareas 500 veces durante el entrenamiento: 
 

1. Realice un pase hacia adelante sin pasar por nuestros datos y averigüe el valor predicho de y.
2. Calcule la pérdida usando MSE.
3. Restablezca todos los gradientes a 0, realice una retropropagación y luego actualice los pesos.

for epoch in range(500):
 
    # Forward pass: Compute predicted y by passing
    # x to the model
    pred_y = our_model(x_data)
 
    # Compute and print loss
    loss = criterion(pred_y, y_data)
 
    # Zero gradients, perform a backward pass,
    # and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print('epoch {}, loss {}'.format(epoch, loss.item()))

Una vez que se completa el entrenamiento, probamos si estamos obteniendo resultados correctos utilizando el modelo que definimos. Entonces, lo probamos para un valor desconocido de x_data , en este caso, 4.0. 
 

new_var = Variable(torch.Tensor([[4.0]]))
pred_y = our_model(new_var)
print("predict (after training)", 4, our_model(new_var).item())

Si realizó todos los pasos correctamente, verá que para la entrada 4.0, obtiene un valor muy cercano a 8.0 como se muestra a continuación. Entonces, nuestro modelo aprende inherentemente la relación entre los datos de entrada y los datos de salida sin ser programado explícitamente.
predecir (después del entrenamiento) 4 7.966438293457031
Para su referencia, puede encontrar el código completo de este artículo a continuación: 
 

import torch
from torch.autograd import Variable
 
x_data = Variable(torch.Tensor([[1.0], [2.0], [3.0]]))
y_data = Variable(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)  # One in and one out
 
    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred
 
# our model
our_model = LinearRegressionModel()
 
criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(our_model.parameters(), lr = 0.01)
 
for epoch in range(500):
 
    # Forward pass: Compute predicted y by passing
    # x to the model
    pred_y = our_model(x_data)
 
    # Compute and print loss
    loss = criterion(pred_y, y_data)
 
    # Zero gradients, perform a backward pass,
    # and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print('epoch {}, loss {}'.format(epoch, loss.item()))
 
new_var = Variable(torch.Tensor([[4.0]]))
pred_y = our_model(new_var)
print("predict (after training)", 4, our_model(new_var).item())

Referencias

• PyTorchZeroToAll
• Estado de Pensilvania STAT 501