GUÍA COMPLETA PARA MODELOS DE REGRESIÓN EN PYTHON

Introducción a los Modelos de Regresión en Python

Los modelos de regresión son herramientas esenciales en el aprendizaje automático supervisado, utilizados para predecir valores numéricos o probabilidades en función de variables independientes. En este tutorial, exploraremos cómo construir y entrenar modelos de regresión lineal y logística en Python, utilizando bibliotecas como scikit-learn, NumPy y pandas. Este contenido está diseñado para programadores y entusiastas de la tecnología que deseen implementar soluciones predictivas con código claro y ejemplos prácticos. Cubriremos desde los fundamentos teóricos hasta la implementación, evaluación y visualización de resultados, asegurando una comprensión integral de ambos modelos.

La regresión lineal es ideal para predecir valores continuos, como el precio de una vivienda o las ventas de una empresa, mientras que la regresión logística se utiliza para problemas de clasificación binaria, como determinar si un correo es spam o no. A lo largo de este artículo, proporcionaremos ejemplos de código en Python para cada etapa, desde la preparación de datos hasta la evaluación de modelos, con un enfoque en aplicaciones prácticas para el análisis de datos y la programación.

Regresión Lineal: Fundamentos y Teoría

La regresión lineal modela la relación entre una variable dependiente (Y) y una o más variables independientes (X) mediante una ecuación lineal. En su forma más simple, con una sola variable predictora, la ecuación es Y = β₀ + β₁X + ε, donde β₀ es el intercepto, β₁ es la pendiente y ε es el término de error. El objetivo es encontrar los valores de β₀ y β₁ que minimicen la suma de los errores cuadrados entre los valores predichos y los reales, un método conocido como mínimos cuadrados ordinarios.

En la regresión lineal múltiple, se incluyen múltiples variables predictoras, y la ecuación se expande a Y = β₀ + β₁X₁ + β₂X₂ + … + βₙXₙ + ε. Este enfoque es útil para problemas complejos donde varias características influyen en el resultado, como predecir el precio de una casa en función de su tamaño, ubicación y número de habitaciones.

Para ilustrar, consideremos un conjunto de datos simple con una variable predictora. El siguiente código genera datos sintéticos y ajusta un modelo de regresión lineal usando scikit-learn:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Generar datos sintéticos
np.random.seed(42)
X = np.random.rand(100, 1) * 10
y = 3 * X + 5 + np.random.randn(100, 1) * 2

# Crear y entrenar el modelo
model = LinearRegression()
model.fit(X, y)

# Predecir valores
y_pred = model.predict(X)

# Visualizar resultados
plt.scatter(X, y, color='blue', label='Datos reales')
plt.plot(X, y_pred, color='red', label='Línea de regresión')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()

En este ejemplo, generamos datos con una relación lineal aproximada y ajustamos un modelo que traza una línea recta para predecir y en función de X. La visualización muestra cómo la línea de regresión se ajusta a los puntos de datos.

Preparación de Datos para Regresión Lineal

Antes de entrenar un modelo, es crucial preparar los datos. Esto incluye manejar valores nulos, escalar características y dividir los datos en conjuntos de entrenamiento y prueba. Usaremos un conjunto de datos realista, como el dataset de precios de viviendas de California, disponible en scikit-learn.

El siguiente código carga el dataset, selecciona una característica (ingreso medio) y prepara los datos:

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Cargar dataset
data = fetch_california_housing()
X = data.data[:, [0]]  # Seleccionar ingreso medio
y = data.target

# Dividir datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Escalar características
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

La estandarización asegura que las características tengan una media de 0 y una desviación estándar de 1, lo que mejora el rendimiento del modelo. La división en conjuntos de entrenamiento (80%) y prueba (20%) permite evaluar el modelo en datos no vistos.

Entrenamiento y Evaluación de la Regresión Lineal

Con los datos preparados, podemos entrenar el modelo y evaluar su rendimiento usando métricas como el error cuadrático medio (MSE) y el coeficiente de determinación (R²). El MSE mide el promedio de los errores al cuadrado, mientras que R² indica la proporción de la varianza explicada por el modelo.

Aquí está el código para entrenar y evaluar el modelo:

from sklearn.metrics import mean_squared_error, r2_score

# Entrenar modelo
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# Predecir
y_pred = model.predict(X_test_scaled)

# Evaluar
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"Error cuadrático medio: {mse:.2f}")
print(f"Coeficiente de determinación (R²): {r2:.2f}")

Salida esperada:

Error cuadrático medio: 0.71
Coeficiente de determinación (R²): 0.47

Un R² de 0.47 indica que el modelo explica aproximadamente el 47% de la varianza en los precios de las viviendas, lo cual es moderado, ya que solo usamos una característica. Agregar más variables predictoras podría mejorar el rendimiento.

Regresión Lineal Múltiple

Para mejorar las predicciones, podemos usar todas las características del dataset. La regresión lineal múltiple considera múltiples variables predictoras, lo que permite capturar relaciones más complejas. Modifiquemos el código anterior para incluir todas las características:

# Cargar y preparar datos
X = data.data  # Todas las características
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Entrenar modelo
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# Predecir y evaluar
y_pred = model.predict(X_test_scaled)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"Error cuadrático medio: {mse:.2f}")
print(f"Coeficiente de determinación (R²): {r2:.2f}")

Salida esperada:

Error cuadrático medio: 0.56
Coeficiente de determinación (R²): 0.58

El R² ha mejorado a 0.58, lo que indica que el modelo explica más varianza al incluir todas las características. Sin embargo, debemos verificar supuestos como la linealidad y la ausencia de multicolinealidad entre variables predictoras para garantizar la validez del modelo.

Regresión Logística: Fundamentos y Teoría

La regresión logística se utiliza para problemas de clasificación binaria, donde el objetivo es predecir la probabilidad de que una observación pertenezca a una de dos clases (por ejemplo, 0 o 1). A diferencia de la regresión lineal, que predice valores continuos, la regresión logística aplica la función sigmoide para transformar una combinación lineal de características en una probabilidad entre 0 y 1.

La ecuación de la regresión logística es P(Y=1) = 1 / (1 + e^-(β₀ + β₁X₁ + … + βₙXₙ)), donde P(Y=1) es la probabilidad de la clase positiva. El modelo ajusta los coeficientes β para maximizar la verosimilitud de los datos observados.

Para ilustrar, consideremos un ejemplo con el dataset de cáncer de mama de scikit-learn, que clasifica tumores como malignos o benignos:

from sklearn.datasets import load_breast_cancer

# Cargar dataset
data = load_breast_cancer()
X = data.data
y = data.target

# Dividir y escalar datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

Entrenamiento y Evaluación de la Regresión Logística

Entrenaremos un modelo de regresión logística y evaluaremos su rendimiento usando métricas como la exactitud, la precisión, el recall y el F1-score. La exactitud mide la proporción de predicciones correctas, mientras que las otras métricas evalúan el equilibrio entre falsos positivos y falsos negativos.

Código para entrenar y evaluar:

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# Entrenar modelo
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)

# Predecir
y_pred = model.predict(X_test_scaled)

# Evaluar
accuracy = accuracy_score(y_test, y_pred)
print(f"Exactitud: {accuracy:.2f}")
print("\nReporte de clasificación:")
print(classification_report(y_test, y_pred))

Salida esperada:

Exactitud: 0.96

Reporte de clasificación:
              precision    recall  f1-score   support
           0       0.98      0.91      0.94        43
           1       0.95      0.99      0.97        71
    accuracy                           0.96       114
   macro avg       0.97      0.95      0.96       114
weighted avg       0.96      0.96      0.96       114

Una exactitud de 0.96 indica que el modelo clasifica correctamente el 96% de las observaciones. El reporte de clasificación muestra un buen equilibrio entre precisión y recall, especialmente para la clase 1 (tumores benignos).

Visualización de Resultados

Visualizar los resultados ayuda a interpretar el modelo. Para la regresión lineal, podemos graficar la línea de regresión o los valores predichos frente a los reales. Para la regresión logística, una matriz de confusión es útil para visualizar los aciertos y errores de clasificación.

Código para una matriz de confusión en regresión logística:

from sklearn.metrics import confusion_matrix
import seaborn as sns

# Calcular matriz de confusión
cm = confusion_matrix(y_test, y_pred)

# Visualizar
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicho')
plt.ylabel('Real')
plt.title('Matriz de Confusión')
plt.show()

Este gráfico muestra los verdaderos positivos, verdaderos negativos, falsos positivos y falsos negativos, proporcionando una visión clara del rendimiento del modelo.

Para la regresión lineal, podemos graficar los valores predichos frente a los reales:

# Usando el modelo de regresión lineal múltiple anterior
plt.scatter(y_test, y_pred, color='blue')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
plt.xlabel('Valores reales')
plt.ylabel('Valores predichos')
plt.title('Predicciones vs. Reales')
plt.show()

Este gráfico ayuda a identificar si las predicciones están alineadas con los valores reales, con puntos cercanos a la línea diagonal indicando un buen ajuste.

Optimización de Modelos

Para mejorar los modelos, podemos ajustar hiperparámetros o realizar selección de características. En la regresión logística, el parámetro C controla la regularización (menor C implica más regularización). Probemos diferentes valores de C:

from sklearn.model_selection import GridSearchCV

# Definir parámetros
param_grid = {'C': [0.01, 0.1, 1, 10, 100]}

# Búsqueda de cuadrícula
grid = GridSearchCV(LogisticRegression(random_state=42), param_grid, cv=5)
grid.fit(X_train_scaled, y_train)

# Mejor modelo
print(f"Mejor valor de C: {grid.best_params_['C']}")
print(f"Mejor exactitud: {grid.best_score_:.2f}")

Salida esperada:

Mejor valor de C: 1
Mejor exactitud: 0.97

La búsqueda de cuadrícula identifica el valor óptimo de C, mejorando la generalización del modelo. Para la regresión lineal, técnicas como Ridge o Lasso pueden reducir el sobreajuste al penalizar coeficientes grandes.

Aplicaciones Prácticas

Los modelos de regresión tienen aplicaciones en diversos campos. En finanzas, la regresión lineal puede predecir precios de acciones basándose en indicadores económicos. En marketing, la regresión logística puede identificar clientes propensos a comprar un producto. En salud, como en nuestro ejemplo, clasifica diagnósticos médicos.

Un ejemplo práctico adicional es predecir el abandono de clientes (churn). Supongamos un dataset con características como antigüedad del cliente, frecuencia de uso y quejas registradas. Podemos entrenar un modelo de regresión logística para predecir si un cliente abandonará:

import pandas as pd

# Dataset ficticio
data = pd.DataFrame({
    'antiguedad': [12, 24, 6, 36, 18],
    'uso_mensual': [10, 5, 15, 8, 12],
    'quejas': [0, 2, 1, 0, 3],
    'abandonar': [0, 1, 0, 0, 1]
})

X = data.drop('abandonar', axis=1)
y = data['abandonar']

# Dividir y escalar
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Entrenar y predecir
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)
y_pred = model.predict(X_test_scaled)

print(f"Predicciones: {y_pred}")

Este código muestra cómo aplicar la regresión logística a un problema empresarial, adaptando el modelo a datos específicos.

Conclusiones

Los modelos de regresión lineal y logística son pilares del aprendizaje automático supervisado, ofreciendo soluciones robustas para predicción y clasificación. La regresión lineal destaca en problemas con variables continuas, mientras que la regresión logística es ideal para clasificación binaria. Usando bibliotecas como scikit-learn, Python facilita la implementación de estos modelos, desde la preparación de datos hasta la evaluación y optimización. Este tutorial ha proporcionado una guía práctica para construir, entrenar y evaluar ambos modelos, con ejemplos de código que puedes adaptar a tus proyectos. Al dominar estas técnicas, estarás equipado para abordar problemas de análisis de datos en diversos dominios, desde finanzas hasta salud, impulsando tus habilidades en programación y ciencia de datos.