Regresión lineal con sklearn: guía completa con ejemplos

La regresión lineal es una técnica fundamental en estadística y aprendizaje automático que modela la relación entre variables. En pocas palabras, nos permite predecir un resultado a partir de uno o varios factores que lo influyen. Se aplica ampliamente en la valoración inmobiliaria, la previsión de ventas, la evaluación de riesgos y muchos otros ámbitos.

En este tutorial, exploraremos la regresión lineal en scikit-learn: cómo funciona, por qué es útil y cómo implementarla con esta biblioteca. Al final, serás capaz de crear y evaluar un modelo de regresión lineal para realizar predicciones basadas en datos.

Diagrama de dispersión del precio de la vivienda frente al número de habitaciones

Regresión lineal y aprendizaje automático

Más allá de su utilidad inmediata para estimar precios de vivienda, la regresión lineal desempeña un papel importante en el aprendizaje automático.

• Es un modelo base para comprender técnicas más avanzadas como la regresión logística, las redes neuronales y las máquinas de vectores de soporte.
• Se entrena muy rápido, ideal para prototipado ágil.
• Sirve como línea base de comparación. Si los modelos avanzados no la superan claramente, quizá su complejidad extra no esté justificada.
• A diferencia de otras técnicas (como el deep learning), es fácilmente interpretable.
• Puede ayudar en la selección de características, identificando los mejores predictores.

Pese a su sencillez, la regresión lineal sigue siendo una herramienta imprescindible por su eficiencia, interpretabilidad y versatilidad.

Regresión lineal y la biblioteca scikit-learn

La biblioteca scikit-learn facilita enormemente implementar regresión lineal. Tiene muchas ventajas.

• Interfaz coherente: el código para distintos algoritmos de ML es muy similar.
• Código sencillo: las matemáticas y detalles complejos quedan abstraídos. Por ejemplo, para ajustar un modelo basta con model.fit(X_train, y_train).
• Acceso sencillo a los coeficientes del modelo.
• Incluye métricas integradas para evaluar el rendimiento.
• Permite integrar fácilmente la regresión lineal (o cualquier otro algoritmo) con pasos de preprocesado, como escalado y selección de características, mediante Pipeline.

Si eres nuevo en scikit-learn, puedes echar un vistazo a nuestro curso Machine Learning with scikit-learn para una introducción práctica a esta biblioteca de Python. 

Entender la regresión lineal

Como hemos visto, en la regresión lineal simple los datos se modelan con una "línea de mejor ajuste". La fórmula de esa línea es: 

donde m es la pendiente y b la intersección con el eje.

La "regresión lineal múltiple" generaliza el caso de un predictor a varios (número de habitaciones, cercanía al mar, renta mediana del barrio). La fórmula se generaliza a: 

donde cada x_i es una variable independiente y el correspondiente b_i su coeficiente. En tres dimensiones, la línea se convierte en un plano. En dimensiones superiores, en un "hiperplano".

¿Cómo interpretamos los coeficientes y la intersección? La intersección es el valor previsto de y cuando todas las variables independientes valen 0; dicho de otro modo, el valor base de la variable dependiente sin contribución de los predictores. Cada coeficiente b_i representa el cambio en y ante un cambio de una unidad en x_i, manteniendo constantes el resto de variables.

Preparar el entorno

Instalar scikit-learn es sencillo. Usa el comando pip install scikit-learn. Si quieres instalar una versión concreta, por ejemplo la 1.2.2, añade la versión: pip install scikit-learn==1.2.2. Si usas Anaconda, scikit-learn debería venir instalado. Si por algún motivo necesitas instalarlo con Anaconda, utiliza conda install scikit-learn.

Hay varias bibliotecas necesarias o recomendadas al usar scikit-learn. La biblioteca numpy es necesaria para almacenar características y etiquetas. Se recomienda pandas para cargar, preprocesar y explorar conjuntos de datos. 

Si usas scikit-learn, lo más probable es que ya utilices pandas para la preparación de datos. Para graficar resultados, seguramente uses matplotlib o seaborn o ambos. Cualquiera de estas bibliotecas puede instalarse con pip, como en el ejemplo anterior. Incluso puedes instalar varias a la vez con un único comando:

pip install scikit-learn numpy pandas matplotlib seaborn.

Implementar regresión lineal en sklearn

Antes de cargar el conjunto de datos, importemos a los sospechosos habituales.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Cargar el conjunto de datos

Usemos el conocido conjunto de datos de viviendas de California.

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

Preparar los datos

Dividamos los datos en entrenamiento y prueba. Importamos el método train_test_split() de sklearn.model_selection, lo invocamos indicando el porcentaje para test y un random_state. Además, usaremos regresión lineal simple con la característica correspondiente al número medio de habitaciones.

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Ahora que hemos dividido en entrenamiento y prueba, vamos a estandarizar las características. Así nos aseguramos de que todas las variables estén en la misma escala, lo que puede mejorar el rendimiento y la estabilidad numérica del modelo.

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

En este código, StandardScaler es una herramienta de preprocesado que elimina la media y escala las características a varianza unitaria. Esto evita que ciertas variables dominen el modelo por diferencias de escala.

El escalador se ajusta sobre los datos de entrenamiento con fit_transform(). Los datos de prueba se transforman por separado con transform() para usar los mismos factores de escalado y evitar fuga de información.

Entrenar el modelo de regresión lineal

Para crear un modelo de regresión lineal, importa LinearRegression() de sklearn.linear_model. Instáncialo y asígnalo a una variable.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Ajustar el modelo con los datos de entrenamiento es directo.

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

Hacer predicciones

Con el modelo entrenado, hacemos predicciones sobre el conjunto de prueba.

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

Evaluar el rendimiento del modelo

Una vez realizadas las predicciones sobre el conjunto de prueba, necesitamos saber qué tal se ajustan a la realidad. Hay varias métricas para evaluar un algoritmo de regresión. Algunas de las más comunes son el coeficiente de determinación (R²), el error cuadrático medio (MSE) y la raíz del error cuadrático medio (RMSE).

El coeficiente de determinación, R², mide cuánto explica el modelo la variabilidad de la variable objetivo. Es decir, cuantifica qué parte de la variabilidad del objetivo explican los predictores: la bondad de ajuste.

Para entenderlo mejor, veamos la fórmula:

donde yactual son los valores reales de la variable objetivo, ypredicted los valores predichos por el modelo, y ȳ la media de los valores reales. La fórmula nos indica cuánta varianza del objetivo explica el modelo. El denominador representa la varianza total y el numerador la varianza no explicada tras aplicar la regresión. El cociente es, por tanto, el porcentaje de varianza explicada por el modelo.

¿Cómo interpretamos R²?

• R² = 1: el modelo explica perfectamente toda la varianza. 
• R² = 0: el modelo no explica nada; predecir la media sería igual de bueno. 
• R² < 0: peor que usar la media; indica mal ajuste.

Aspectos clave a tener en cuenta.

• Un R² más alto no siempre es mejor. Puede indicar sobreajuste, especialmente con modelos complejos. 
• Añadir más variables puede inflar artificialmente R², así que un valor mayor no implica necesariamente mejor modelo.
• En regresión múltiple, usa R² ajustado, que tiene en cuenta el número de predictores y evita mejoras engañosas por variables innecesarias.

Evaluar el rendimiento con el coeficiente de determinación es muy sencillo con scikit-learn.

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

Otras métricas muy usadas son el error cuadrático medio (MSE) y su raíz (RMSE). Miden cuánto se desvían las predicciones de los valores reales.

El MSE calcula la diferencia cuadrática media entre valores reales y predichos: 

para un total de n observaciones. Como los errores se elevan al cuadrado antes de promediar, los errores grandes se penalizan más que los pequeños; por ello el MSE es sensible a valores atípicos. Un MSE más bajo indica mejor ajuste.

Para abordar esto, se usa el RMSE, que no es más que la raíz cuadrada del MSE. Al estar en las mismas unidades que la variable objetivo, es más interpretable como desviación media de las predicciones.

Calcular MSE y RMSE también es muy sencillo con scikit-learn.

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

Trabajar con regresión lineal múltiple en scikit-learn

Volvamos a ejecutar el modelo usando todas las características disponibles, no solo el número medio de habitaciones. ¿Esperas mejores o peores resultados?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


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


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

Vemos que los resultados son bastante mejores que usando una sola característica. Ahora bien, ¿necesitamos todas? ¿Hay unas más relevantes que otras? Elegir las características más relevantes del conjunto de datos se conoce como selección de características.

La selección de características es importante por varias razones.

• Reduce el sobreajuste. Menos variables implica menos complejidad y menor riesgo de sobreajuste.
• Mejora la precisión. Al eliminar variables irrelevantes o redundantes, el modelo se centra en patrones útiles.
• Aumenta la interpretabilidad. Facilita entender el modelo al resaltar los factores más importantes.
• Acelera el entrenamiento. Menos variables reducen el tiempo de cómputo y el uso de memoria.

Cuando varias características están muy correlacionadas, son redundantes: aportan básicamente la misma información. A esto se le llama multicolinealidad. Aunque no siempre perjudica la precisión predictiva, complica la selección e interpretación, especialmente en modelos lineales.

El factor de inflación de la varianza (VIF) es una métrica para detectar multicolinealidad entre predictores. Para cada predictor, el VIF se calcula como: 

donde R_i² es el R² obtenido al ajustar el predictor X_i frente al resto de predictores del modelo. Un VIF alto indica que el predictor está muy correlacionado con otras variables.

• VIF = 1: sin multicolinealidad (escenario ideal).
• VIF < 5: multicolinealidad baja o moderada (generalmente aceptable).
• VIF > 5: multicolinealidad alta (valora eliminar o combinar variables correlacionadas).
• VIF > 10: multicolinealidad severa (indica fuerte redundancia).

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

Eliminemos AveBedrms del modelo.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

Los resultados mejoran (ligeramente).

Extraer información del modelo

Construir un modelo de regresión es solo el primer paso; entender sus salidas es igual de importante. Analizando los coeficientes del modelo podemos ver qué características tienen más impacto en las predicciones.

Entender los coeficientes de la regresión

Una vez entrenado un modelo de regresión lineal, puedes acceder a los coeficientes con model.coef_. La intersección se obtiene con model.intercept_.

Una vez entrenado con LinearRegression(), los coeficientes se consultan con model.coef_ y la intersección con model.intercept_.

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

Resumir los resultados del modelo

Como Scikit-Learn no ofrece un método summary() como Statsmodels, podemos extraer y visualizar manualmente la importancia de cada característica usando los coeficientes. Las variables con coeficientes absolutos mayores tienen más impacto en el objetivo. Considera el siguiente código.

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

Gráfico de importancia de características según los coeficientes

Ahora, visualicemos los residuos y el ajuste de la regresión.

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

Gráficas para visualizar residuos y ajuste de la regresión

La distribución de residuos (gráfico izquierdo) debería estar centrada en cero, lo que indica errores distribuidos aleatoriamente. Si los residuos siguen una distribución normal, el ajuste es bueno; si hay asimetrías o tendencias, podría haber errores sistemáticos. El gráfico de ajuste (derecha) compara valores reales y predichos; la línea roja discontinua representa el ajuste perfecto. Si los puntos siguen de cerca la línea, las predicciones son precisas; si aparece un patrón (p. ej., una curva), quizá la relación no sea realmente lineal. 

Estas visualizaciones ayudan a diagnosticar sobreajuste o infraajuste, revelan patrones en los residuos que sugieren relaciones omitidas y ofrecen una evaluación clara de la eficacia del modelo.

Aplicaciones en el mundo real

La regresión lineal se usa ampliamente en distintos sectores para predecir y tomar decisiones. En inmobiliaria, estima precios de vivienda en función de factores como tamaño y ubicación. 

Ventas y marketing la emplean para prever demanda y optimizar presupuestos; en salud se aplica a evaluar riesgos de enfermedad. En finanzas ayuda a predecir precios de acciones y a la calificación crediticia; en manufactura, a control de calidad y predicción de fallos. 

Cuándo usar regresión lineal

• Las características y la variable objetivo mantienen una relación lineal.
• La interpretabilidad y la sencillez pesan más que el modelado complejo.
• Los datos requieren poco ingenierizado de variables.

Cuándo no usar regresión lineal

• La relación entre el objetivo y las características es compleja y no lineal.
• Los datos están muy correlacionados.
• El conjunto contiene valores atípicos que no se pueden eliminar. En ese caso, puede que necesites aplicar transformaciones o usar estrategias para mitigar su impacto.

Conclusión

La regresión lineal sigue siendo una de las técnicas más básicas y a la vez más utilizadas en machine learning y modelado estadístico. Pese a su sencillez, es una herramienta potente para entender relaciones entre variables y realizar predicciones en multitud de casos de uso.

Qué debes recordar de este tutorial:

• Aplicaciones versátiles. La regresión lineal aporta información valiosa en múltiples sectores y tipos de problemas.
• Interpretable. A diferencia de los modelos caja negra, ofrece interpretaciones claras basadas en coeficientes, fáciles de explicar.
• Selección de características. Elegir bien las variables y abordar la multicolinealidad ayuda a que los modelos sean precisos, estables y fiables. 

Si quieres seguir aprendiendo sobre interpolación de cadenas en Python, consulta los recursos de DataCamp.

• Simple Linear Regression: Everything You Need to Know - Tutorial
• How to Do Linear Regression in R - Tutorial
• Linear Regression in Excel: A Comprehensive Guide For Beginners - Tutorial
• Introduction to Regression in R - Course
• Supervised Learning with scikit-learn - Course
• Scikit-Learn Cheat Sheet: Python Machine Learning - Cheat Sheet
• Understanding Logistic Regression in Python - Tutorial