Regresión Lineal con Scikit-learn

Introducción

En este laboratorio, aprenderá los fundamentos de la construcción de un modelo de aprendizaje automático utilizando una de las bibliotecas de Python más populares, scikit-learn. Nos centraremos en la Regresión Lineal, un algoritmo básico pero potente utilizado para predecir un valor continuo, como un precio o una temperatura.

Nuestro objetivo es construir un modelo que pueda predecir los precios medios de la vivienda en distritos de California. Utilizaremos el conjunto de datos de vivienda de California, que está convenientemente incluido con scikit-learn.

A lo largo de este laboratorio, aprenderá a:

• Cargar un conjunto de datos de scikit-learn.
• Preparar y dividir los datos para entrenamiento y prueba.
• Crear y entrenar un modelo de Regresión Lineal.
• Utilizar el modelo entrenado para hacer predicciones.

Realizará todas las tareas dentro del WebIDE. ¡Empecemos!

Cargar el conjunto de datos de vivienda de California con datasets.fetch_california_housing()

En este paso, comenzaremos cargando el conjunto de datos para nuestro modelo. scikit-learn viene con varios conjuntos de datos integrados, que son excelentes para aprender y practicar. Utilizaremos el conjunto de datos de vivienda de California.

Primero, necesitamos crear un script de Python. Ya se ha creado un archivo llamado main.py en el directorio ~/project. Puede encontrarlo en el explorador de archivos en el lado izquierdo del WebIDE.

Abra main.py y agregue el siguiente código. Este código importa las bibliotecas necesarias (fetch_california_housing de sklearn.datasets y pandas) y carga el conjunto de datos. Utilizaremos pandas para convertir los datos en un DataFrame, que es una estructura de datos tabular fácil de ver y manipular.

Por favor, agregue el siguiente código a main.py:

import pandas as pd
from sklearn.datasets import fetch_california_housing

## Load the California housing dataset
california = fetch_california_housing()

## Create a DataFrame
california_df = pd.DataFrame(california.data, columns=california.feature_names)
california_df['MedHouseVal'] = california.target

## Print the first 5 rows of the DataFrame
print("California Housing Dataset:")
print(california_df.head())

Ahora, ejecutemos el script para ver la salida. Abra una terminal en el WebIDE (puede usar el menú "Terminal" -> "New Terminal") y ejecute el siguiente comando:

python3 main.py

Debería ver las primeras cinco filas del conjunto de datos impresas en la consola. La columna MedHouseVal es nuestra variable objetivo, que representa el valor medio de la vivienda para los distritos de California, expresado en cientos de miles de dólares ($100,000).

California Housing Dataset:
   MedInc  HouseAge  AveRooms  AveBedrms  Population  AveOccup  Latitude  Longitude  MedHouseVal
0  8.3252      41.0  6.984127   1.023810       322.0  2.555556     37.88    -122.23        4.526
1  8.3014      21.0  6.238137   0.971880      2401.0  2.109842     37.86    -122.22        3.585
2  7.2574      52.0  8.288136   1.073446       496.0  2.802260     37.85    -122.24        3.521
3  5.6431      52.0  5.817352   1.073059       558.0  2.547945     37.85    -122.25        3.413
4  3.8462      52.0  6.281853   1.081081       565.0  2.181467     37.85    -122.25        3.422

Dividir los datos en entrenamiento y prueba usando train_test_split de sklearn.model_selection

En este paso, prepararemos nuestros datos para el proceso de entrenamiento. Una parte crucial del aprendizaje automático es evaluar el modelo con datos que nunca ha visto antes. Para hacer esto, dividimos nuestro conjunto de datos en dos partes: un conjunto de entrenamiento y un conjunto de prueba. El modelo aprenderá del conjunto de entrenamiento y utilizaremos el conjunto de prueba para ver qué tan bien se desempeña.

Primero, necesitamos separar nuestras características (las variables de entrada, X) de nuestro objetivo (el valor que queremos predecir, y). En nuestro caso, X serán todas las columnas excepto MedHouseVal, y y será la columna MedHouseVal.

Luego, utilizaremos la función train_test_split de sklearn.model_selection para realizar la división.

Agregue el siguiente código a su archivo main.py.

from sklearn.model_selection import train_test_split

## Prepare the data
X = california_df.drop('MedHouseVal', axis=1)  ## Features (input variables)
y = california_df['MedHouseVal']  ## Target variable (what we want to predict)

## Split the data into training and testing sets
## test_size=0.2: Reserve 20% of data for testing, 80% for training
## random_state=42: Ensures reproducible splits (same result every run)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Print the shapes of the new datasets to confirm the split
print("\n--- Data Split ---")
print("X_train shape:", X_train.shape)  ## Training features
print("X_test shape:", X_test.shape)    ## Test features
print("y_train shape:", y_train.shape)  ## Training target values
print("y_test shape:", y_test.shape)    ## Test target values

Ahora, ejecute el script nuevamente desde la terminal:

python3 main.py

Verá las formas de los conjuntos de entrenamiento y prueba recién creados impresas debajo del DataFrame. Esto confirma que los datos se han dividido correctamente.

--- Data Split ---
X_train shape: (16512, 8)
X_test shape: (4128, 8)
y_train shape: (16512,)
y_test shape: (4128,)

Inicializar el modelo LinearRegression de sklearn.linear_model

En este paso, crearemos nuestro modelo de Regresión Lineal. scikit-learn lo hace increíblemente simple. Solo necesitamos importar la clase LinearRegression del módulo sklearn.linear_model y luego crear una instancia de ella.

Esta instancia es un objeto que contiene el algoritmo de regresión lineal. La regresión lineal encuentra la línea que mejor se ajusta a los puntos de datos, utilizando la fórmula: y = mx + b, donde m son los coeficientes (pesos) para cada característica, y b es la intersección. Aquí usamos parámetros predeterminados que funcionan bien para la mayoría de los casos básicos.

Figura 1: Fórmula de regresión lineal y = mx + b, donde m es la pendiente y b es la intersección

Agregue el siguiente código a su archivo main.py. Esto importará la clase LinearRegression y creará un objeto modelo.

from sklearn.linear_model import LinearRegression

## Inicializar el modelo de Regresión Lineal
model = LinearRegression()

## Imprimir el modelo para confirmar que se ha creado
print("\n--- Modelo Inicializado ---")
print(model)

Ejecute su script main.py nuevamente desde la terminal:

python3 main.py

La salida ahora incluirá una línea que muestra el objeto LinearRegression. Esto confirma que el modelo se ha inicializado correctamente.

--- Model Initialized ---
LinearRegression()

Ajustar el modelo con model.fit(X_train, y_train)

En este paso, entrenaremos nuestro modelo. Este proceso a menudo se denomina "ajustar" el modelo a los datos. Durante el ajuste, el modelo aprende las relaciones entre las características (X_train) y la variable objetivo (y_train). Para la regresión lineal, esto significa encontrar los coeficientes óptimos para cada característica para predecir mejor el objetivo.

Utilizaremos el método fit() de nuestro objeto modelo, pasando nuestros datos de entrenamiento como argumentos.

Agregue el siguiente código a su archivo main.py.

## Fit (train) the model on the training data
## The fit() method learns the relationship between features (X_train) and target (y_train)
## It calculates optimal coefficients for each feature and the intercept using least squares optimization
model.fit(X_train, y_train)

## After fitting, the model has learned the coefficients and intercept.
## The intercept represents the predicted value when all features are zero
print("\n--- Model Trained ---")
print("Intercept:", model.intercept_)

Ahora, ejecute el script desde la terminal:

python3 main.py

Después de que se ejecute el script, verá una nueva sección en la salida que muestra la intersección del modelo de regresión lineal. La intersección es el valor de la predicción cuando todos los valores de las características son cero. Ver un valor numérico aquí confirma que el modelo se ha entrenado correctamente con los datos.

--- Model Trained ---
Intercept: -37.023277706064185

Predecir sobre datos de prueba con model.predict(X_test)

En este paso final, utilizaremos nuestro modelo entrenado para hacer predicciones. Este es el objetivo final de construir un modelo predictivo. Utilizaremos los datos de prueba (X_test), que el modelo no ha visto durante el entrenamiento, para evaluar su rendimiento.

Utilizaremos el método predict() de nuestro objeto modelo entrenado, pasando las características de prueba (X_test) como argumento. El método devolverá una matriz de valores predichos para la variable objetivo.

Agregue el siguiente código a su archivo main.py.

## Make predictions on the test data
## The predict() method uses the learned coefficients and intercept to calculate predictions
## Formula: prediction = intercept + (coeff1 * feature1) + (coeff2 * feature2) + ...
predictions = model.predict(X_test)

## Print the first 5 predictions (values are in $100,000 units)
print("\n--- Predictions ---")
print(predictions[:5])

Ahora, ejecute el script completo una última vez desde la terminal:

python3 main.py

La salida ahora incluirá los primeros cinco precios de casas predichos para el conjunto de prueba. Estos valores son lo que nuestro modelo cree que deberían ser los valores medianos de las casas, basándose en las características en X_test. Puede comparar conceptualmente estas predicciones con los valores reales en y_test para evaluar la precisión del modelo.

--- Predictions ---
[0.71912284 1.76401657 2.70965883 2.83892593 2.60465725]

¡Felicitaciones! Ha construido, entrenado y utilizado con éxito un modelo de regresión lineal con scikit-learn.

Resumen

En este laboratorio, ha completado todo el flujo de trabajo para construir un modelo básico de aprendizaje automático utilizando scikit-learn.

Comenzó cargando el conjunto de datos de vivienda de California y preparándolo usando pandas. Luego, aprendió la importancia de dividir sus datos en conjuntos de entrenamiento y prueba y realizó la división usando train_test_split.

Después de eso, inicializó un modelo LinearRegression, lo entrenó con sus datos de entrenamiento usando el método fit(), y finalmente usó el modelo entrenado para hacer predicciones sobre datos de prueba no vistos con el método predict().

Este laboratorio proporciona una base sólida en scikit-learn. A partir de aquí, puede explorar temas más avanzados como:

• Evaluación del modelo: Calcular métricas como el Error Cuadrático Medio (MSE) o el R-cuadrado para medir la precisión del modelo.
• Escalado de características: Estandarizar o normalizar características para un mejor rendimiento.
• Regularización: Usar regresión Ridge o Lasso para prevenir el sobreajuste (overfitting).
• Validación cruzada: Una evaluación más robusta utilizando validación cruzada k-fold.
• Otros algoritmos: Probar Random Forest, Support Vector Machines (Máquinas de Vectores de Soporte) o Redes Neuronales.

Summary

In this lab, you have completed the entire workflow for building a basic machine learning model using scikit-learn.

You started by loading the California housing dataset and preparing it using pandas. Then, you learned the importance of splitting your data into training and testing sets and performed the split using train_test_split.

Following that, you initialized a LinearRegression model, trained it on your training data using the fit() method, used the trained model to make predictions on unseen test data with the predict() method, and finally visualized the results to understand your model's performance.

This lab provides a solid foundation in scikit-learn. From here, you can explore more advanced topics such as:

• Model evaluation: Calculate metrics like Mean Squared Error (MSE) or R-squared to measure model accuracy
• Data visualization: Create more advanced plots like residual plots, feature importance charts, or correlation matrices
• Feature scaling: Standardize or normalize features for better performance
• Regularization: Use Ridge or Lasso regression to prevent overfitting
• Cross-validation: More robust evaluation using k-fold cross-validation
• Other algorithms: Try Random Forest, Support Vector Machines, or Neural Networks