Aprende Regresión Lineal

Utilizaremos un conjunto de datos real para implementar la regresión lineal en PyTorch. El conjunto de datos contiene dos columnas:

'Number of Appliances': número de electrodomésticos en un hogar (característica de entrada, X);
'Electricity Bill': importe correspondiente de la factura de electricidad (salida objetivo, Y).

1. Carga e inspección del conjunto de datos

El conjunto de datos está almacenado en un archivo CSV. Lo cargaremos utilizando pandas e inspeccionaremos las primeras filas:


              12345
            
import pandas as pd
# Load the dataset
bills_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/electricity_bills.csv')
# Display the first five rows
print(bills_df.head())

2. Preparación de los datos para PyTorch

A continuación, se deben extraer las columnas de entrada X y objetivo Y, convertirlas en tensores de PyTorch y reformatearlas como tensores 2D para garantizar la compatibilidad con las operaciones de PyTorch:


              12345678910
            
import torch
import pandas as pd
# Load the dataset
bills_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/electricity_bills.csv')
# Extract input (Number of Appliances) and target (Electricity Bill)
X = torch.tensor(bills_df['Number of Appliances'].values).float().reshape(-1, 1)
Y = torch.tensor(bills_df['Electricity Bill'].values).float().reshape(-1, 1)
# Print the shapes of X and Y
print(f"Shape of X: {X.shape}")
print(f"Shape of Y: {Y.shape}")

3. Definición del modelo lineal

El módulo nn.Linear en PyTorch define una capa totalmente conectada, realizando y = xWT + b. Es un componente fundamental en las redes neuronales y puede combinarse con otras capas para arquitecturas más complejas.

Sus parámetros clave son los siguientes:

in_features: número de características de entrada (variables independientes);
out_features: número de características de salida (valores predichos).

Para la regresión lineal simple, como en este caso, se predice una sola salida a partir de una entrada. Por lo tanto:

in_features=1: una variable de entrada;
out_features=1: un valor predicho.

import torch.nn as nn
# Define the linear regression model
model = nn.Linear(in_features=1, out_features=1)

4. Definición de la función de pérdida y el optimizador

Se utilizará el error cuadrático medio (MSE) como función de pérdida y el descenso de gradiente estocástico (SGD) como optimizador, con una tasa de aprendizaje igual a 0.005.

La pérdida MSE puede definirse utilizando la clase nn.MSELoss, y SGD mediante la clase correspondiente del módulo torch.optim.

import torch.optim as optim
# Define the loss function (MSE)
loss_fn = nn.MSELoss()
# Define the optimizer (SGD)
optimizer = optim.SGD(model.parameters(), lr=0.005)

5. Entrenamiento del modelo

El entrenamiento consiste en realizar un paso hacia adelante y un paso hacia atrás durante un número especificado de épocas.

Paso hacia adelante: este paso calcula las predicciones del modelo en función de los datos de entrada y calcula la pérdida comparando las predicciones con los valores reales objetivo;
Paso hacia atrás: este paso calcula los gradientes utilizando retropropagación (basada en la pérdida) y actualiza los pesos y sesgos del modelo utilizando un algoritmo de optimización, que en este caso es SGD.

Este proceso se repite durante el número especificado de épocas para minimizar la pérdida y mejorar el rendimiento del modelo.


              1234567891011121314151617181920212223242526272829303132333435
            
import torch
import torch.nn as nn
import torch.optim as optim
import pandas as pd
# Load the dataset
bills_df = pd.read_csv('https://staging-content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/electricity_bills.csv')
# Extract input (Number of Appliances) and target (Electricity Bill)
X = torch.tensor(bills_df['Number of Appliances'].values).float().reshape(-1, 1)
Y = torch.tensor(bills_df['Electricity Bill'].values).float().reshape(-1, 1)
# Define the linear regression model
model = nn.Linear(in_features=1, out_features=1)
# Define the loss function (MSE)
loss_fn = nn.MSELoss()
# Define the optimizer (SGD)
optimizer = optim.SGD(model.parameters(), lr=0.005)
# Training loop
epochs = 100
for epoch in range(epochs):
    # Forward pass
    Y_pred = model(X)
    loss = loss_fn(Y_pred, Y)

    # Backward pass
    optimizer.zero_grad()  # Reset gradients
    loss.backward()        # Compute gradients

    # Update parameters
    optimizer.step()

    if (epoch + 1) % 10 == 0:
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}")

# Final parameters
print(f"Trained weight: {model.weight.item()}")
print(f"Trained bias: {model.bias.item()}")

Los parámetros del modelo, es decir, sus pesos y sesgos, pueden accederse utilizando los atributos .weight y .bias:

weights = model.weight.item()
biases = model.bias.item()

Nota

optimizer.zero_grad() es importante porque restablece los gradientes de todos los parámetros antes de la retropropagación. Sin este paso, los gradientes se acumularían de pasos previos, lo que llevaría a actualizaciones incorrectas de los pesos del modelo. Esto asegura que cada pasada hacia atrás comience desde cero.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 1. Capítulo 13

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Desliza para mostrar el menú