2.6 - Notas de Luis - Primer modelo predictivo con scikit-learn¶

En este cuaderno, vamos a construir nuestro primer modelo predictivo utilizando la potente biblioteca scikit-learn de Python. Nos centraremos en la Regresión Lineal, un algoritmo fundamental en el aprendizaje automático, y exploraremos cómo scikit-learn simplifica el proceso de entrenamiento, evaluación y uso de modelos.

A lo largo de este cuaderno, cubriremos los siguientes pasos:

Importado de las bibliotecas necesarias: Cargaremos las herramientas de scikit-learn que necesitaremos.
Carga y preparación de los datos: Generaremos datos sintéticos para nuestro ejemplo.
Dividisión los datos en conjuntos de entrenamiento y prueba: Separaremos los datos para entrenar y evaluar el modelo de manera efectiva.
Entrenamiento del modelo: Ajustaremos el modelo de regresión lineal a nuestros datos de entrenamiento.
Evaluación del modelo: Mediremos el rendimiento del modelo utilizando métricas estándar.
Visualización de los resultados: Graficaremos los datos y la recta de regresión para una comprensión visual.
Uso del modelo para hacer predecciones: Realizaremos predicciones con el modelo entrenado.

Paso 1: Importado de las bibliotecas necesarias¶

En esta sección, importaremos las funciones y clases esenciales de la biblioteca scikit-learn que necesitaremos para construir, entrenar, evaluar y utilizar nuestro modelo de regresión lineal.

In [8]:

# Importamos LinearRegression para construir el modelo
from sklearn.linear_model import LinearRegression

# Importamos train_test_split para dividir los datos en conjuntos de entrenamiento y prueba
from sklearn.model_selection import train_test_split

# Importamos mean_squared_error y r2_score para evaluar el modelo
from sklearn.metrics import mean_squared_error, r2_score

Paso 2: Carga y preparación de los datos¶

Para este ejemplo, generaremos un conjunto de datos sintéticos que simulan una relación lineal entre una variable independiente (X) y una variable dependiente (y), añadiendo un poco de ruido para hacer el ejemplo más realista. Esto nos permite controlar las características de los datos y entender mejor cómo funciona el modelo.

In [9]:

import numpy as np

# Generar datos sintéticos
m =50 # Número de datos de la muestra
np.random.seed(0)  # Para reproducibilidad
X = 10 * np.random.rand(m, 1) # m puntos de datos entre 0 y 10
y = 4 + 3 * X + np.random.randn(m, 1) # Generamos los datos en base a la recta y = 4 + 3x añadiendo ruido, y = 4 + 3x + ruido

Paso 3: Dividisión los datos en conjuntos de entrenamiento y prueba¶

Es una práctica estándar en aprendizaje automático dividir los datos en dos conjuntos:

Conjunto de entrenamiento: para entrenar el modelo.
Conjunto de prueba: para evaluar su rendimiento en datos no vistos.

Tres divisiones comunes comunes son 70/30, 75/25 y 80/20. Utilizaremos la división de 80% para entrenamiento y 20% para prueba.

Esto ayuda a evitar el sobreajuste y a obtener una estimación más realista de la capacidad de generalización del modelo. Utilizaremos la función train_test_split de scikit-learn para realizar esta división de forma sencilla.

In [10]:

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

print(f"Tamaño del conjunto de entrenamiento: {X_train.shape[0]}")
print(f"Tamaño del conjunto de prueba: {X_test.shape[0]}")

Tamaño del conjunto de entrenamiento: 40
Tamaño del conjunto de prueba: 10

Paso 4: Entrenamiento del modelo¶

Aquí es donde utilizamos la clase LinearRegression de scikit-learn. Crearemos una instancia de este modelo y lo "entrenaremos" utilizando los datos del conjunto de entrenamiento (X_train y y_train). El método fit() se encargará de encontrar los mejores coeficientes para la línea de regresión que mejor se ajuste a estos datos.

In [11]:

# Crear una instancia del modelo de Regresión Lineal
model = LinearRegression()

# Entrenar el modelo con los datos de entrenamiento
model.fit(X_train, y_train)

print("Modelo entrenado exitosamente.")
print(f"Coeficiente (peso): {model.coef_[0][0]}")
print(f"Intercepto (sesgo): {model.intercept_[0]}")

Modelo entrenado exitosamente.
Coeficiente (peso): 2.9820321495223094
Intercepto (sesgo): 4.037097174962346

Paso 5: Evaluación del modelo¶

Una vez que el modelo ha sido entrenado, necesitamos evaluar como de bien se desempeña. Para la regresión, métricas comunes como el Error Cuadrático Medio (ECM) y el Coeficiente de Determinación (R²) nos dan una medida cuantitativa de la precisión de las predicciones del modelo en el conjunto de prueba. Un ECM más bajo y un R² más cercano a 1 indican un mejor ajuste.

In [12]:

# Realizar predicciones sobre el conjunto de prueba
y_pred = model.predict(X_test)

# Calcular el Error Cuadrático Medio (ECM)
mse = mean_squared_error(y_test, y_pred)

# Calcular el Coeficiente de Determinación (R²)
r2 = r2_score(y_test, y_pred)

print(f"Error Cuadrático Medio (ECM): {mse}")
print(f"Coeficiente de Determinación (R²): {r2}")

Error Cuadrático Medio (ECM): 0.8375952851062938
Coeficiente de Determinación (R²): 0.9756924413920042

Paso 6: Visualización de los resultados¶

La visualización es una herramienta poderosa para entender el ajuste del modelo. Representaremos los puntos de datos originales (entrenamiento y prueba) y la línea de regresión aprendida por el modelo. Esto nos permitirá ver visualmente como de bien la línea representa la relación entre X e y, y cómo se compara con los datos de prueba.

In [13]:

import matplotlib.pyplot as plt

# Visualizar los datos de entrenamiento y la línea de regresión
plt.scatter(X_train, y_train, color='blue', label='Datos de Entrenamiento')
plt.scatter(X_test, y_test, color='red', label='Datos de Prueba')
plt.plot(X, model.predict(X), color='green', label='Línea de Regresión')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Regresión Lineal con Scikit-learn')
plt.legend()
plt.show()

No description has been provided for this image

Paso 7: Uso del modelo para hacer predecciones¶

Finalmente, utilizamos el modelo entrenado para hacer predicciones sobre nuevos valores de la variable independiente (X) que el modelo no ha visto antes. Esto simula cómo se usaría el modelo en un escenario real para predecir resultados futuros.

In [14]:

# Usar el modelo para predecir con nuevos datos
X_new = np.array([[2.5],[15]]) # Un nuevo valor de X
y_new_pred = model.predict(X_new)

print(f"Predicción para X = {X_new[0][0]} es el valor {y_new_pred[0][0]}")
print(f"Predicción para X = {X_new[1][0]} es el valor {y_new_pred[1][0]}")
print("(el valor 15 no puede estar dentro de los datos de entrenamiento puesto que el rango máximo era 10)")

Predicción para X = 2.5 es el valor 11.492177548768119
Predicción para X = 15.0 es el valor 48.76757941779699
(el valor 15 no puede estar dentro de los datos de entrenamiento puesto que el rango máximo era 10)

Conclusión¶

En este cuaderno, hemos implementado un modelo de regresión lineal utilizando la biblioteca scikit-learn. A diferencia de la implementación manual, scikit-learn simplifica enormemente el proceso, proporcionando herramientas eficientes y optimizadas para:

División de datos: train_test_split facilita la separación de los datos en conjuntos de entrenamiento y prueba, lo cual es esencial para un buen entrenamiento y una evaluación realista del modelo.
Entrenamiento del modelo: LinearRegression abstrae los detalles matemáticos y computacionales del entrenamiento, permitiéndonos ajustar el modelo con una simple llamada a fit().
Evaluación del modelo: Métricas como mean_squared_error y r2_score nos dan una medida cuantitativa del rendimiento del modelo en datos no vistos.

La visualización de los resultados nos permite comprobar que la línea de regresión se ajusta razonablemente bien a los datos y tanto el valor del ECM como el R² confirman el buen ajuste de los datos.

En resumen, scikit-learn es una herramienta poderosa y fácil de usar para construir y evaluar modelos de aprendizaje automático, lo que acelera el desarrollo y nos permite centrarnos en la interpretación de los resultados y la mejora del modelo.