👋 Sobre el autor

Wilder Ramírez Delgado es Científico de Datos, Arquitecto de IA, Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), consultor y docente universitario, trabaja en la intersección entre Data Science, Inteligencia Artificial, Big Data e IoT, transformando problemas reales en soluciones aplicadas.

De la teoría a la práctica, un problema a la vez.

¿Qué es la regresión lineal y qué problema resuelve?

Este es el primer notebook del Módulo 1, y vale la pena tomárselo con calma: la regresión lineal es la base sobre la que se construye prácticamente todo lo demás en este curso — regularización, modelos lineales generalizados, suavizado, incluso partes de los módulos de datos dependientes. Si entiendes bien esta pieza, todo lo que viene después te va a resultar mucho más natural.

En el fondo, la pregunta que resuelve la regresión es muy simple: ¿puedes predecir un valor numérico a partir de otras variables que sí conoces?

Piensa en ejemplos cotidianos:

• Predecir el precio de una casa a partir de su tamaño, su ubicación y su antigüedad.
• Predecir las ventas del próximo mes a partir de la inversión en publicidad.
• Predecir cómo va a evolucionar una enfermedad en un paciente a partir de variables clínicas como su edad, su presión arterial o su índice de masa corporal (IMC).

En los tres casos tienes una variable que te interesa predecir (el objetivo o variable de respuesta, ) y una o más variables que usas para predecirla (las variables predictoras o features, ). La regresión lineal asume algo concreto: que la relación entre esas variables predictoras y el objetivo se puede aproximar razonablemente bien con una línea recta (o, con varias variables, con un plano o hiperplano).

Es un supuesto fuerte — el mundo real casi nunca es perfectamente lineal — pero es sorprendentemente útil como punto de partida: es fácil de ajustar, fácil de interpretar y, en muchos problemas, funciona sorprendentemente bien. Por eso es el primer modelo que vas a dominar a fondo en este curso.

A lo largo de este notebook vas a trabajar con el dataset diabetes de scikit-learn: datos clínicos de 442 pacientes (edad, sexo, IMC, presión arterial y varias mediciones de sangre) con los que vas a predecir un índice cuantitativo de progresión de la enfermedad un año después de la medición inicial. Es un dataset pequeño, real y viene incluido en la librería, así que todo el código de este notebook corre sin depender de archivos externos.

import numpy as np
import pandas as pd
from sklearn.datasets import load_diabetes

diabetes = load_diabetes(as_frame=True)
X_completo = diabetes.data
y = diabetes.target  # progresión de la enfermedad, medida un año después del inicio

print(f"Observaciones: {X_completo.shape[0]}")
print(f"Variables predictoras: {list(X_completo.columns)}")
X_completo.head()

Observaciones: 442
Variables predictoras: ['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']

Antes de seguir, vale la pena saber qué mide cada columna — las vas a interpretar más adelante:

Y la variable de salida, y, es una medida cuantitativa de qué tan avanzada está la enfermedad un año después de la medición inicial: entre más alto el valor, más ha progresado.

Regresión lineal simple: una variable predictora

Empieza por el caso más simple posible: predecir usando una sola variable predictora, . El modelo de regresión lineal simple es una recta:

Donde:

• es el valor predicho por el modelo, distinto del valor real observado, .
• es el intercepto: el valor predicho de cuando . Geométricamente, es el punto donde la recta cruza el eje vertical.
• es la pendiente: cuánto cambia por cada unidad que aumenta . Si , la relación es positiva (a más , más ); si , es negativa.

import matplotlib.pyplot as plt

# Ejemplo tradicional: horas de estudio de 10 estudiantes vs. calificación del examen (0-100)
horas_estudio = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
calificacion = np.array([50, 55, 58, 63, 65, 70, 72, 74, 80, 84])

x_media = horas_estudio.mean()
y_media = calificacion.mean()

beta1_manual = np.sum((horas_estudio - x_media) * (calificacion - y_media)) / np.sum(
    (horas_estudio - x_media) ** 2
)
beta0_manual = y_media - beta1_manual * x_media

print(f"x̄ = {x_media:.2f}, ȳ = {y_media:.2f}")
print(f"beta1 (pendiente):  {beta1_manual:.2f}")
print(f"beta0 (intercepto): {beta0_manual:.2f}")

x_recta_manual = np.linspace(horas_estudio.min(), horas_estudio.max(), 100)
y_recta_manual = beta0_manual + beta1_manual * x_recta_manual

fig, ax = plt.subplots(figsize=(6.5, 4.5))
ax.scatter(horas_estudio, calificacion, color="steelblue", s=60, label="Datos (horas vs. calificación)")
ax.plot(x_recta_manual, y_recta_manual, color="crimson", linewidth=2, label="Recta ajustada a mano")
ax.set_xlabel("Horas de estudio")
ax.set_ylabel("Calificación del examen")
ax.set_title("Ejemplo tradicional: mínimos cuadrados calculados a mano")
ax.legend()
ax.grid(alpha=0.3)
plt.show()

x̄ = 5.50, ȳ = 67.10
beta1 (pendiente):  3.59
beta0 (intercepto): 47.33

from sklearn.linear_model import LinearRegression

modelo_estudio = LinearRegression()
modelo_estudio.fit(horas_estudio.reshape(-1, 1), calificacion)

print("Fórmula clásica (a mano):", round(beta0_manual, 2), round(beta1_manual, 2))
print("scikit-learn:            ", round(modelo_estudio.intercept_, 2), round(modelo_estudio.coef_[0], 2))

predicho=modelo_estudio.coef_[0] * 12 + modelo_estudio.intercept_ 
print(f"Predicción de calificación para 12 horas de estudio: {predicho:.2f}")

Fórmula clásica (a mano): 47.33 3.59
scikit-learn:             47.33 3.59
Predicción de calificación para 12 horas de estudio: 90.46

def sse(beta0, beta1, x, y):
    y_pred = beta0 + beta1 * x
    return np.sum((y - y_pred) ** 2)

sse_ols = sse(beta0_manual, beta1_manual, horas_estudio, calificacion)
sse_alt1 = sse(beta0_manual, beta1_manual + 1.0, horas_estudio, calificacion)  # pendiente algo mayor
sse_alt2 = sse(beta0_manual - 3.0, beta1_manual, horas_estudio, calificacion)  # intercepto desplazado

print(f"SSE con la recta de mínimos cuadrados:       {sse_ols:.1f}")
print(f"SSE con pendiente +1 (recta alternativa 1):  {sse_alt1:.1f}")
print(f"SSE con intercepto -3 (recta alternativa 2): {sse_alt2:.1f}")

SSE con la recta de mínimos cuadrados:       9.3
SSE con pendiente +1 (recta alternativa 1):  394.3
SSE con intercepto -3 (recta alternativa 2): 99.3

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

x_bmi = X_completo[["bmi"]]  # scikit-learn espera una matriz 2D, no un vector

modelo_simple = LinearRegression()
modelo_simple.fit(x_bmi, y)

beta0 = modelo_simple.intercept_
beta1 = modelo_simple.coef_[0]
print(f"Intercepto (beta0): {beta0:.2f}")
print(f"Pendiente  (beta1): {beta1:.2f}")

x_recta = np.linspace(x_bmi["bmi"].min(), x_bmi["bmi"].max(), 100)
y_recta = beta0 + beta1 * x_recta

fig, ax = plt.subplots(figsize=(7, 4.5))
ax.scatter(x_bmi, y, alpha=0.5, label="Pacientes (datos reales)")
ax.plot(x_recta, y_recta, color="crimson", linewidth=2, label="Recta ajustada")
ax.set_xlabel("IMC estandarizado (bmi)")
ax.set_ylabel("Progresión de la enfermedad")
ax.set_title("Regresión lineal simple: progresión de la enfermedad vs. IMC")
ax.legend()
ax.grid(alpha=0.3)
plt.show()

Intercepto (beta0): 152.13
Pendiente  (beta1): 949.44

y_pred_bmi = modelo_simple.predict(x_bmi)
residuales_bmi = y - y_pred_bmi

# Para que la gráfica sea legible, dibuja los residuales solo de una muestra de pacientes
rng = np.random.default_rng(42)
idx_muestra = rng.choice(len(y), size=60, replace=False)

fig, ax = plt.subplots(figsize=(7, 4.5))
ax.scatter(x_bmi, y, alpha=0.5, label="Pacientes (datos reales)")
ax.plot(x_recta, y_recta, color="crimson", linewidth=2, label="Recta ajustada")
for i in idx_muestra:
    xi = x_bmi["bmi"].iloc[i]
    ax.plot([xi, xi], [y.iloc[i], y_pred_bmi[i]], color="gray", linewidth=0.8, alpha=0.7)
ax.set_xlabel("IMC estandarizado (bmi)")
ax.set_ylabel("Progresión de la enfermedad")
ax.set_title("Residuales: distancia vertical entre cada punto y la recta")
ax.legend()
ax.grid(alpha=0.3)
plt.show()

print(f"Suma de residuales al cuadrado (SSE): {np.sum(residuales_bmi ** 2):,.0f}")

Suma de residuales al cuadrado (SSE): 1,719,582

Interpretación de los coeficientes

Ya tienes el modelo ajustado, pero un modelo solo es útil si sabes leer lo que dice. Fíjate en los valores de beta0 y beta1 que imprimiste arriba (, ):

• El intercepto () es la progresión de la enfermedad que predice el modelo cuando bmi vale 0, es decir, para un paciente con un IMC exactamente igual al promedio de la muestra (recuerda: la variable está centrada en cero). No lo interpretes como “IMC igual a cero” en el sentido literal — nadie tiene un IMC de cero — sino como “un paciente con IMC promedio”.
• La pendiente () te dice cuánto sube, en promedio, el índice de progresión de la enfermedad por cada unidad que aumenta bmi. Ojo con un detalle fácil de asumir mal: scikit-learn no reescaló esta variable a la estandarización habitual (media 0, varianza 1). La centró en media cero y luego dividió cada columna para que la suma de cuadrados diera exactamente 1 (norma L2 unitaria) — un detalle propio de cómo empaquetaron este dataset en particular. La desviación estándar real de esta bmi reescalada es de apenas ≈0.048, no 1 — así que “una unidad” no es un punto de IMC real, y tampoco es una desviación estándar: es sencillamente la unidad de esa escala normalizada específica, sin una lectura clínica directa. Lo que sí puedes interpretar sin ambigüedad, más allá de esa escala arbitraria, es el signo y la magnitud relativa: la pendiente sale claramente positiva y grande, lo que confirma la intuición clínica de que un IMC más alto se asocia con una progresión más rápida de la enfermedad.

Este es un punto que te va a servir en cualquier dataset que uses de aquí en adelante: antes de interpretar un coeficiente, revisa en qué unidades está la variable — y no asumas que “estandarizado” siempre significa lo mismo. Un mismo coeficiente significa cosas muy distintas si está en las unidades originales o si fue reescalada, y de qué forma.

Interpretación de los errores (residuales)

Ya interpretaste qué dicen los coeficientes. La otra mitad de la historia son los residuales — la diferencia entre lo que predijo el modelo y lo que pasó en realidad, — que ya usaste antes para comprobar que la recta minimiza el SSE. Pero los residuales no solo sirven para verificar la fórmula: también te dicen si el modelo está capturando bien la relación entre bmi y la progresión de la enfermedad, o si se le está escapando algo.

La forma más rápida de leerlos es graficar cada residual contra el valor predicho . Buscas que los puntos formen una nube sin forma clara, repartida al azar alrededor de la línea horizontal en cero:

• Si ves una curva en vez de una nube sin forma, es señal de que la relación real no es lineal — el modelo se está dejando algo sin capturar.
• Si el ancho de la nube cambia de forma clara a medida que te mueves de izquierda a derecha (por ejemplo, se abre como un abanico), es señal de heterocedasticidad: el error no es igual de grande en todo el rango de predicciones.
• Si la nube se ve pareja y sin patrón visible, es una señal razonable de que el modelo no está violando el supuesto de linealidad de forma obvia — aunque un diagnóstico riguroso (normalidad de los residuales, multicolinealidad entre varias variables, etc.) necesita más que una inspección visual, algo que vas a ver a fondo en el notebook de análisis multivariado.

fig, ax = plt.subplots(figsize=(7, 4.5))
ax.scatter(y_pred_bmi, residuales_bmi, alpha=0.5)
ax.axhline(0, color="crimson", linewidth=2)
ax.set_xlabel("Valor predicho (ŷ)")
ax.set_ylabel("Residual (y - ŷ)")
ax.set_title("Residuales vs. valores predichos: modelo simple con bmi")
ax.grid(alpha=0.3)
plt.show()

print(f"R² del modelo: {modelo_simple.score(x_bmi, y):.3f}")
print(f"Desviación estándar de los residuales: {residuales_bmi.std():.2f}")

R² del modelo: 0.344
Desviación estándar de los residuales: 62.44

Otro ejemplo: predecir el valor de una vivienda

Para que la idea no se quede pegada a un solo dataset, repítela con un problema clásico y puramente explicativo: predecir el precio de una vivienda a partir de su tamaño. No necesitas un dataset real para esto — con unos pocos puntos sintéticos alcanza para ver el patrón con claridad.

Aplica exactamente el mismo procedimiento que ya conoces: calcula y con la fórmula clásica y, por separado, con LinearRegression, para comprobar otra vez que ambos caminos llegan al mismo resultado.

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

# Datos sintéticos, solo para ilustrar: tamaño (m²) y precio de venta (miles de USD) de 10 casas
tamano_m2 = np.array([50, 60, 70, 80, 90, 100, 110, 120, 130, 140])
precio = np.array([120, 138, 150, 165, 180, 195, 208, 225, 242, 258])

# Camino 1: fórmula clásica, a mano
x_media_h = tamano_m2.mean()
y_media_h = precio.mean()
beta1_h = np.sum((tamano_m2 - x_media_h) * (precio - y_media_h)) / np.sum(
    (tamano_m2 - x_media_h) ** 2
)
beta0_h = y_media_h - beta1_h * x_media_h

# Camino 2: scikit-learn
modelo_vivienda = LinearRegression()
modelo_vivienda.fit(tamano_m2.reshape(-1, 1), precio)

print("Fórmula clásica (a mano):", round(beta0_h, 2), round(beta1_h, 2))
print("scikit-learn:            ", round(modelo_vivienda.intercept_, 2), round(modelo_vivienda.coef_[0], 2))

x_recta_h = np.linspace(tamano_m2.min(), tamano_m2.max(), 100)
y_recta_h = beta0_h + beta1_h * x_recta_h

fig, ax = plt.subplots(figsize=(6.5, 4.5))
ax.scatter(tamano_m2, precio, color="steelblue", s=60, label="Casas (datos sintéticos)")
ax.plot(x_recta_h, y_recta_h, color="crimson", linewidth=2, label="Recta ajustada")
ax.set_xlabel("Tamaño de la vivienda (m²)")
ax.set_ylabel("Precio de venta (miles de USD)")
ax.set_title("Ejemplo explicativo: precio de una vivienda según su tamaño")
ax.legend()
ax.grid(alpha=0.3)
plt.show()

Fórmula clásica (a mano): 44.79 1.51
scikit-learn:             44.79 1.51

La pendiente confirma la intuición: a mayor tamaño, mayor precio esperado. Ya tienes un modelo ajustado — ahora la pregunta natural es: ¿cómo lo usas para predecir un caso nuevo, uno que no está en los datos?

Con la recta ya ajustada, predecir es tan simple como evaluarla en el nuevo valor de . Fíjate en un detalle práctico: scikit-learn espera que le pases una matriz 2D para predecir, incluso si es un único valor y una sola variable — por eso [[105.0]] y no simplemente 105.0. Es la misma forma que tenía tamano_m2.reshape(-1, 1) cuando ajustaste el modelo.

# ¿Cuánto costaría, según el modelo, una casa de 105 m²?
tamano_nuevo = np.array([[105.0]])
precio_predicho = modelo_vivienda.predict(tamano_nuevo)

print(f"Precio predicho para 105 m²: {precio_predicho[0]:.1f} mil USD")

Precio predicho para 105 m²: 203.2 mil USD

Forma matricial:

Vuelve ahora al dataset diabetes. Hasta ahora escribiste el modelo variable por variable: . Esa notación funciona bien con una sola variable, pero se vuelve incómoda apenas tienes varias — y el dataset diabetes tiene 10. La solución, como recordarás del repaso de NumPy, es usar álgebra lineal: agrupar todas las observaciones y todos los coeficientes en matrices y expresar el modelo completo como un único producto matricial.

Define la matriz de diseño agregando una columna de unos al inicio (para que multiplique al intercepto ) y luego una columna por cada variable predictora:

Con esto, las predicciones de todas las observaciones a la vez se calculan con un solo producto matricial:

Y el problema de mínimos cuadrados que planteaste antes tiene una solución exacta, cerrada, conocida como la ecuación normal:

scikit-learn no resuelve exactamente así por dentro (usa métodos numéricamente más estables), pero el resultado es equivalente.

Antes de aplicarlo sobre datos reales, hazlo tangible con un ejemplo pequeño que ya conoces bien: horas de estudio contra calificación. Con observaciones y variable, la matriz tiene 10 filas y 2 columnas (la columna de unos, más horas_estudio) — lo suficientemente chica para imprimirla completa y verla “a mano”.

Con los 10 pares (horas, calificación) del ejemplo, la matriz de diseño (columna de unos + columna de horas) y el vector (las calificaciones) quedan así:

Cada fila de es un estudiante: un 1 (para el intercepto) y sus horas de estudio. Aplica la ecuación normal, , sobre estas matrices exactas y compara el resultado con y que ya calculaste antes.

# Matriz de diseño X para el ejemplo de horas de estudio: columna de 1s + columna de horas
n_estudio = horas_estudio.shape[0]
X_estudio = np.hstack([np.ones((n_estudio, 1)), horas_estudio.reshape(-1, 1)])

print("Matriz de diseño X (10 filas: columna de 1s | horas de estudio):")
print(X_estudio)

# Ecuación normal: beta = (X^T X)^-1 X^T y
beta_estudio_matricial = np.linalg.inv(X_estudio.T @ X_estudio) @ X_estudio.T @ calificacion

print("\nCoeficientes con la ecuación normal:      ", beta_estudio_matricial)
print("Coeficientes con la fórmula de covarianza:", [beta0_manual, beta1_manual])

Matriz de diseño X (10 filas: columna de 1s | horas de estudio):
[[ 1.  1.]
 [ 1.  2.]
 [ 1.  3.]
 [ 1.  4.]
 [ 1.  5.]
 [ 1.  6.]
 [ 1.  7.]
 [ 1.  8.]
 [ 1.  9.]
 [ 1. 10.]]

Coeficientes con la ecuación normal:       [47.33333333  3.59393939]
Coeficientes con la fórmula de covarianza: [np.float64(47.33333333333333), np.float64(3.5939393939393938)]

Los coeficientes coinciden exactamente con los que calculaste con la fórmula de covarianza/varianza — tiene que ser así, porque son dos caminos algebraicos distintos para llegar a la misma solución del mismo problema de mínimos cuadrados.

Repite el mismo ejercicio con el otro ejemplo pequeño que ya conoces: el precio de las casas según su tamaño.

Con las 10 casas del ejemplo, la matriz de diseño (columna de unos + columna de tamaño en m²) y el vector (los precios) quedan así:

Mismo patrón: cada fila es una casa, con un 1 para el intercepto y su tamaño en la segunda columna. Aplica sobre estas matrices y compara con y que ya calculaste antes.

# Matriz de diseño X para el ejemplo de las casas: columna de 1s + columna de tamaño (m²)
n_vivienda = tamano_m2.shape[0]
X_vivienda = np.hstack([np.ones((n_vivienda, 1)), tamano_m2.reshape(-1, 1)])

print("Matriz de diseño X (10 filas: columna de 1s | tamaño en m²):")
print(X_vivienda)

beta_vivienda_matricial = np.linalg.inv(X_vivienda.T @ X_vivienda) @ X_vivienda.T @ precio

print("\nCoeficientes con la ecuación normal:      ", beta_vivienda_matricial)
print("Coeficientes con la fórmula de covarianza:", [beta0_h, beta1_h])

Matriz de diseño X (10 filas: columna de 1s | tamaño en m²):
[[  1.  50.]
 [  1.  60.]
 [  1.  70.]
 [  1.  80.]
 [  1.  90.]
 [  1. 100.]
 [  1. 110.]
 [  1. 120.]
 [  1. 130.]
 [  1. 140.]]

Coeficientes con la ecuación normal:       [44.79393939  1.50848485]
Coeficientes con la fórmula de covarianza: [np.float64(44.79393939393938), np.float64(1.5084848484848485)]

Otra vez, coincide exactamente. Ya viste con dos ejemplos distintos que la forma matricial reproduce, número por número, lo mismo que la fórmula “tradicional” — la diferencia es que la matricial escala sin esfuerzo a cualquier cantidad de variables. Ahora aplícala sobre datos reales: reconstruye el modelo simple de bmi con NumPy puro, usando la ecuación normal, y verifica que obtienes los mismos coeficientes que te dio LinearRegression.

n = x_bmi.shape[0]
columna_unos = np.ones((n, 1))
X_matriz = np.hstack([columna_unos, x_bmi.to_numpy()])  # columna de 1s + columna de bmi

# Ecuación normal: beta = (X^T X)^-1 X^T y
beta_matricial = np.linalg.inv(X_matriz.T @ X_matriz) @ X_matriz.T @ y.to_numpy()

print("Coeficientes con la ecuación normal (NumPy):", beta_matricial)
print("Coeficientes con scikit-learn:              ", [beta0, beta1])

Coeficientes con la ecuación normal (NumPy): [152.13348416 949.43526038]
Coeficientes con scikit-learn:               [np.float64(152.13348416289617), np.float64(949.4352603840387)]

Ejercicios: consolida la regresión simple

Ya tienes todas las piezas: la fórmula clásica, scikit-learn, la forma matricial y la ecuación normal. Antes de pasar a modelos con más de una variable predictora — el tema del notebook de análisis multivariado del módulo — vale la pena practicar el mismo patrón unas cuantas veces más: con otra variable, con casos nuevos, comparando variables entre sí, repitiendo el álgebra matricial y poniendo a prueba qué tan frágil es una recta ajustada con pocos datos. Los cinco ejercicios que siguen usan exactamente las herramientas que ya construiste arriba.

# Tu código aquí. Guía de pasos:
# 1. Extrae "bp" de X_completo como matriz 2D: x_bp = X_completo[["bp"]]
# 2. Calcula beta0 y beta1 a mano con la fórmula de covarianza/varianza (igual que hiciste con bmi)
# 3. Ajusta un LinearRegression sobre x_bp y compara sus coeficientes con los del paso 2
# 4. Grafica los puntos (x_bp, y) junto con la recta ajustada, con matplotlib

# Tu código aquí. Guía de pasos:
# 1. Calcula los percentiles 10, 50 y 90 de x_bmi["bmi"] con np.percentile
# 2. Arma una tabla (por ejemplo, un pd.DataFrame) con esos tres valores de bmi, uno por paciente
# 3. Usa modelo_simple.predict(...) sobre esa tabla para obtener la progresión predicha de cada paciente
# 4. Imprime los tres resultados junto con el valor de bmi que los generó

# Tu código aquí. Guía de pasos:
# 1. Recorre cada columna de X_completo (por ejemplo, con un for sobre X_completo.columns)
# 2. Para cada columna, ajusta un LinearRegression usando solo esa variable como predictor
# 3. Calcula el R² de esa regresión sobre los mismos datos, con r2_score
# 4. Guarda los resultados (por ejemplo, en un diccionario o un pd.Series) y ordénalos de mayor a menor

# Tu código aquí. Guía de pasos:
# 1. Extrae x_s5 = X_completo[["s5"]]
# 2. Construye la matriz de diseño: columna de unos + columna de s5 (np.hstack, igual que hiciste con bmi)
# 3. Aplica la ecuación normal: beta = (X^T X)^-1 X^T y, con np.linalg.inv
# 4. Ajusta también un LinearRegression sobre x_s5 y compara ambos resultados

# Tu código aquí. Guía de pasos:
# 1. Crea horas_con_outlier y calificacion_con_outlier agregando el par (2, 95) a los arrays originales,
#    con np.append
# 2. Recalcula beta0 y beta1 con la fórmula clásica, pero sobre los datos con el outlier incluido
# 3. Compara los nuevos coeficientes contra beta0_manual y beta1_manual (los originales, sin el outlier)
# 4. Grafica ambas rectas (original vs. con el outlier) sobre el mismo scatter para ver el desplazamiento

👋 Sobre el autor

Wilder Ramírez Delgado es Científico de Datos, Arquitecto de IA, Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), consultor y docente universitario, trabaja en la intersección entre Data Science, Inteligencia Artificial, Big Data e IoT, transformando problemas reales en soluciones aplicadas.

De la teoría a la práctica, un problema a la vez.

Análisis Multivariado Aplicado

Este notebook introduce el análisis multivariado de forma enfocada: concepto, supuestos, flujo de modelado e interpretación.

Contexto de ejemplo: consumo energético residencial (sin relación con ventas).

1. Qué es análisis multivariado

En análisis univariado observamos una variable a la vez. En bivariado estudiamos la relación entre dos.

En multivariado analizamos varias variables simultáneamente para:

• Explicar una variable objetivo con múltiples predictores: en lugar de asumir que un solo factor determina el resultado, modelamos la contribución conjunta de varias variables. Esto permite representar mejor fenómenos reales, que casi siempre son multifactoriales.

• Controlar factores de confusión: algunas variables pueden distorsionar una relación aparente entre predictor y respuesta. Incluirlas en el modelo ayuda a aislar relaciones más limpias y evita conclusiones engañosas.

• Estimar efectos parciales (manteniendo constantes otras variables): cada coeficiente se interpreta como el cambio esperado en la respuesta cuando una variable aumenta una unidad y las demás permanecen fijas. Esta idea es clave para interpretar impactos individuales.

• Mejorar capacidad predictiva y toma de decisiones: combinar información de varias fuentes suele reducir error de predicción y producir recomendaciones más útiles para la acción (priorizar variables, diseñar intervenciones o asignar recursos).

2. Modelo base: regresión lineal múltiple

Una formulación típica es:

donde:

• es la variable objetivo,
• son predictores,
• representa el cambio esperado en por una unidad adicional de , manteniendo las demás variables constantes,
• captura variación no explicada.

3. Ejemplo de contexto (energía residencial)

Objetivo: explicar el consumo mensual de energía (kWh) a partir de variables como:

• temperatura promedio exterior,
• número de ocupantes,
• área de la vivienda (m2),
• índice de aislamiento térmico,
• cantidad de electrodomésticos intensivos.

Este tipo de problema es naturalmente multivariado: una sola variable rara vez explica por completo el consumo.

pip install seaborn

Requirement already satisfied: seaborn in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (0.13.2)
Requirement already satisfied: numpy!=1.24.0,>=1.20 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from seaborn) (2.5.1)
Requirement already satisfied: pandas>=1.2 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from seaborn) (3.0.5)
Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from seaborn) (3.11.1)
Requirement already satisfied: contourpy>=1.0.1 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.3.3)
Requirement already satisfied: cycler>=0.10 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (0.12.1)
Requirement already satisfied: fonttools>=4.28.2 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (4.63.0)
Requirement already satisfied: kiwisolver>=1.3.1 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.5.0)
Requirement already satisfied: packaging>=20.0 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (26.0)
Requirement already satisfied: pillow>=9 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (12.3.0)
Requirement already satisfied: pyparsing>=3 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (3.3.2)
Requirement already satisfied: python-dateutil>=2.7 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (2.9.0.post0)
Requirement already satisfied: tzdata in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from pandas>=1.2->seaborn) (2026.3)
Requirement already satisfied: six>=1.5 in c:\Users\wilde\.conda\envs\ANALITICA\Lib\site-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.4->seaborn) (1.17.0)
Note: you may need to restart the kernel to use updated packages.

# Librerias base para analisis multivariado
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

import statsmodels.api as sm
from statsmodels.stats.outliers_influence import variance_inflation_factor

# Estilo visual base para mantener uniformidad en todas las graficas
sns.set_theme(style="whitegrid", context="notebook")
plt.rcParams["axes.titlesize"] = 12
plt.rcParams["axes.labelsize"] = 10

# Dataset sintetico: energia residencial
rng = np.random.default_rng(24)
n = 500

temperatura = rng.normal(20, 4, n)
ocupantes = rng.integers(1, 7, n)
area_m2 = rng.normal(85, 20, n).clip(35, 180)
aislamiento = rng.uniform(0.2, 1.0, n)
electrodomesticos = rng.integers(2, 11, n)

ruido = rng.normal(0, 25, n)
consumo_kwh = (
    120
    + 1.8 * area_m2
    + 18 * ocupantes
    + 9 * electrodomesticos
    - 55 * aislamiento
    + 2.7 * np.abs(temperatura - 22)
    + ruido
)

df = pd.DataFrame({
    "temperatura": temperatura,
    "ocupantes": ocupantes,
    "area_m2": area_m2,
    "aislamiento": aislamiento,
    "electrodomesticos": electrodomesticos,
    "consumo_kwh": consumo_kwh
})

df.head()

4. Flujo recomendado de trabajo

1. Definir pregunta y variable objetivo

Este paso responde: “¿Qué quiero entender o predecir exactamente?”. Si la pregunta es difusa, el modelo también lo será. La variable objetivo es el resultado final que intentamos explicar.

Términos clave: - Variable objetivo: el resultado principal del estudio. - Unidad de análisis: sobre quién se mide (hogar, persona, empresa, etc.). - Horizonte temporal: en qué período se mide (día, mes, año).

Por qué importa: este paso pone límites claros al análisis y evita mezclar objetivos distintos en un mismo modelo.

2. Revisar calidad de datos (nulos, atípicos, escalas, codificación)

Aquí verificamos si los datos son confiables antes de sacar conclusiones. Si hay valores faltantes, errores extremos o categorías mal registradas, el modelo aprende “ruido” en lugar de aprender patrones reales.

Términos clave: - Nulos: datos faltantes. - Atípicos (outliers): valores muy alejados del comportamiento normal. - Escala: tamaño numérico de una variable (por ejemplo 0-1 versus 0-10000). - Codificación: forma de representar texto o categorías en formato útil para análisis.

Por qué importa: un modelo no corrige automáticamente datos mal preparados; solo amplifica sus problemas.

3. Explorar relaciones entre predictores y objetivo

Antes de modelar, observamos cómo se mueven las variables entre sí. Este paso ayuda a detectar relaciones claras, relaciones débiles, posibles efectos no lineales y variables redundantes.

Términos clave: - Predictor: variable usada para explicar la objetivo. - Relación lineal: cuando el cambio entre variables sigue una tendencia aproximadamente recta. - Interacción: cuando el efecto de una variable depende del nivel de otra.

Por qué importa: evita construir un modelo “a ciegas” y orienta mejores decisiones de modelado.

4. Partir datos en entrenamiento y prueba

Separamos los datos en dos grupos: uno para aprender y otro para evaluar. El modelo se ajusta con entrenamiento y se pone a prueba con datos que no vio.

Términos clave: - Entrenamiento (train): datos para ajustar el modelo. - Prueba (test): datos reservados para medir desempeño real. - Generalización: capacidad de funcionar bien en datos nuevos.

Por qué importa: sin esta separación, es fácil creer que el modelo es bueno cuando solo está memorizando.

5. Ajustar modelo base (OLS o equivalente)

Construimos primero una versión simple y explicable del modelo. Ese modelo base funciona como punto de partida para comparar mejoras posteriores.

Términos clave: - OLS: método clásico que ajusta la mejor línea/plano minimizando errores al cuadrado. - Coeficiente: cuánto cambia la variable objetivo si un predictor sube una unidad (manteniendo lo demás constante). - Intercepto: valor esperado de la variable objetivo cuando los predictores valen cero (si tiene interpretación en el contexto).

Por qué importa: un buen modelo base permite saber si la complejidad adicional realmente aporta valor.

6. Diagnosticar supuestos y multicolinealidad

Este paso es un control de calidad del modelo ya entrenado. La pregunta aquí no es solo “¿cuánto acierta?”, sino también “¿es confiable lo que dice?”.

En lenguaje simple: un modelo puede dar buenas predicciones promedio y aun así estar mal calibrado para interpretar efectos. Por ejemplo, si los residuos muestran patrón (en vez de dispersarse de forma aleatoria), el modelo está dejando estructura sin explicar. Si dos predictores dicen casi lo mismo, los coeficientes pueden volverse inestables y cambiar de signo entre muestras parecidas.

Términos clave: - Residuo: diferencia entre valor real y valor predicho. - Homoscedasticidad: variabilidad de residuos parecida a lo largo del rango de predicciones. - Multicolinealidad: solapamiento fuerte de información entre predictores. - VIF: indicador de cuánto se infla la incertidumbre de un coeficiente por colinealidad.

Regla práctica: si esta etapa falla, no conviene interpretar coeficientes como si fueran firmes, aunque el error global parezca bueno.

Por qué importa: protege contra conclusiones frágiles y mejora la credibilidad técnica del análisis.

7. Evaluar con métricas y validación cruzada

Evaluar bien significa mirar el desempeño desde tres ángulos: magnitud del error, sensibilidad a errores grandes y estabilidad del modelo.

Primero, las métricas sobre test te dicen “cómo le fue” en una partición concreta. Luego, la validación cruzada responde “si repito el proceso, ¿se mantiene el resultado o cambia mucho?”. Esa segunda pregunta es clave para confiar en que el modelo no depende de una sola muestra afortunada.

Términos clave: - MAE: error promedio absoluto; se interpreta fácil porque está en unidades reales. - RMSE: parecido al MAE, pero castiga más los errores grandes. - R2: porcentaje de variabilidad explicado por el modelo. - Validación cruzada: repetir entrenamiento/evaluación en varios pliegues para medir robustez.

Lectura recomendada: no decidir con una sola métrica. Un modelo puede tener buen R2 y aun así cometer errores absolutos demasiado altos para el contexto de decisión.

Por qué importa: permite seleccionar modelos por desempeño real y estable, no por resultados puntuales.

8. Iterar (transformaciones, regularización, selección de variables)

Con los resultados en mano, se mejora el modelo paso a paso. La idea es simplificar lo necesario y ganar estabilidad sin perder interpretabilidad.

Términos clave: - Transformación: cambiar la escala o forma de una variable para capturar mejor su relación con la objetivo. - Regularización: técnica para evitar sobreajuste penalizando complejidad excesiva. - Ridge/Lasso: métodos comunes para estabilizar o simplificar coeficientes cuando hay muchas variables o colinealidad.

Por qué importa: el primer modelo rara vez es el mejor; iterar con criterio mejora calidad y confiabilidad.

9. Comunicar resultados con interpretación y límites

El trabajo termina cuando el resultado se puede entender y usar para decidir. Se debe explicar qué se encontró, con qué confianza, bajo qué condiciones y con qué restricciones.

Términos clave: - Significancia estadística: evidencia de que una relación no parece producto del azar, bajo supuestos. - Relevancia práctica: si el efecto encontrado realmente importa en la realidad. - Limitaciones: lo que el modelo no cubre o no puede asegurar.

Por qué importa: un análisis serio no solo reporta aciertos; también declara alcances, riesgos y límites de uso.

Criterio general: en análisis multivariado, la claridad de la pregunta y la calidad de los datos suelen influir más en el resultado que elegir un algoritmo más sofisticado.

5. Exploración multivariada

La exploración multivariada es el puente entre “tener datos” y “construir un modelo con criterio”. Su objetivo no es solo describir, sino detectar señales útiles y riesgos metodológicos antes del entrenamiento formal.

En esta etapa buscamos responder preguntas prácticas como: - ¿Qué variables parecen realmente informativas? - ¿Cuáles variables parecen duplicar información? - ¿Hay patrones no lineales que un modelo lineal simple no capturaría bien? - ¿Existen grupos atípicos que puedan sesgar conclusiones?

# Etapa 1: construir un dataset sintetico controlado
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

rng = np.random.default_rng(2026)
n = 450

# Segmento para heterogeneidad estructural
segmento = rng.choice(["urbano", "rural"], size=n, p=[0.65, 0.35])

# Predictores con relación y colinealidad parcial
ingreso = rng.normal(2500, 700, n).clip(700, 6000)
tamano_hogar = rng.integers(1, 7, n)
edad_vivienda = rng.normal(18, 9, n).clip(1, 60)
aislamiento = rng.uniform(0.25, 0.95, n)

# Variable casi redundante con ingreso (colinealidad intencional)
gasto_electrico_base = 0.28 * ingreso + rng.normal(0, 120, n)

# Relación no lineal intencional con temperatura
temperatura = rng.normal(22, 5, n)
efecto_temp = 3.5 * np.abs(temperatura - 24)

# Consumo con diferencias por segmento
efecto_segmento = np.where(segmento == "urbano", 55, -20)
ruido = rng.normal(0, 45, n)

consumo = (
    140
    + 0.045 * ingreso
    + 26 * tamano_hogar
    + 1.4 * edad_vivienda
    - 95 * aislamiento
    + 0.10 * gasto_electrico_base
    + efecto_temp
    + efecto_segmento
    + ruido
)

df_demo = pd.DataFrame({
    "segmento": segmento,
    "ingreso": ingreso,
    "tamano_hogar": tamano_hogar,
    "edad_vivienda": edad_vivienda,
    "aislamiento": aislamiento,
    "gasto_electrico_base": gasto_electrico_base,
    "temperatura": temperatura,
    "consumo_kwh": consumo
})

# Inyectamos unos pocos outliers tecnicos
idx_out = rng.choice(df_demo.index, size=6, replace=False)
df_demo.loc[idx_out, "consumo_kwh"] *= rng.uniform(2.2, 3.0, size=6)

preds = ["ingreso", "tamano_hogar", "edad_vivienda", "aislamiento", "gasto_electrico_base", "temperatura"]

print("Dataset listo:", df_demo.shape)
df_demo.head()

Dataset listo: (450, 8)

# Etapa 2: distribuciones marginales y asimetría
vars_plot = ["consumo_kwh", "ingreso", "tamano_hogar", "edad_vivienda", "aislamiento", "temperatura"]

fig, axes = plt.subplots(2, 3, figsize=(14, 7))
for ax, col in zip(axes.ravel(), vars_plot):
    sns.histplot(df_demo[col], kde=True, ax=ax)
    ax.set_title(f"Distribución: {col}")
plt.tight_layout()
plt.show()

print("Asimetria (skewness) por variable:")
display(df_demo[vars_plot].skew().to_frame("skew"))

Asimetria (skewness) por variable:

# Etapa 3: correlación de cada predictor con la variable objetivo
corr_target = df_demo[preds + ["consumo_kwh"]].corr()["consumo_kwh"].drop("consumo_kwh")
corr_target = corr_target.sort_values(key=np.abs, ascending=False)

print("Correlación predictor -> consumo (ordenada por magnitud absoluta):")
display(corr_target.to_frame("corr_con_consumo"))

plt.figure(figsize=(7, 4))
corr_target.sort_values().plot(kind="barh")
plt.title("Correlación de predictores con consumo_kwh")
plt.xlabel("Coeficiente de correlación")
plt.tight_layout()
plt.show()

print("Interpretación: magnitud más alta = asociación lineal más fuerte (no implica causalidad).")

Correlación predictor -> consumo (ordenada por magnitud absoluta):

Interpretación: magnitud más alta = asociación lineal más fuerte (no implica causalidad).

# Etapa 4: correlación entre predictores (foco principal)
corr_preds = df_demo[preds].corr()

print("Matriz de correlación entre predictores:")
display(corr_preds)

plt.figure(figsize=(8, 5))
sns.heatmap(corr_preds, annot=True, cmap="coolwarm", fmt=".2f")
plt.title("Correlación entre predictores")
plt.show()

# Ranking de pares con mayor correlación absoluta
pairs = (
    corr_preds.where(np.triu(np.ones(corr_preds.shape), k=1).astype(bool))
    .stack()
    .reset_index()
    .rename(columns={"level_0": "var_1", "level_1": "var_2", 0: "corr"})
)
pairs["abs_corr"] = pairs["corr"].abs()
pairs = pairs.sort_values("abs_corr", ascending=False)

print("Top 8 pares más correlacionados (en valor absoluto):")
display(pairs.head(8))

print("Lectura clave: una correlación alta entre predictores sugiere posible redundancia de información.")

Matriz de correlación entre predictores:

Top 8 pares más correlacionados (en valor absoluto):

Lectura clave: una correlación alta entre predictores sugiere posible redundancia de información.

# Etapa 5: cuantificar redundancia entre predictores con VIF
X_vif_demo = sm.add_constant(df_demo[preds])
vif_demo = pd.DataFrame({
    "variable": X_vif_demo.columns,
    "VIF": [variance_inflation_factor(X_vif_demo.values, i) for i in range(X_vif_demo.shape[1])]
})

display(vif_demo.sort_values("VIF", ascending=False))
print("Guia rapida: VIF < 5 usualmente aceptable; 5-10 zona de alerta; > 10 problema serio.")

Guia rapida: VIF < 5 usualmente aceptable; 5-10 zona de alerta; > 10 problema serio.

# Etapa 6: validar no linealidad (lineal vs polinomial en temperatura)
X_lin = df_demo[["temperatura"]]
y_lin = df_demo["consumo_kwh"]

m_lin = LinearRegression().fit(X_lin, y_lin)
r2_lin = m_lin.score(X_lin, y_lin)

poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X_lin)
m_poly = LinearRegression().fit(X_poly, y_lin)
r2_poly = m_poly.score(X_poly, y_lin)

print(f"R2 lineal (temperatura -> consumo): {r2_lin:.3f}")
print(f"R2 polinomial grado 2:             {r2_poly:.3f}")
print("Si el polinomial mejora de forma clara, hay evidencia de curvatura.")

R2 lineal (temperatura -> consumo): 0.014
R2 polinomial grado 2:             0.014
Si el polinomial mejora de forma clara, hay evidencia de curvatura.

# Etapa 7: validar heterogeneidad por segmento
resumen_segmento = df_demo.groupby("segmento")["consumo_kwh"].agg(["mean", "median", "std", "count"])
print("Resumen por segmento:")
display(resumen_segmento)

plt.figure(figsize=(7, 4))
sns.boxplot(data=df_demo, x="segmento", y="consumo_kwh")
plt.title("Consumo por segmento")
plt.show()

print("Si las medias/medianas difieren de forma consistente, hay heterogeneidad estructural.")

Resumen por segmento:

Si las medias/medianas difieren de forma consistente, hay heterogeneidad estructural.

# Etapa 8: detectar outliers con IQR y revisar casos
q1 = df_demo["consumo_kwh"].quantile(0.25)
q3 = df_demo["consumo_kwh"].quantile(0.75)
iqr = q3 - q1
lim_inf = q1 - 1.5 * iqr
lim_sup = q3 + 1.5 * iqr

mask_out = (df_demo["consumo_kwh"] < lim_inf) | (df_demo["consumo_kwh"] > lim_sup)
n_out = int(mask_out.sum())
pct_out = 100 * n_out / len(df_demo)

print(f"Outliers detectados por IQR: {n_out} ({pct_out:.2f}%)")
print("Primeros casos para inspección contextual:")
display(df_demo.loc[mask_out, ["segmento", "ingreso", "temperatura", "consumo_kwh"]].head(10))

plt.figure(figsize=(8, 4))
sns.scatterplot(
    data=df_demo,
    x=df_demo.index,
    y="consumo_kwh",
    hue=mask_out,
    palette={False: "steelblue", True: "crimson"},
    alpha=0.7
)
plt.title("Outliers IQR resaltados")
plt.xlabel("Índice de observación")
plt.legend(title="Outlier")
plt.show()

Outliers detectados por IQR: 10 (2.22%)
Primeros casos para inspección contextual:

6. Supuestos clave en regresión múltiple

La regresión múltiple no se evalúa solo por el R2. Para interpretar coeficientes, p-valores e intervalos de confianza con rigor, hay supuestos que deben revisarse.

# Separación train/test y ajuste con statsmodels para inferencia
X = df.drop(columns=["consumo_kwh"])
y = df["consumo_kwh"]

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

X_train_sm = sm.add_constant(X_train)
modelo_ols = sm.OLS(y_train, X_train_sm).fit()
print(modelo_ols.summary())

                            OLS Regression Results                            
==============================================================================
Dep. Variable:            consumo_kwh   R-squared:                       0.823
Model:                            OLS   Adj. R-squared:                  0.821
Method:                 Least Squares   F-statistic:                     367.6
Date:                Thu, 27 Aug 2026   Prob (F-statistic):          6.43e-146
Time:                        23:12:33   Log-Likelihood:                -1875.2
No. Observations:                 400   AIC:                             3762.
Df Residuals:                     394   BIC:                             3786.
Df Model:                           5                                         
Covariance Type:            nonrobust                                         
=====================================================================================
                        coef    std err          t      P>|t|      [0.025      0.975]
-------------------------------------------------------------------------------------
const               161.9641      9.716     16.670      0.000     142.862     181.066
temperatura          -1.8394      0.325     -5.658      0.000      -2.479      -1.200
ocupantes            18.9569      0.808     23.457      0.000      17.368      20.546
area_m2               1.8394      0.062     29.560      0.000       1.717       1.962
aislamiento         -58.7356      5.689    -10.325      0.000     -69.919     -47.552
electrodomesticos     8.9760      0.511     17.566      0.000       7.971       9.981
==============================================================================
Omnibus:                        1.336   Durbin-Watson:                   1.889
Prob(Omnibus):                  0.513   Jarque-Bera (JB):                1.250
Skew:                          -0.137   Prob(JB):                        0.535
Kurtosis:                       3.015   Cond. No.                         686.
==============================================================================

Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.

7. Multicolinealidad y VIF

La multicolinealidad es el solapamiento de información entre predictores: varias variables explicativas aportan casi la misma señal dentro del modelo. El VIF (Variance Inflation Factor) es el indicador que cuantifica ese problema, midiendo cuánto se infla la varianza de cada coeficiente por depender linealmente de los demás predictores. Sí, está relacionado con la correlación: correlaciones altas entre predictores suelen ser una alerta inicial, pero el VIF es más completo porque evalúa la colinealidad conjunta (no solo pares aislados).

Diferencia clave: la correlación describe asociación lineal entre dos variables a la vez (visión bivariada), mientras que el VIF evalúa para cada predictor cuánta redundancia tiene respecto al conjunto de todos los demás predictores (visión multivariada). Por eso, puede haber casos con correlaciones por pares moderadas pero VIF elevado, si la combinación de varias variables juntas explica casi la misma información.

# Cálculo e interpretación práctica de VIF
X_vif = sm.add_constant(X_train).copy()

vif_df = pd.DataFrame({
    "variable": X_vif.columns,
    "VIF": [variance_inflation_factor(X_vif.values, i) for i in range(X_vif.shape[1])]
})

# El intercepto no se interpreta para colinealidad, se excluye en el semaforo.
vif_eval = vif_df[vif_df["variable"] != "const"].copy()

def clasificar_vif(v):
    if v < 5:
        return "OK (<5)"
    if v < 10:
        return "Alerta (5-10)"
    return "Alto (>=10)"

vif_eval["lectura"] = vif_eval["VIF"].apply(clasificar_vif)
vif_eval = vif_eval.sort_values("VIF", ascending=False).reset_index(drop=True)

display(vif_eval)

n_alerta = (vif_eval["VIF"] >= 5).sum()
n_alto = (vif_eval["VIF"] >= 10).sum()

print(f"Variables en alerta (VIF >= 5): {n_alerta}")
print(f"Variables en riesgo alto (VIF >= 10): {n_alto}")

Variables en alerta (VIF >= 5): 0
Variables en riesgo alto (VIF >= 10): 0

# Conclusiones automáticas según resultados VIF
vif_max = float(vif_eval["VIF"].max())
var_max = str(vif_eval.loc[vif_eval["VIF"].idxmax(), "variable"])

print("Resumen automático de colinealidad:")
print(f"- VIF máximo: {vif_max:.3f} ({var_max})")
print(f"- Variables en alerta (VIF >= 5): {int(n_alerta)}")
print(f"- Variables en riesgo alto (VIF >= 10): {int(n_alto)}")

if n_alto > 0:
    print("Conclusión: hay multicolinealidad alta; revisar selección/transformación de variables antes de interpretar coeficientes.")
elif n_alerta > 0:
    print("Conclusión: existe colinealidad moderada; interpretar coeficientes con cautela y considerar regularización.")
else:
    print("Conclusión: no hay evidencia relevante de multicolinealidad según VIF; la interpretación de coeficientes es estable en este aspecto.")

Resumen automático de colinealidad:
- VIF máximo: 1.014 (ocupantes)
- Variables en alerta (VIF >= 5): 0
- Variables en riesgo alto (VIF >= 10): 0
Conclusión: no hay evidencia relevante de multicolinealidad según VIF; la interpretación de coeficientes es estable en este aspecto.

8. Evaluación predictiva

La evaluación predictiva responde dos preguntas: 1. ¿Qué tan grande es el error en unidades reales? 2. ¿Qué tan estable es el desempeño cuando cambia la muestra?

Primero definimos el error por observación (residuo de predicción):

Con esos residuos, las métricas principales son:

• MAE (Mean Absolute Error):

• MSE (Mean Squared Error):

• RMSE (Root Mean Squared Error):

• R2 (coeficiente de determinación):

Interpretación conceptual: - MAE: error promedio en unidades originales; fácil de explicar a negocio/política pública. - MSE: error cuadrático promedio; amplifica errores grandes y es muy útil para comparar modelos durante optimización matemática. - RMSE: raíz del MSE; conserva la sensibilidad a errores grandes pero vuelve a la escala original de la variable objetivo. - R2: proporción de variabilidad explicada; útil para comparar ajuste global.

La validación cruzada complementa la foto de test único: en lugar de depender de una sola partición, mide robustez en varios pliegues.

Idea clave: no conviene decidir con una sola métrica. Un modelo puede tener buen R2 y aun así un error absoluto demasiado alto para el contexto de decisión.

# Modelo base con sklearn + lectura de estabilidad
lr = LinearRegression()
lr.fit(X_train, y_train)
pred_test = lr.predict(X_test)

mae = mean_absolute_error(y_test, pred_test)
rmse = np.sqrt(mean_squared_error(y_test, pred_test))
r2 = r2_score(y_test, pred_test)

cv_r2 = cross_val_score(lr, X, y, cv=5, scoring="r2")
cv_r2_mean = float(cv_r2.mean())
cv_r2_std = float(cv_r2.std())

print(f"MAE : {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"R2 test: {r2:.3f}")
print(f"R2 CV (media): {cv_r2_mean:.3f}")
print(f"R2 CV (desv):  {cv_r2_std:.3f}")

# Brecha test vs CV como chequeo rapido de estabilidad
gap_test_cv = r2 - cv_r2_mean
print(f"Brecha R2 test - R2 CV media: {gap_test_cv:+.3f}")

MAE : 22.40
RMSE: 27.66
R2 test: 0.820
R2 CV (media): 0.808
R2 CV (desv):  0.037
Brecha R2 test - R2 CV media: +0.012

9. Cuándo usar regularización

Definición breve (antes del detalle): Regularizar significa entrenar el modelo minimizando no solo el error de ajuste, sino también una penalización por coeficientes grandes. En práctica, es una forma de controlar complejidad para reducir sobreajuste y mejorar generalización.

En palabras simples, así funciona el proceso matemático:

Qué hace OLS (sin regularización) - Solo intenta minimizar el error de predicción. - Si hay ruido o variables muy parecidas, puede asignar coeficientes grandes e inestables para “perseguir” detalles de la muestra.

Qué agrega la regularización - Además de minimizar error, agrega un “costo” por coeficientes grandes. - Eso obliga al modelo a preferir soluciones más sobrias.

# Comparación: OLS vs Ridge vs Lasso con validación cruzada
modelos = {
    "OLS": LinearRegression(),
    "Ridge(alpha=1.0)": Pipeline([("scaler", StandardScaler()), ("m", Ridge(alpha=1.0))]),
    "Lasso(alpha=0.05)": Pipeline([("scaler", StandardScaler()), ("m", Lasso(alpha=0.05, max_iter=10000))]),
}

res_reg = []
for nombre, modelo in modelos.items():
    scores = cross_val_score(modelo, X, y, cv=5, scoring="r2")
    res_reg.append({
        "modelo": nombre,
        "r2_cv_mean": float(scores.mean()),
        "r2_cv_std": float(scores.std())
    })

res_reg_df = pd.DataFrame(res_reg).sort_values("r2_cv_mean", ascending=False).reset_index(drop=True)
display(res_reg_df)

mejor_modelo = str(res_reg_df.loc[0, "modelo"])
mejor_r2 = float(res_reg_df.loc[0, "r2_cv_mean"])
print(f"Mejor modelo por R2 CV medio: {mejor_modelo} ({mejor_r2:.3f})")

Mejor modelo por R2 CV medio: Ridge(alpha=1.0) (0.808)

10. Diagnóstico de residuos (capítulo clave)

El residuo es la parte que el modelo no logra explicar:

Mirar residuos permite detectar problemas que no se ven en una sola métrica de desempeño. Un modelo puede tener buen R2 y, aun así, mostrar fallas estructurales en residuos.

# Diagnóstico de residuos: gráfico + resumen numérico
from statsmodels.stats.stattools import durbin_watson

pred_train = modelo_ols.predict(X_train_sm)
resid = y_train - pred_train

# Prediccion y residuos sobre el conjunto de PRUEBA: el modelo no los vio al ajustarse,
# por eso son los unicos que permiten un chequeo no tautologico de media y correlacion (ver nota arriba).
X_test_sm = sm.add_constant(X_test)
pred_test = modelo_ols.predict(X_test_sm)
resid_test = y_test - pred_test

fig, axes = plt.subplots(1, 3, figsize=(15, 4))

# 1) Residuo vs predicción
axes[0].scatter(pred_train, resid, alpha=0.6)
axes[0].axhline(0, color="red", linestyle="--")
axes[0].set_xlabel("Predicción")
axes[0].set_ylabel("Residuo")
axes[0].set_title("Residuo vs predicción")

# 2) Histograma de residuos
sns.histplot(resid, kde=True, ax=axes[1])
axes[1].set_title("Distribución de residuos")
axes[1].set_xlabel("Residuo")

# 3) Q-Q plot
sm.qqplot(resid, line="45", ax=axes[2], fit=True)
axes[2].set_title("Q-Q plot de residuos")

plt.tight_layout()
plt.show()

# Resumen numerico rapido (sobre train, para escala/forma) mas el chequeo no tautologico (sobre test)
resid_mean = float(resid.mean())
resid_std = float(resid.std())
corr_pred_resid = float(np.corrcoef(pred_train, resid)[0, 1])
pct_extremos = float((np.abs(resid) > 2 * resid_std).mean() * 100)
dw = float(durbin_watson(resid))

resid_test_mean = float(resid_test.mean())
corr_pred_resid_test = float(np.corrcoef(pred_test, resid_test)[0, 1])

print(f"Media de residuos (train, ~0 por construccion, no es diagnostico): {resid_mean:.3f}")
print(f"Media de residuos (test, chequeo real):                          {resid_test_mean:.3f}")
print(f"Desv. estandar de residuos: {resid_std:.3f}")
print(f"Correlacion prediccion-residuo (train, ~0 por construccion, no es diagnostico): {corr_pred_resid:.3f}")
print(f"Correlacion prediccion-residuo (test, chequeo real):                            {corr_pred_resid_test:.3f}")
print(f"% residuos extremos (|resid| > 2*std): {pct_extremos:.2f}%")
print(f"Durbin-Watson: {dw:.3f}")

# Lectura automatica orientativa (usa el chequeo de test, el unico no tautologico)
if abs(corr_pred_resid_test) > 0.2:
    print("Alerta: hay dependencia notable entre prediccion y residuo en test; revisar especificacion.")
else:
    print("OK: no hay dependencia lineal fuerte entre prediccion y residuo en test.")

if pct_extremos > 8:
    print("Alerta: porcentaje alto de residuos extremos; revisar outliers y no linealidad.")
else:
    print("OK: porcentaje de residuos extremos en rango razonable.")

Media de residuos (train, ~0 por construccion, no es diagnostico): 0.000
Media de residuos (test, chequeo real):                          2.371
Desv. estandar de residuos: 26.319
Correlacion prediccion-residuo (train, ~0 por construccion, no es diagnostico): -0.000
Correlacion prediccion-residuo (test, chequeo real):                            0.088
% residuos extremos (|resid| > 2*std): 5.25%
Durbin-Watson: 1.889
OK: no hay dependencia lineal fuerte entre prediccion y residuo en test.
OK: porcentaje de residuos extremos en rango razonable.

11. Guía práctica para interpretar resultados (paso a paso)

Usa esta guía cada vez que termines un modelo. La idea es responder: - qué tan bien predice, - si es estable, - y si se puede interpretar con confianza.

12. Cierre

Este notebook deja una base clara de análisis multivariado:

• marco teórico breve,
• flujo de trabajo reproducible,
• ejemplo alternativo al contexto comercial,
• herramientas para inferencia, predicción y diagnóstico.

Siguiente paso sugerido: adaptar este esqueleto a un dataset real del curso y comparar un modelo lineal simple frente a uno multivariado.

👋 Sobre el autor

Wilder Ramírez Delgado es Científico de Datos, Arquitecto de IA, Ingeniero Electrónico y Magíster en Analítica de Datos. CEO y fundador de Business Innovation Technology (BIT), consultor y docente universitario, trabaja en la intersección entre Data Science, Inteligencia Artificial, Big Data e IoT, transformando problemas reales en soluciones aplicadas.

De la teoría a la práctica, un problema a la vez.

¿Por qué la regresión lineal se queda corta?

La regresión lineal es, probablemente, el primer modelo que aprendiste en ciencia de datos. Es simple, interpretable y funciona sorprendentemente bien en muchos problemas reales. Pero tiene puntos débiles que se vuelven críticos en la práctica:

• Cuando hay muchas variables predictoras, algunas correlacionadas entre sí (multicolinealidad), los coeficientes se vuelven inestables: pequeños cambios en los datos producen coeficientes muy distintos.
• Cuando el modelo tiene más flexibilidad de la necesaria (muchas variables, o términos polinomiales), tiende a memorizar el ruido del conjunto de entrenamiento en lugar de aprender el patrón real — esto se llama sobreajuste (overfitting).
• No tienes forma de decirle al modelo qué variables no aportan, para que las ignore.

La solución a estos tres problemas tiene un nombre: regularización. En este artículo vas a construir la intuición completa, con código ejecutable de principio a fin, sobre las dos formas de regularización más usadas en regresión: Ridge y Lasso.

Repaso: regresión lineal múltiple

La regresión lineal múltiple modela una variable de respuesta como una combinación lineal de variables predictoras:

Los coeficientes se estiman minimizando la suma de errores al cuadrado (mínimos cuadrados ordinarios, OLS):

Para repasarla, vas a usar un dataset real: precios de vivienda en California, disponible directamente en scikit-learn. Cada fila es un bloque censal, con variables como ingreso medio, antigüedad de las viviendas, número de habitaciones, población y ubicación geográfica; el objetivo es predecir el precio medio de la vivienda.

import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing

# Dataset real: precios de vivienda en California (incluido en scikit-learn)
housing = fetch_california_housing(as_frame=True)
X = housing.data
y = housing.target  # precio medio de vivienda, en cientos de miles de USD

print(f"Observaciones: {X.shape[0]}")
print(f"Variables predictoras: {list(X.columns)}")
X.head()

Observaciones: 20640
Variables predictoras: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']

Para evaluar el modelo de forma honesta, separa los datos en un conjunto de entrenamiento y uno de prueba: ajusta el modelo solo con el primero y evalúalo con el segundo, que nunca vio durante el entrenamiento.

import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

housing = fetch_california_housing(as_frame=True)
X = housing.data
y = housing.target

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

modelo_lineal = LinearRegression()
modelo_lineal.fit(X_train, y_train)
y_pred = modelo_lineal.predict(X_test)

print(f"R² en test:   {r2_score(y_test, y_pred):.3f}")
print(f"RMSE en test: {np.sqrt(mean_squared_error(y_test, y_pred)):.3f}")

coeficientes = pd.Series(modelo_lineal.coef_, index=X.columns).sort_values()
print("\nCoeficientes del modelo:")
print(coeficientes)

print(f"\nCorrelación AveRooms-AveBedrms: {X['AveRooms'].corr(X['AveBedrms']):.2f}")

R² en test:   0.576
RMSE en test: 0.746

Coeficientes del modelo:
Longitude    -0.433708
Latitude     -0.419792
AveRooms     -0.123323
AveOccup     -0.003526
Population   -0.000002
HouseAge      0.009724
MedInc        0.448675
AveBedrms     0.783145
dtype: float64

Correlación AveRooms-AveBedrms: 0.85

El problema del sobreajuste y el compromiso sesgo-varianza

Para ver el sobreajuste con claridad, aléjate por un momento del dataset de 8 variables y mira un ejemplo con una sola variable, donde puedas graficar el ajuste directamente.

Imagina que la relación real entre y es una curva suave, pero solo tienes observaciones con ruido. Si ajustas:

• Un modelo demasiado simple (una recta) va a subajustar (underfitting): no captura la curva real. Esto es alto sesgo.
• Un modelo demasiado flexible (un polinomio de grado muy alto) va a memorizar el ruido de los puntos de entrenamiento. Esto es alta varianza: el modelo cambia mucho si cambian ligeramente los datos.

El objetivo es encontrar el punto intermedio donde el error en datos nuevos (no vistos durante el entrenamiento) es mínimo.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.pipeline import make_pipeline

# Datos sintéticos: una curva real + ruido
rng = np.random.default_rng(42)
x = np.sort(rng.uniform(0, 10, 60))
y_real = np.sin(x) * 3 + 0.3 * x
y = y_real + rng.normal(scale=1.0, size=x.shape)

X = x.reshape(-1, 1)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

grados = range(1, 16)
error_train, error_test = [], []

for grado in grados:
    # Escalar x antes de generar las potencias evita que las columnas de alto grado
    # exploten en magnitud y hagan inestable la solución de mínimos cuadrados.
    modelo = make_pipeline(StandardScaler(), PolynomialFeatures(grado), LinearRegression())
    modelo.fit(X_train, y_train)
    error_train.append(mean_squared_error(y_train, modelo.predict(X_train)))
    error_test.append(mean_squared_error(y_test, modelo.predict(X_test)))

fig, ax = plt.subplots(figsize=(7, 4.5))
ax.plot(list(grados), error_train, marker="o", label="Error de entrenamiento")
ax.plot(list(grados), error_test, marker="o", label="Error de prueba")
ax.set_xlabel("Grado del polinomio (complejidad del modelo)")
ax.set_ylabel("Error cuadrático medio")
ax.set_title("Compromiso sesgo-varianza: complejidad vs error")
ax.legend()
ax.grid(alpha=0.3)
plt.show()

grado_optimo = list(grados)[int(np.argmin(error_test))]
print(f"Grado con menor error de prueba: {grado_optimo} (MSE_test={min(error_test):.2f}, MSE_train={error_train[np.argmin(error_test)]:.2f})")
print(f"MSE de prueba en grado 12: {error_test[11]:.2f}")
print(f"MSE de entrenamiento en grado 15: {error_train[-1]:.2f} (el más bajo de toda la curva)")

Grado con menor error de prueba: 4 (MSE_test=0.50, MSE_train=0.90)
MSE de prueba en grado 12: 73.09
MSE de entrenamiento en grado 15: 0.32 (el más bajo de toda la curva)

Regularización Ridge (L2)

Ridge modifica la función de costo de la regresión lineal agregando una penalización proporcional a la suma de los coeficientes al cuadrado:

El hiperparámetro (alpha) controla la fuerza de la penalización:

• → Ridge es idéntico a la regresión lineal ordinaria.
• → todos los coeficientes se acercan a cero (el modelo se vuelve casi constante).

La intuición: Ridge encoge (shrinks) los coeficientes hacia cero, especialmente los de variables correlacionadas o poco informativas, sin llegar a eliminarlos por completo. Esto reduce la varianza del modelo a cambio de un poco de sesgo — justo el compromiso que viste arriba.

Para ver el efecto con claridad, genera un dataset sintético con variables informativas y variables que son puro ruido, y observa cómo cambian los coeficientes a medida que aumenta .

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge

# Dataset sintético: 10 variables, solo 4 realmente informativas
X, y, coef_real = make_regression(
    n_samples=200,
    n_features=10,
    n_informative=4,
    noise=10.0,
    coef=True,
    random_state=42,
)
X = StandardScaler().fit_transform(X)  # estandarizar es clave para regularizar

alphas = np.logspace(-2, 4, 50)
coeficientes_ridge = []

for alpha in alphas:
    modelo = Ridge(alpha=alpha)
    modelo.fit(X, y)
    coeficientes_ridge.append(modelo.coef_)

coeficientes_ridge = np.array(coeficientes_ridge)

fig, ax = plt.subplots(figsize=(7, 4.5))
for i in range(X.shape[1]):
    ax.plot(alphas, coeficientes_ridge[:, i], label=f"x{i+1}")
ax.set_xscale("log")
ax.set_xlabel("alpha (fuerza de regularización)")
ax.set_ylabel("Valor del coeficiente")
ax.set_title("Ridge: los coeficientes se encogen hacia cero, pero no lo alcanzan")
ax.legend(loc="upper right", fontsize=8, ncol=2)
ax.grid(alpha=0.3)
plt.show()

print(f"Variables realmente informativas (coeficiente ≠ 0 en la generación): {[f'x{i+1}' for i, c in enumerate(coef_real) if abs(c) > 0]}")
print(f"\nSuma de |coeficientes| en alpha={alphas[0]:.2f}: {np.sum(np.abs(coeficientes_ridge[0])):.1f}")
print(f"Suma de |coeficientes| en alpha={alphas[-1]:.0f}: {np.sum(np.abs(coeficientes_ridge[-1])):.1f}")
print(f"Coeficiente de x7 (el más grande, informativo) — alpha bajo: {coeficientes_ridge[0][6]:.2f}, alpha alto: {coeficientes_ridge[-1][6]:.2f}")

Variables realmente informativas (coeficiente ≠ 0 en la generación): ['x2', 'x5', 'x7', 'x10']

Suma de |coeficientes| en alpha=0.01: 91.7
Suma de |coeficientes| en alpha=10000: 2.1
Coeficiente de x7 (el más grande, informativo) — alpha bajo: 36.97, alpha alto: 0.80

Regularización Lasso (L1)

Lasso (Least Absolute Shrinkage and Selection Operator) usa una penalización distinta: la suma de los valores absolutos de los coeficientes.

La diferencia con Ridge parece sutil (cuadrado vs. valor absoluto), pero tiene una consecuencia geométrica importante: la región de penalización de Lasso tiene esquinas (sobre los ejes, donde algún coeficiente es exactamente cero), mientras que la de Ridge es una esfera suave. Eso hace que la solución óptima de Lasso “aterrice” con frecuencia exactamente sobre uno de esos ejes.

En la práctica, esto significa que Lasso no solo encoge coeficientes: los apaga por completo. Es, de facto, un método de selección automática de variables.

Usa el mismo dataset sintético de antes (10 variables, solo 4 informativas) para comprobarlo.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Lasso

X, y, coef_real = make_regression(
    n_samples=200,
    n_features=10,
    n_informative=4,
    noise=10.0,
    coef=True,
    random_state=42,
)
X = StandardScaler().fit_transform(X)

alphas = np.logspace(-2, 1.5, 50)
coeficientes_lasso = []

for alpha in alphas:
    modelo = Lasso(alpha=alpha, max_iter=10000)
    modelo.fit(X, y)
    coeficientes_lasso.append(modelo.coef_)

coeficientes_lasso = np.array(coeficientes_lasso)

fig, ax = plt.subplots(figsize=(7, 4.5))
for i in range(X.shape[1]):
    ax.plot(alphas, coeficientes_lasso[:, i], label=f"x{i+1}")
ax.set_xscale("log")
ax.set_xlabel("alpha (fuerza de regularización)")
ax.set_ylabel("Valor del coeficiente")
ax.set_title("Lasso: los coeficientes menos relevantes llegan exactamente a cero")
ax.legend(loc="upper right", fontsize=8, ncol=2)
ax.grid(alpha=0.3)
plt.show()

print("Variables informativas reales (coeficiente ≠ 0 en la generación):")
print([f"x{i+1}" for i, c in enumerate(coef_real) if abs(c) > 0])

Variables informativas reales (coeficiente ≠ 0 en la generación):
['x2', 'x5', 'x7', 'x10']

import numpy as np
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Lasso

X, y, coef_real = make_regression(
    n_samples=200,
    n_features=10,
    n_informative=4,
    noise=10.0,
    coef=True,
    random_state=42,
)
X = StandardScaler().fit_transform(X)

modelo_lasso = Lasso(alpha=1.0, max_iter=10000)
modelo_lasso.fit(X, y)

no_cero = np.sum(modelo_lasso.coef_ != 0)
print(f"Variables con coeficiente distinto de cero: {no_cero} de {X.shape[1]}")
print(f"Variables realmente informativas: {np.sum(np.abs(coef_real) > 0)}")

Variables con coeficiente distinto de cero: 4 de 10
Variables realmente informativas: 4

Comparación visual: sin regularizar vs. Ridge vs. Lasso

Ahora compara, lado a lado, los coeficientes que produce cada enfoque sobre el mismo dataset sintético, con un valor de fijo y razonable para cada uno.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso

X, y, coef_real = make_regression(
    n_samples=200,
    n_features=10,
    n_informative=4,
    noise=10.0,
    coef=True,
    random_state=42,
)
X = StandardScaler().fit_transform(X)

modelo_ols = LinearRegression().fit(X, y)
modelo_ridge = Ridge(alpha=10.0).fit(X, y)
modelo_lasso = Lasso(alpha=1.0, max_iter=10000).fit(X, y)

variables = [f"x{i+1}" for i in range(X.shape[1])]
ancho = 0.25
posiciones = np.arange(len(variables))

fig, ax = plt.subplots(figsize=(9, 5))
ax.bar(posiciones - ancho, modelo_ols.coef_, width=ancho, label="Sin regularizar (OLS)")
ax.bar(posiciones, modelo_ridge.coef_, width=ancho, label="Ridge (L2)")
ax.bar(posiciones + ancho, modelo_lasso.coef_, width=ancho, label="Lasso (L1)")
ax.set_xticks(posiciones)
ax.set_xticklabels(variables)
ax.set_ylabel("Valor del coeficiente")
ax.set_title("Coeficientes: OLS vs Ridge vs Lasso")
ax.axhline(0, color="black", linewidth=0.8)
ax.legend()
ax.grid(alpha=0.3, axis="y")
plt.show()

print(f"Coeficientes con |valor|>0.01 — OLS: {np.sum(np.abs(modelo_ols.coef_)>0.01)}, Ridge: {np.sum(np.abs(modelo_ridge.coef_)>0.01)}, Lasso: {np.sum(modelo_lasso.coef_ != 0)}")
print(f"Suma de |coeficientes|      — OLS: {np.sum(np.abs(modelo_ols.coef_)):.1f}, Ridge: {np.sum(np.abs(modelo_ridge.coef_)):.1f}, Lasso: {np.sum(np.abs(modelo_lasso.coef_)):.1f}")
print(f"Coeficiente de x4 (irrelevante, coef_real=0) — OLS: {modelo_ols.coef_[3]:.2f}, Ridge: {modelo_ridge.coef_[3]:.2f}, Lasso: {modelo_lasso.coef_[3]:.2f}")

Coeficientes con |valor|>0.01 — OLS: 10, Ridge: 10, Lasso: 4
Suma de |coeficientes|      — OLS: 91.7, Ridge: 87.6, Lasso: 83.9
Coeficiente de x4 (irrelevante, coef_real=0) — OLS: 1.10, Ridge: 1.05, Lasso: 0.00

Cierre técnico: ¿cuándo usar cada una?

En la práctica, el valor de no se elige a mano: se selecciona con validación cruzada (RidgeCV, LassoCV en scikit-learn), probando un rango de valores y quedándote con el que minimiza el error en datos de validación. Ese será tema de un próximo artículo de la serie, dedicado a evaluación de modelos y bootstrap.

Un último punto práctico: tanto Ridge como Lasso son sensibles a la escala de las variables — por eso, en todos los ejemplos de este artículo, se estandarizaron los datos con StandardScaler antes de ajustar el modelo. Si te saltas ese paso, las variables con escalas más grandes quedan penalizadas de forma desproporcionada respecto a las demás.