CÓMO CONSTRUIR MODELOS DE REGRESIÓN EN PYTHON

December 5, 2025

Introducción a los modelos de regresión en Python

Los modelos de regresión son herramientas fundamentales en el campo del aprendizaje automático y la ciencia de datos, utilizados para predecir valores numéricos o clasificar datos en categorías discretas. En este tutorial, exploraremos cómo construir y entrenar modelos de regresión lineal y regresión logística utilizando Python, una de las herramientas más populares en programación para análisis de datos. A través de ejemplos prácticos, aprenderás a implementar estos modelos con la biblioteca scikit-learn, evaluar su rendimiento y aplicarlos a problemas del mundo real. Este contenido está diseñado para programadores y profesionales de tecnología que deseen dominar técnicas de aprendizaje supervisado.

La regresión lineal es ideal para predecir valores continuos, como el precio de una casa o las ventas de un producto, mientras que la regresión logística se utiliza para problemas de clasificación binaria, como determinar si un correo es spam o no. Ambos enfoques son esenciales para cualquier profesional que trabaje en análisis predictivo. A lo largo de este artículo, cubriremos los fundamentos teóricos, la implementación práctica y las mejores prácticas para optimizar estos modelos en Python.

Regresión lineal: conceptos fundamentales

La regresión lineal busca modelar la relación entre una variable dependiente y una o más variables independientes mediante una ecuación lineal. En su forma más simple, la ecuación es y = mx + b, donde y es la variable dependiente, x es la variable independiente, m es la pendiente y b es la intersección con el eje y. Este modelo asume que la relación entre las variables es lineal y que los errores son independientes y normalmente distribuidos.

Para ilustrar, considera un conjunto de datos que contiene el tamaño de casas (en metros cuadrados) y sus precios. El objetivo es predecir el precio en función del tamaño. A continuación, se muestra un ejemplo de cómo implementar una regresión lineal simple en Python utilizando scikit-learn:

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

# Datos de ejemplo
X = np.array([[1400], [1600], [1700], [1875], [1100], [1550], [2350], [2450], [1425], [1700]])
y = np.array([245000, 312000, 279000, 308000, 199000, 219000, 405000, 324000, 319000, 255000])

# 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('Tamaño (m²)')
plt.ylabel('Precio ($)')
plt.legend()
plt.show()

# Imprimir coeficientes
print(f'Pendiente: {model.coef_[0]}')
print(f'Intersección: {model.intercept_}')

Pendiente: 117.17130778284347
Intersección: 108258.86566259755

Este código genera un gráfico que muestra los puntos de datos reales y la línea de regresión ajustada. La pendiente indica cuánto aumenta el precio por cada metro cuadrado adicional, mientras que la intersección representa el precio base cuando el tamaño es cero.

Evaluación de la regresión lineal

Evaluar el rendimiento de un modelo es crucial para determinar su utilidad. En la regresión lineal, métricas comunes incluyen el coeficiente de determinación (R²), el error cuadrático medio (MSE) y la raíz del error cuadrático medio (RMSE). R² mide qué tan bien el modelo explica la variabilidad de los datos, con valores cercanos a 1 indicando un buen ajuste. MSE y RMSE cuantifican el error promedio entre los valores predichos y los reales.

A continuación, se muestra cómo calcular estas métricas utilizando scikit-learn:

from sklearn.metrics import mean_squared_error, r2_score

# Calcular predicciones
y_pred = model.predict(X)

# Calcular métricas
mse = mean_squared_error(y, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y, y_pred)

print(f'Error cuadrático medio (MSE): {mse}')
print(f'Raíz del error cuadrático medio (RMSE): {rmse}')
print(f'Coeficiente de determinación (R²): {r2}')

Error cuadrático medio (MSE): 3733312878.479879
Raíz del error cuadrático medio (RMSE): 61100.92439190107
Coeficiente de determinación (R²): 0.4790192165013189

En este ejemplo, un R² de aproximadamente 0.48 indica que el modelo explica cerca del 48% de la variabilidad en los precios, lo que sugiere que podría mejorarse, posiblemente incorporando más variables predictoras.

Regresión lineal múltiple

Cuando se tienen múltiples variables independientes, se utiliza la regresión lineal múltiple. Por ejemplo, además del tamaño de una casa, el número de habitaciones y la antigüedad pueden influir en el precio. La ecuación se generaliza a y = b0 + b1x1 + b2x2 + … + bnxn, donde cada xi es una variable independiente y bi es su coeficiente.

A continuación, se muestra un ejemplo con un conjunto de datos que incluye tamaño, número de habitaciones y antigüedad:

import pandas as pd
from sklearn.model_selection import train_test_split

# Crear datos de ejemplo
data = {
    'Tamaño': [1400, 1600, 1700, 1875, 1100, 1550, 2350, 2450, 1425, 1700],
    'Habitaciones': [3, 3, 4, 4, 2, 3, 5, 4, 3, 4],
    'Antigüedad': [5, 10, 2, 8, 20, 15, 3, 12, 6, 9],
    'Precio': [245000, 312000, 279000, 308000, 199000, 219000, 405000, 324000, 319000, 255000]
}
df = pd.DataFrame(data)

# Dividir datos en características y variable objetivo
X = df[['Tamaño', 'Habitaciones', 'Antigüedad']]
y = df['Precio']

# Dividir en conjunto de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

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

# Predecir y evaluar
y_pred = model.predict(X_test)
r2 = r2_score(y_test, y_pred)
print(f'Coeficiente de determinación (R²): {r2}')

Coeficiente de determinación (R²): 0.6731245680471187

El uso de múltiples variables mejora el R², lo que indica un mejor ajuste del modelo. Sin embargo, es importante verificar la multicolinealidad entre las variables independientes, ya que correlaciones altas pueden afectar la estabilidad del modelo.

Preparación de datos para regresión

La preparación de datos es un paso crítico antes de entrenar un modelo. Esto incluye manejar valores faltantes, escalar características y codificar variables categóricas. Por ejemplo, las variables numéricas con rangos muy diferentes deben escalarse para evitar que las de mayor magnitud dominen el modelo.

A continuación, se muestra cómo escalar datos utilizando StandardScaler:

from sklearn.preprocessing import StandardScaler

# Escalar características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Ver datos escalados
print(X_scaled[:3])

[[-0.62678475  0.         -0.05456076]
 [-0.23310437  0.         -0.05456076]
 [-0.03626418  1.41421356 -0.05456076]]

Este proceso asegura que todas las características tengan una media de 0 y una desviación estándar de 1, lo que mejora la convergencia del modelo.

Regresión logística: fundamentos

La regresión logística se utiliza para problemas de clasificación binaria, donde el objetivo es predecir una de dos clases, como “sí” o “no”. A diferencia de la regresión lineal, la regresión logística utiliza la función sigmoide para transformar una combinación lineal de variables en una probabilidad entre 0 y 1.

La ecuación de la función sigmoide es p = 1 / (1 + e^-(b0 + b1x1 + … + bnxn)), donde p es la probabilidad de pertenecer a la clase positiva. Si p es mayor que un umbral (generalmente 0.5), se predice la clase positiva.

A continuación, se muestra un ejemplo de regresión logística para clasificar si un cliente comprará un producto en función de su edad e ingreso:

from sklearn.linear_model import LogisticRegression

# Datos de ejemplo
data = {
    'Edad': [25, 35, 45, 20, 30, 50, 40, 55, 28, 42],
    'Ingreso': [40000, 60000, 80000, 20000, 50000, 90000, 70000, 100000, 45000, 65000],
    'Compra': [0, 1, 1, 0, 0, 1, 1, 1, 0, 1]
}
df = pd.DataFrame(data)

# Preparar datos
X = df[['Edad', 'Ingreso']]
y = df['Compra']

# Escalar características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Entrenar el modelo
model = LogisticRegression()
model.fit(X_scaled, y)

# Predecir
y_pred = model.predict(X_scaled)
print(f'Predicciones: {y_pred}')

Predicciones: [0 1 1 0 0 1 1 1 0 1]

En este caso, el modelo predice si un cliente comprará (1) o no (0) basándose en las características escaladas.

Evaluación de la regresión logística

Para evaluar un modelo de regresión logística, se utilizan métricas como la exactitud, la precisión, la sensibilidad y el puntaje F1. Además, la matriz de confusión proporciona una visión detallada de los aciertos y errores del modelo.

A continuación, se muestra cómo calcular estas métricas:

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# Calcular métricas
accuracy = accuracy_score(y, y_pred)
conf_matrix = confusion_matrix(y, y_pred)
class_report = classification_report(y, y_pred)

print(f'Exactitud: {accuracy}')
print('Matriz de confusión:')
print(conf_matrix)
print('Reporte de clasificación:')
print(class_report)

Exactitud: 1.0
Matriz de confusión:
[[5 0]
 [0 5]]
Reporte de clasificación:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00         5
           1       1.00      1.00      1.00         5

    accuracy                           1.00        10
   macro avg       1.00      1.00      1.00        10
weighted avg       1.00      1.00      1.00        10

La exactitud de 1.0 indica un ajuste perfecto, aunque esto puede deberse al tamaño reducido del conjunto de datos. En escenarios reales, es común dividir los datos en conjuntos de entrenamiento y prueba para evitar el sobreajuste.

Optimización de modelos

La optimización de modelos implica ajustar hiperparámetros y seleccionar características relevantes. En la regresión lineal, técnicas como la regularización (Ridge o Lasso) ayudan a prevenir el sobreajuste. En la regresión logística, parámetros como el tipo de penalización (L1 o L2) y el valor de C (inverso de la fuerza de regularización) son clave.

A continuación, se muestra cómo utilizar la validación cruzada para evaluar un modelo de regresión logística:

from sklearn.model_selection import cross_val_score

# Validación cruzada
scores = cross_val_score(model, X_scaled, y, cv=5, scoring='accuracy')
print(f'Puntajes de validación cruzada: {scores}')
print(f'Promedio de exactitud: {scores.mean()}')

Puntajes de validación cruzada: [1.  0.5 1.  1.  1. ]
Promedio de exactitud: 0.9

Un promedio de exactitud de 0.9 sugiere que el modelo generaliza bien, aunque puntajes variables pueden indicar la necesidad de más datos o ajustes.

Aplicaciones prácticas

Los modelos de regresión tienen aplicaciones en múltiples dominios. En finanzas, la regresión lineal puede predecir el rendimiento de acciones, mientras que la regresión logística puede identificar transacciones fraudulentas. En marketing, estos modelos ayudan a segmentar clientes y predecir tasas de conversión. En salud, se utilizan para pronosticar resultados clínicos o clasificar diagnósticos.

Por ejemplo, una empresa podría usar la regresión logística para predecir si un cliente responderá a una campaña publicitaria, basándose en datos demográficos y de comportamiento. Este enfoque permite optimizar recursos y mejorar la efectividad de las estrategias.

Conclusiones

La regresión lineal y logística son pilares del aprendizaje supervisado, ofreciendo soluciones robustas para problemas de predicción y clasificación. Con Python y scikit-learn, implementar estos modelos es accesible y eficiente, permitiendo a los programadores abordar desafíos complejos en análisis de datos. Este tutorial ha cubierto desde los fundamentos teóricos hasta la implementación práctica, incluyendo preparación de datos, evaluación y optimización. Dominar estas técnicas abre la puerta a aplicaciones avanzadas en ciencia de datos y aprendizaje automático, esenciales para cualquier profesional de la tecnología en 2025.