Qué es, cuándo utilizarla y cómo aplicarla en Data Science

La transformación logarítmica es una de las técnicas de preprocesamiento de datos más utilizadas en Ciencia de Datos, Estadística y Machine Learning. Su principal objetivo es modificar la distribución de una variable para facilitar el análisis, mejorar el comportamiento de ciertos algoritmos y reducir el impacto de valores extremos.

Aunque puede parecer un concepto matemático complejo, la realidad es que la transformación logarítmica es una herramienta práctica que ayuda a resolver problemas muy comunes en datasets reales, especialmente cuando trabajamos con variables altamente asimétricas o con rangos de valores extremadamente amplios.

¿Qué es una transformación logarítmica?

Una transformación logarítmica consiste en reemplazar los valores originales de una variable por sus logaritmos. La forma más habitual es:

Donde:

• \(x\) es el valor original.
• \(y\) es el valor transformado.

El efecto principal es comprimir las diferencias entre valores grandes mientras se conservan las relaciones entre observaciones.

¿Por qué se utiliza?

Muchos fenómenos reales no crecen de forma lineal. Por ejemplo:

• Ingresos de personas.
• Valor de viviendas.
• Número de visitas a una web.
• Ventas de productos.
• Seguidores en redes sociales.

En estos casos suelen existir muchos valores pequeños y unos pocos valores extremadamente grandes. La diferencia entre ellos puede dominar completamente el análisis. La transformación logarítmica reduce esta desproporción.

Cómo Funciona el Logaritmo

Supongamos que utilizamos logaritmos en base 10:

Observa que:

10 → 100
Multiplicación ×10

100 → 1.000
Multiplicación ×10

10 → 100
Multiplicación ×10

100 → 1.000
Multiplicación ×10

Pero tras aplicar el logaritmo:

1 → 2
Incremento +1

2 → 3
Incremento +1

1 → 2
Incremento +1

2 → 3
Incremento +1

El logaritmo transforma relaciones multiplicativas en relaciones aditivas.

Reducción de la Asimetría

Uno de los usos más importantes de la transformación logarítmica es reducir la asimetría de una distribución. Muchas variables presentan una larga cola hacia la derecha. La transformación suele producir una distribución más equilibrada que facilita tanto el análisis estadístico como el entrenamiento de modelos.

Reducción del Impacto de los Outliers

Otra ventaja importante es la reducción de la influencia de valores extremos.

ventas = [100, 120, 150, 180, 1000]

ventas = [100, 120, 150, 180, 1000]

El valor 10.000 domina completamente la escala. Aplicando logaritmos:

ventas_log = [4.61, 4.79, 5.01, 5.19, 9.21]

ventas_log = [4.61, 4.79, 5.01, 5.19, 9.21]

La diferencia sigue existiendo, pero es mucho menos extrema.

Mejora de la Relación Lineal

Muchos algoritmos funcionan mejor cuando existe una relación aproximadamente lineal entre variables. Como por ejemplo entre publicidad y ventas. A menudo esta relación es exponencial y aplicando logaritmos, la relación puede volverse más lineal y resultar más fácil de modelar.

Cuándo Utilizar una Transformación Logarítmica

La transformación logarítmica suele ser recomendable cuando:

• Existe una fuerte asimetría positiva: por ejemplo, en ingresos, ventas, número de usuarios.
• Existen valores extremos: cuando unos pocos registros son mucho mayores que el resto.
• La variable cubre varios órdenes de magnitud: por ejemplo, [10, 100, 1000, 10000, 10000000]
• Se desea estabilizar la varianza: algunos modelos estadísticos asumen una varianza relativamente constante. La transformación logarítmica puede ayudar a cumplir esta condición.

Cuándo NO Utilizarla

No siempre es una buena idea usarla en:

• Distribuciones ya equilibradas: Si la variable ya presenta una distribución aproximadamente normal, la transformación puede empeorar los resultados.
• Variables categóricas: No tiene sentido aplicar logaritmos a este tipo de variables.
• Variables con interpretación directa: En algunos casos la transformación dificulta la interpretación de los resultados.

El Problema del Cero

Los logaritmos presentan una limitación importante, hallar el logaritmo de cero np.log(0) produce un error matemático. Una práctica habitual consiste en utilizar:

$y=\log(x+1)$

Esto permite transformar variables que contienen ceros. Es una de las transformaciones más utilizadas en Machine Learning.

Aplicación en Machine Learning

La transformación logarítmica puede utilizarse durante la fase de preparación de datos para:

• Regresión Lineal.
• Regresión Ridge.
• Regresión Lasso.
• Árboles de decisión.
• Random Forest.
• Gradient Boosting.
• Redes neuronales.

Aunque los modelos basados en árboles son menos sensibles a la escala de los datos, la transformación puede seguir siendo útil para mejorar la calidad de la información.

Transformar la Variable Objetivo

En ocasiones no solo se transforman las variables predictoras. También puede transformarse la variable objetivo. El modelo aprende sobre la variable transformada y posteriormente las predicciones pueden volver a la escala original mediante la función exponencial.

Implementación en Python

Utilizando NumPy

import numpy as np

df["ventas_log"] = np.log(df["ventas"])

import numpy as np

df["ventas_log"] = np.log(df["ventas"])

Cuando Existen Ceros

import numpy as np

df["ventas_log"] = np.log1p(df["ventas"])

import numpy as np

df["ventas_log"] = np.log1p(df["ventas"])

Visualización Antes y Después

import matplotlib.pyplot as plt

df["ventas"].hist()

plt.show()

df["ventas_log"].hist()

plt.show()

import matplotlib.pyplot as plt

df["ventas"].hist()

plt.show()

df["ventas_log"].hist()

plt.show()

Esto permite observar cómo cambia la distribución tras la transformación.

Ventajas de la Transformación Logarítmica

• Reduce la asimetría de los datos.
• Disminuye el impacto de valores extremos.
• Facilita el modelado de relaciones no lineales.
• Puede mejorar el rendimiento de algunos algoritmos.
• Ayuda a estabilizar la varianza.

Limitaciones

• No funciona directamente con valores negativos.
• Requiere tratamiento especial para los ceros.
• Puede dificultar la interpretación de resultados.
• No siempre mejora el rendimiento del modelo.

Una de las métricas más utilizadas por su simplicidad e interpretación intuitiva es el Error Absoluto Medio (Mean Absolute Error o MAE). Esta métrica calcula el error promedio cometido por un modelo sin penalizar especialmente los errores grandes, proporcionando una medida fácil de comprender y comunicar.

¿Qué es el MAE?

El Error Absoluto Medio mide la diferencia promedio entre los valores reales y las predicciones realizadas por el modelo.

Para calcularlo:

1. Se obtiene la diferencia entre el valor real y el valor predicho.
2. Se toma el valor absoluto de cada diferencia.
3. Se calcula la media de todos los errores absolutos.

Su fórmula es:

$$MAE=\frac{1}{n}\sum_{i=1}^{n}|y_i-\hat{y}_i|$$

Donde:

• n = número de observaciones.
• yᵢ = valor real.
• ŷᵢ = valor predicho.
• |yᵢ − ŷᵢ| = error absoluto.

¿Por Qué Utiliza Valores Absolutos?

Supongamos que tenemos dos predicciones:

Si calculáramos la media de los errores:

$$\frac{10 + (-10)}{2}=0$$

Obtendríamos un error promedio igual a cero, lo cual sería incorrecto. Al utilizar el valor absoluto, ambos errores contribuyen positivamente al resultado final.

$$|10| = 10$$

$$|-10| = 10$$

Cómo Interpretar el MAE

La principal ventaja del MAE es su facilidad de interpretación. El resultado se expresa en las mismas unidades que la variable objetivo. Por ejemplo: Si estamos prediciendo precios de viviendas en miles de euros:

MAE = 15

MAE = 15

significa que el modelo se equivoca aproximadamente en 15 mil euros por predicción. Si estamos prediciendo ventas:

MAE = 50

MAE = 50

significa que las predicciones presentan un error promedio de 50 unidades.

Ventajas del MAE

• Interpretación sencilla: El resultado se expresa en las mismas unidades de la variable objetivo. Esto facilita enormemente la comunicación de resultados a usuarios de negocio.
• Fácil de calcular: Su fórmula es simple y computacionalmente eficiente.
• Menor sensibilidad a valores atípicos: A diferencia del MSE, el MAE no eleva los errores al cuadrado. Por tanto, los errores extremos tienen menos influencia sobre la métrica.
• Robusto frente a Outliers: Cuando el conjunto de datos contiene valores atípicos, el MAE suele proporcionar una visión más estable del rendimiento general del modelo.

Limitaciones del MAE

• No penaliza especialmente los errores grandes: Todos los errores contribuyen de forma proporcional. Esto puede resultar problemático en situaciones donde los errores grandes tienen un coste elevado.
• Puede ocultar errores extremos: Dos modelos pueden tener el mismo MAE aunque uno de ellos cometa errores muy grandes en algunas observaciones. Por este motivo suele utilizarse junto con otras métricas.

Comparación entre MAE y MSE

¿Cuándo utilizar MAE?

El MAE suele ser una buena elección cuando:

• Queremos una métrica fácil de interpretar.
• Los errores grandes no son especialmente críticos.
• Existen valores atípicos en los datos.
• Necesitamos comunicar resultados a perfiles no técnicos.

Es especialmente frecuente en:

• Predicción de ventas.
• Forecasting de demanda.
• Estimación de precios.
• Modelos financieros.
• Analítica empresarial.

Cálculo del MAE en Python

Scikit-Learn proporciona la función mean_absolute_error() para calcular esta métrica.

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_test, y_pred)

print(f"MAE: {mae:.2f}")

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_test, y_pred)

print(f"MAE: {mae:.2f}")

Ejemplo Completo

from sklearn.metrics import mean_absolute_error

y_true = [100, 150, 200]
y_pred = [90, 160, 180]

mae = mean_absolute_error(y_true, y_pred)

print(mae)

from sklearn.metrics import mean_absolute_error

y_true = [100, 150, 200]
y_pred = [90, 160, 180]

mae = mean_absolute_error(y_true, y_pred)

print(mae)

13.33

13.33

Esto significa que las predicciones se desvían en promedio aproximadamente 13.33 unidades respecto a los valores reales.

MAE vs RMSE

Las dos métricas suelen utilizarse juntas.

El MAE proporciona una visión del error medio general, mientras que el RMSE permite detectar si existen errores especialmente grandes que puedan estar afectando al modelo.

Conclusión

El Error Absoluto Medio (MAE) es una de las métricas más utilizadas para evaluar modelos de regresión debido a su simplicidad y facilidad de interpretación. Al medir el promedio de los errores absolutos, proporciona una estimación clara de cuánto se desvían las predicciones respecto a los valores reales. A diferencia del MSE, no penaliza excesivamente los errores grandes, lo que lo convierte en una opción robusta cuando existen valores atípicos o cuando se busca una métrica comprensible para usuarios de negocio. Por este motivo, el MAE suele formar parte del conjunto básico de métricas utilizadas para evaluar y comparar modelos de Machine Learning.

La Base para Evaluar Modelos de Machine Learning

Uno de los objetivos fundamentales de cualquier proyecto de Machine Learning es construir modelos capaces de generalizar correctamente sobre datos que nunca han visto. Para conseguirlo utilizamos técnicas como el Train/Test Split, reservando una parte de los datos para evaluar el rendimiento real del modelo.

El Train/Test Split es el proceso mediante el cual dividimos nuestro conjunto de datos en dos partes:

• Conjunto de entrenamiento (Training Set)
• Conjunto de prueba (Test Set)

El conjunto de entrenamiento se utiliza para que el algoritmo aprenda los patrones presentes en los datos. El conjunto de prueba se reserva y permanece oculto durante el entrenamiento. Solo se utiliza al final para evaluar el rendimiento real del modelo.

La idea es simular una situación del mundo real. Entrenamos con datos históricos y evaluamos con datos que el modelo nunca ha visto.

El Objetivo Real del Machine Learning

Muchas personas creen que el objetivo del Machine Learning es obtener el mejor rendimiento posible sobre los datos disponibles. En realidad, el objetivo es diferente. El objetivo es construir modelos capaces de generalizar correctamente sobre datos que nunca han visto. Por eso la evaluación debe realizarse utilizando información que haya permanecido completamente separada durante el entrenamiento.

El flujo básico es el siguiente:

1. Datos originales: Disponemos de un conjunto de datos completo.
2. División de los datos: Separamos los datos en dos conjuntos: Train Set y Test Set
3. Paso 3: Entrenamiento: El modelo aprende exclusivamente utilizando el conjunto de entrenamiento: Train Set → Modelo
4. Paso 4: Evaluación: Una vez entrenado, el modelo realiza predicciones sobre el conjunto de prueba. Modelo → Predicciones → Test Set

El Papel del Conjunto de Entrenamiento

Tras realizar la división de datos obtenemos cuatro elementos principales:

X_train → Variables predictoras para entrenamiento
X_test → Variables predictoras para evaluación

y_train → Variable objetivo para entrenamiento
y_test → Variable objetivo para evaluación

X_train → Variables predictoras para entrenamiento
X_test → Variables predictoras para evaluación

y_train → Variable objetivo para entrenamiento
y_test → Variable objetivo para evaluación

Donde:

• X representa las características o variables independientes.
• y representa la variable objetivo que queremos predecir.

Durante el entrenamiento, el modelo utilizará las variables de X_train junto con los valores reales contenidos en y_train para aprender los patrones existentes en los datos.

El Método Fit()

En Scikit-Learn, el aprendizaje del modelo se realiza mediante el método fit().

model.fit(X_train, y_train)

model.fit(X_train, y_train)

Durante esta fase:

1. El algoritmo analiza los datos.
2. Aprende la relación entre las variables predictoras y la variable objetivo.
3. Calcula los parámetros internos necesarios para realizar futuras predicciones.

Por ejemplo, en una regresión lineal el algoritmo aprenderá los coeficientes de la ecuación. En un árbol de decisión aprenderá las reglas de partición. En una red neuronal ajustará miles o millones de pesos internos.

Proporciones Habituales de División

No existe una única división correcta. Las más utilizadas son:

Regla general: cuanto más pequeño sea el dataset, mayor suele ser el porcentaje destinado al entrenamiento. Cuanto más grande sea el dataset, más sencillo resulta reservar una proporción mayor para pruebas sin afectar significativamente al aprendizaje del modelo.

¿Qué es la generalización?

La generalización es la capacidad de un modelo para funcionar correctamente sobre datos nuevos. Es probablemente el concepto más importante de todo Machine Learning. Un modelo que memoriza los datos de entrenamiento no es útil. Un modelo útil es aquel que:

• Aprende patrones generales.
• Mantiene un buen rendimiento fuera de la muestra.

El Test Set existe precisamente para medir esta capacidad. No debemos mezclar observaciones futuras con observaciones pasadas. La división correcta suele respetar el orden cronológico. De lo contrario, estaríamos introduciendo información futura durante el entrenamiento.

¿Qué significa que el modelo “aprende”?

Cuando hablamos de aprendizaje en Machine Learning nos referimos al proceso mediante el cual el algoritmo encuentra patrones en los datos históricos. El objetivo es identificar relaciones que puedan utilizarse posteriormente para realizar predicciones sobre nuevos datos. El resultado de este proceso es un modelo entrenado.

Generación de Predicciones

Una vez entrenado el modelo, podemos utilizarlo para realizar predicciones sobre observaciones que nunca ha visto. En Scikit-Learn esto se realiza mediante el método predict().

y_pred = model.predict(X_test)

y_pred = model.predict(X_test)

El modelo recibe las variables del conjunto de prueba y genera una predicción para cada observación. Estas predicciones se almacenan en y_pred.

Comparando Predicciones con Valores Reales

La ventaja del conjunto de prueba es que conocemos los valores reales. Por tanto podemos comparar: y_test contra y_pred. Esta comparación permite medir el rendimiento real del modelo. Es precisamente aquí donde entran en juego las métricas de evaluación.

Cálculo del Error del Modelo

Dependiendo del tipo de problema utilizaremos métricas diferentes.

Problemas de Regresión

Cuando la variable objetivo es numérica:

• MAE (Mean Absolute Error)
• MSE (Mean Squared Error)
• RMSE (Root Mean Squared Error)
• R² (Coefficient of Determination)

Problemas de Clasificación

Cuando la variable objetivo es categórica:

• Accuracy
• Precision
• Recall
• F1 Score
• ROC-AUC

Este proceso constituye la base de prácticamente todos los proyectos de Machine Learning modernos.

Flujo de entrenamiento y evaluación de un modelo

Implementación Completa en Python

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# División de datos
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

# Crear modelo
model = LinearRegression()

# Entrenar modelo
model.fit(X_train, y_train)

# Generar predicciones
y_pred = model.predict(X_test)

# Evaluar rendimiento
mse = mean_squared_error(y_test, y_pred)

print(f"MSE: {mse:.2f}")

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# División de datos
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

# Crear modelo
model = LinearRegression()

# Entrenar modelo
model.fit(X_train, y_train)

# Generar predicciones
y_pred = model.predict(X_test)

# Evaluar rendimiento
mse = mean_squared_error(y_test, y_pred)

print(f"MSE: {mse:.2f}")

Data Leakage: El Error Silencioso que Puede Invalidar un Modelo de Machine Learning

Uno de los objetivos fundamentales de cualquier proyecto de Machine Learning es construir modelos capaces de generalizar correctamente sobre datos que nunca han visto. Para conseguirlo utilizamos técnicas como el Train/Test Split, reservando una parte de los datos para evaluar el rendimiento real del modelo.

Sin embargo, existe un problema que puede hacer que nuestras métricas parezcan excelentes mientras que el modelo fracasa cuando llega a producción. Este problema recibe el nombre de Data Leakage o fuga de información y es una de las causas más comunes de resultados excesivamente optimistas en Machine Learning.

Comprender qué es el Data Leakage, cómo se produce y cómo evitarlo es esencial para construir modelos fiables y obtener evaluaciones realistas.

¿Qué es el Data Leakage?

El Data Leakage ocurre cuando información que debería permanecer oculta durante el entrenamiento termina llegando al modelo de forma directa o indirecta. En otras palabras: El modelo recibe pistas sobre los datos de prueba antes de ser evaluado.

Como consecuencia:

• El modelo aprende información que no debería conocer.
• Las métricas de evaluación se inflan artificialmente.
• El rendimiento real en producción suele ser mucho peor de lo esperado.

¿Por qué es un problema?

Supongamos que queremos predecir el precio de una vivienda. Disponemos de un conjunto de datos histórico y realizamos un Train/Test Split. La idea es que:

Train Set → Aprendizaje
Test Set → Evaluación

Train Set → Aprendizaje
Test Set → Evaluación

El Test Set debe representar información completamente nueva. Si el modelo tiene acceso, aunque sea parcialmente, a información procedente del conjunto de prueba, la evaluación deja de ser objetiva. Las métricas obtenidas ya no reflejan la capacidad real de generalización.

La Relación Entre Data Leakage y Train/Test Split

El propósito del Train/Test Split es simular una situación real. Entrenamos con datos históricos y posteriormente evaluamos el modelo sobre datos que nunca ha visto. Para que esta simulación sea válida, ambos conjuntos deben permanecer completamente independientes. Cuando esta independencia se rompe aparece el Data Leakage.

Un Ejemplo Sencillo

Imaginemos que queremos predecir la recaudación de películas. Disponemos de variables como:

• Presupuesto.
• Duración.
• Género.
• Popularidad de los actores.

Si entrenamos el modelo utilizando todo el dataset y después evaluamos sobre esos mismos registros, podríamos obtener resultados aparentemente perfectos. Sin embargo, el modelo no está aprendiendo patrones generales, está memorizando ejemplos concretos. Por tanto, las métricas no representan el rendimiento sobre datos nuevos.

El Caso Más Común: Transformaciones Antes del Split

Uno de los errores más frecuentes consiste en aplicar transformaciones sobre todo el dataset antes de dividir los datos. Por ejemplo:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(
    X_scaled,
    y,
    test_size=0.2
)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(
    X_scaled,
    y,
    test_size=0.2
)

Aunque parece correcto, existe un problema. El escalador ha calculado la media y la desviación estándar utilizando tanto el Train Set como el Test Set. Por tanto, durante el entrenamiento ya se ha utilizado información procedente del conjunto de prueba.

La forma correcta: primero se divide el dataset:

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

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

Después se ajusta la transformación utilizando únicamente el conjunto de entrenamiento.

scaler = StandardScaler()
scaler.fit(X_train)

scaler = StandardScaler()
scaler.fit(X_train)

Y finalmente se aplica a ambos conjuntos.

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

De esta forma, el modelo nunca tiene acceso a información procedente del Test Set.

Otros Casos Frecuentes de Data Leakage

Imputación de Valores Nulos

# Incorrecto:
imputer.fit(X)

# Correcto
imputer.fit(X_train)

# Incorrecto:
imputer.fit(X)

# Correcto
imputer.fit(X_train)

Normalización

Incorrecto:

# Incorrecto:
scaler.fit(X)

# Correcto
scaler.fit(X_train)

# Incorrecto:
scaler.fit(X)

# Correcto
scaler.fit(X_train)

One-Hot Encoding

# Incorrecto:
encoder.fit(X)

# Correcto
encoder.fit(X_train)

# Incorrecto:
encoder.fit(X)

# Correcto
encoder.fit(X_train)

Selección de Variables

# Incorrecto:
selector.fit(X, y)

# Correcto
selector.fit(X_train, y_train)

# Incorrecto:
selector.fit(X, y)

# Correcto
selector.fit(X_train, y_train)

PCA

# Incorrecto:
pca.fit(X)

# Correcto
pca.fit(X_train)

# Incorrecto:
pca.fit(X)

# Correcto
pca.fit(X_train)

Una Regla Fácil de Recordar

Existe una regla muy útil: Todo objeto que utilice el método .fit() debe aprender únicamente del conjunto de entrenamiento. Esto incluye:

• Scalers.
• Encoders.
• Imputadores.
• PCA.
• Selectores de variables.
• Modelos de Machine Learning.

Si un componente necesita ejecutar un .fit(), debe hacerlo exclusivamente utilizando el Train Set.

Cómo Detectar un Posible Data Leakage

Algunas señales de alerta son:

• Accuracy extremadamente alta.
• R² inusualmente elevado.
• Error casi nulo.
• Diferencias muy grandes entre entorno de pruebas y producción.

Cuando las métricas parecen demasiado buenas para ser ciertas, conviene revisar cuidadosamente posibles fugas de información.

Data Leakage en Series Temporales

En problemas temporales el riesgo es todavía mayor. Por ejemplo:

• Predicción bursátil.
• Forecasting de ventas.
• Predicción meteorológica.

Un error habitual consiste en utilizar información futura durante el entrenamiento. Si mezclamos registros futuros con registros pasados, el modelo aprende patrones imposibles de conocer en una situación real. Por esta razón las series temporales requieren estrategias de validación específicas que respeten el orden cronológico.

Buenas Prácticas para Evitar Data Leakage

• Dividir antes de transformar: Siempre: Split → Fit → Transform
• Mantener independencia entre conjuntos: El Test Set debe permanecer aislado hasta la fase final de evaluación.
• Utilizar Pipelines: Los pipelines de Scikit-Learn ayudan a evitar errores de procesamiento. Permiten garantizar que cada transformación aprende únicamente a partir del conjunto de entrenamiento.
• Desconfiar de resultados excesivamente buenos: Cuando las métricas parecen perfectas, conviene revisar cuidadosamente el flujo de datos.

Errores Comunes

• Evaluar con datos de entrenamiento: produce resultados engañosamente buenos.
• Realizar transformaciones antes de dividir: por ejemplo, escalado, normalización, imputación. Estas transformaciones deben aprenderse utilizando únicamente el Train Set. Está directamente relacionado con el problema de Data Leakage (fuga de información).
• Utilizar el Test Set repetidamente: Cada vez que modificamos el modelo basándonos en el Test Set estamos filtrando información. Con el tiempo, el conjunto de prueba deja de ser independiente.
• Ignorar el desbalanceo de clases: En clasificación puede ser necesario utilizar particiones estratificadas para mantener la proporción de clases.

Relación con la Validación Cruzada

El Train/Test Split suele ser el primer paso. Posteriormente pueden utilizarse técnicas más avanzadas como:

• K-Fold Cross Validation.
• Stratified K-Fold.
• Time Series Split.

Estas técnicas proporcionan estimaciones más robustas del rendimiento del modelo. Sin embargo, incluso cuando utilizamos validación cruzada, suele mantenerse un conjunto de prueba final completamente independiente.

Conclusión

El Train/Test Split es una de las etapas más importantes de cualquier proyecto de Machine Learning. Su objetivo es garantizar que la evaluación del modelo se realiza sobre datos que no han participado en el entrenamiento, permitiendo medir de forma realista su capacidad de generalización. Esta práctica constituye la base sobre la que se apoyan todas las metodologías modernas de evaluación de modelos y resulta imprescindible tanto en problemas de regresión como de clasificación, Deep Learning o sistemas de recomendación. Comprender cómo dividir correctamente los datos y evitar fugas de información es uno de los primeros pasos para construir modelos fiables y útiles en entornos reales.

Cómo Medir la Capacidad Explicativa de un Modelo de Regresión

Cuando desarrollamos un modelo de regresión, una de las preguntas más importantes es: ¿qué tan bien explica el modelo los datos observados?. Aunque métricas como el Error Cuadrático Medio (MSE) o el Error Absoluto Medio (MAE) nos indican cuánto se equivoca un modelo en sus predicciones, no nos dicen qué proporción de la información presente en los datos ha sido realmente capturada.

Para responder a esta cuestión utilizamos el coeficiente de determinación, más conocido como R², una de las métricas más utilizadas en Machine Learning, estadística y ciencia de datos para evaluar modelos de regresión.

¿Qué es el coeficiente de determinación?

El coeficiente de determinación mide qué porcentaje de la variabilidad de la variable objetivo puede ser explicado por el modelo. Dicho de forma más sencilla: R² nos indica cuánto mejor es nuestro modelo que una predicción basada únicamente en la media de los datos. Si un modelo logra explicar gran parte de las variaciones observadas, tendrá un valor de R² elevado. Si apenas encuentra patrones útiles, el valor será bajo.

La Idea Intuitiva Detrás del R²

Imaginemos que queremos predecir el precio de viviendas. Supongamos que el precio medio de todas las viviendas del conjunto de datos es de 250.000 €. Una estrategia extremadamente simple sería ignorar todas las características de las viviendas y predecir siempre: 250.000€ para cualquier casa.

Obviamente, esta estrategia produciría errores importantes. Ahora entrenamos un modelo utilizando variables como: metros cuadrados, número de habitaciones, ubicación, antigüedad, etc. Si el modelo consigue reducir significativamente esos errores, significa que está explicando parte de la variabilidad presente en los precios. El R² cuantifica precisamente cuánto ha mejorado el modelo respecto a utilizar únicamente la media.

Variabilidad Total y Variabilidad Residual

Para entender cómo se calcula R² es necesario distinguir dos conceptos fundamentales.

Variabilidad Total

Representa toda la dispersión existente en la variable objetivo respecto a su media. Por ejemplo, si los precios de las viviendas varían entre 100.000 € y 800.000 €, existe una gran variabilidad que el modelo intentará explicar. La variabilidad total se calcula mediante la Suma Total de Cuadrados (SST):

$$SST=\sum_{i=1}^{n}(y_i-\bar{y})^2$$

Donde:

• \(y_i\) es cada valor real.
• \(\bar{y}\) es la media de todos los valores.

Variabilidad Residual

Una vez entrenado el modelo, siempre existirá cierta diferencia entre las predicciones y los valores reales. Esa parte que el modelo no consigue explicar se conoce como variabilidad residual; cuanto menor sea esta cantidad, mejor será el ajuste. Se calcula mediante la Suma de Cuadrados Residuales (SSE):

$$SSE=\sum_{i=1}^{n}(y_i-\hat{y}_i)^2$$

Donde:

• \(y_i\) es el valor real.
• \(\hat{y}_i\) es la predicción del modelo.

Fórmula del Coeficiente de Determinación

El R² compara la variabilidad residual con la variabilidad total. Su fórmula es:

$$R^2=1-\frac{SSE}{SST}$$

Por tanto, mide la proporción de información que el modelo ha conseguido capturar.

Interpretación de los Valores de R²

• R² = 0: El modelo no explica absolutamente nada. Tiene el mismo rendimiento que predecir siempre la media de los datos.
• R² = 0.30: El modelo explica aproximadamente el 30% de la variabilidad observada. El 70% restante permanece sin explicar.
• R² = 0.70: El modelo explica el 70% de la variación presente en los datos. Generalmente se considera un resultado bastante sólido en muchos problemas reales.
• R² = 1: El modelo explica el 100% de la variabilidad. Todas las observaciones son predichas perfectamente. Aunque pueda parecer ideal, en algunos casos puede indicar sobreajuste (overfitting), especialmente cuando se evalúa sobre los mismos datos utilizados para entrenar.

Ventajas

• Fácil de interpretar: Expresa directamente la proporción de información explicada por el modelo.
• Permite comparar modelos: Es muy útil para evaluar diferentes algoritmos o configuraciones.
• Independiente de las unidades: A diferencia del MSE o RMSE, el R² no depende de la escala de la variable objetivo. Puede utilizarse para comparar problemas distintos.

Limitaciones

Aunque es una métrica muy popular, también tiene limitaciones importantes.

• No mide directamente el error: Dos modelos pueden tener valores de R² similares y errores muy diferentes. Por ello suele combinarse con métricas como:
  • MAE
  • MSE
  • RMSE
• Puede aumentar al añadir variables irrelevantes: Una característica importante es que el R² nunca disminuye al incorporar nuevas variables al modelo. Incluso variables sin valor predictivo pueden provocar un ligero aumento. Por esta razón, utilizar únicamente R² puede conducir a conclusiones equivocadas.
• No garantiza causalidad: Un valor elevado de R² no implica que exista una relación causal entre las variables. Simplemente indica que existe una relación estadística capaz de explicar parte de la variabilidad observada. Para solucionar el problema de añadir variables innecesarias, se utiliza el R² Ajustado (Adjusted R²).

Cálculo del Coeficiente de Determinación (R²) en Python

La biblioteca Scikit-Learn incorpora funciones que permiten calcular el coeficiente de determinación de forma sencilla. Una vez entrenado un modelo y generadas las predicciones, podemos evaluar su capacidad explicativa utilizando la función r2_score().

Supongamos que disponemos de los valores reales y las predicciones generadas por nuestro modelo:

from sklearn.metrics import r2_score

# Valores reales
y_true = [100, 150, 200, 250, 300]

# Predicciones del modelo
y_pred = [110, 140, 195, 260, 290]

# Calcular R²
r2 = r2_score(y_true, y_pred)

print(f"R²: {r2:.4f}")

from sklearn.metrics import r2_score

# Valores reales
y_true = [100, 150, 200, 250, 300]

# Predicciones del modelo
y_pred = [110, 140, 195, 260, 290]

# Calcular R²
r2 = r2_score(y_true, y_pred)

print(f"R²: {r2:.4f}")

R²: 0.9850

R²: 0.9850

Esto indica que el modelo explica aproximadamente el 98,5% de la variabilidad presente en los datos.

Cálculo tras entrenar un modelo

En un flujo de trabajo típico de Machine Learning, primero entrenamos el modelo y posteriormente calculamos el R² sobre el conjunto de prueba.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

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

# Crear modelo
model = LinearRegression()

# Entrenar
model.fit(X_train, y_train)

# Realizar predicciones
y_pred = model.predict(X_test)

# Calcular R²
r2 = r2_score(y_test, y_pred)

print(f"R² Score: {r2:.4f}")

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

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

# Crear modelo
model = LinearRegression()

# Entrenar
model.fit(X_train, y_train)

# Realizar predicciones
y_pred = model.predict(X_test)

# Calcular R²
r2 = r2_score(y_test, y_pred)

print(f"R² Score: {r2:.4f}")

Utilizando el método .score()

Muchos modelos de regresión en Scikit-Learn incluyen directamente el cálculo de R² mediante el método .score().

from sklearn.linear_model import LinearRegression

model = LinearRegression()

model.fit(X_train, y_train)

r2 = model.score(X_test, y_test)

print(f"R² Score: {r2:.4f}")

from sklearn.linear_model import LinearRegression

model = LinearRegression()

model.fit(X_train, y_train)

r2 = model.score(X_test, y_test)

print(f"R² Score: {r2:.4f}")

Internamente, este método devuelve exactamente el mismo resultado que r2_score() para modelos de regresión.

Comparando Varios Modelos

Una práctica habitual consiste en entrenar varios algoritmos y comparar sus valores de R² para seleccionar el modelo con mayor capacidad explicativa.

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import r2_score

models = {
    "Linear Regression": LinearRegression(),
    "Random Forest": RandomForestRegressor(random_state=42)
}

for name, model in models.items():

    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)

    r2 = r2_score(y_test, y_pred)

    print(f"{name}: R² = {r2:.4f}")

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import r2_score

models = {
    "Linear Regression": LinearRegression(),
    "Random Forest": RandomForestRegressor(random_state=42)
}

for name, model in models.items():

    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)

    r2 = r2_score(y_test, y_pred)

    print(f"{name}: R² = {r2:.4f}")

Este enfoque permite comparar objetivamente distintos modelos y seleccionar aquel que mejor explica la variabilidad de los datos.

¿Qué se considera un buen R²?

No existe un valor universal. Depende del problema y del contexto de negocio. Por ejemplo:

Sin embargo, en problemas complejos como economía, comportamiento humano o mercados financieros, valores de R² relativamente modestos pueden seguir siendo extremadamente útiles.

R² Ajustado: Corrigiendo una de sus Limitaciones

Para solucionar el problema de añadir variables innecesarias, se utiliza el R² Ajustado (Adjusted R²). Esta métrica introduce una penalización cuando se agregan variables que no aportan información relevante. Por ello resulta especialmente útil en modelos con múltiples variables predictoras. Mientras que el R² tradicional tiende a aumentar al añadir variables, el R² ajustado puede disminuir si esas variables no mejoran realmente el modelo.

Aunque el coeficiente de determinación (R²) es una métrica muy útil para medir la capacidad explicativa de un modelo, presenta una limitación importante: nunca disminuye cuando añadimos nuevas variables predictoras. Incluso si una variable no aporta información relevante, el valor de R² puede mantenerse igual o aumentar ligeramente, dando la impresión de que el modelo ha mejorado.

Para corregir este problema se utiliza el R² Ajustado (Adjusted R²), una versión modificada del coeficiente de determinación que penaliza la incorporación de variables innecesarias.

¿Por qué necesitamos el R² Ajustado?

Supongamos que estamos construyendo un modelo para predecir el precio de una vivienda. Inicialmente utilizamos variables como:

• Metros cuadrados.
• Número de habitaciones.
• Antigüedad de la vivienda.

Posteriormente añadimos una nueva variable:

• Número de letras del nombre del propietario.

Esta última variable no tiene ninguna relación real con el precio de una vivienda. Sin embargo, el R² tradicional podría aumentar ligeramente simplemente por haber añadido una nueva característica al modelo. El problema es que el R² no distingue entre variables útiles y variables irrelevantes. El R² Ajustado sí lo hace.

¿Cómo Funciona?

El R² Ajustado incorpora una penalización basada en:

• El número de observaciones disponibles.
• El número de variables predictoras utilizadas.

Si una nueva variable aporta información relevante, el R² Ajustado aumentará. Si una nueva variable no mejora realmente la capacidad predictiva del modelo, el R² Ajustado disminuirá. Por esta razón, suele considerarse una métrica más fiable cuando se comparan modelos con distinto número de variables.

Fórmula del R² Ajustado

$$R^2_{adj}=1-(1-R^2)\frac{n-1}{n-p-1}$$

Donde:

• R² = Coeficiente de determinación tradicional.
• n = Número de observaciones.
• p = Número de variables predictoras.

La fórmula introduce una penalización que aumenta a medida que incorporamos más variables al modelo.

Interpretación

La interpretación es similar a la del R² tradicional:

¿Cuándo Utilizar R² Ajustado?

El R² Ajustado resulta especialmente útil cuando:

• Trabajamos con regresión múltiple.
• Comparamos modelos con diferente número de variables.
• Realizamos procesos de selección de características (Feature Selection).
• Queremos evitar modelos excesivamente complejos.
• Buscamos reducir el riesgo de sobreajuste (Overfitting).

Si todos los modelos tienen exactamente las mismas variables, el R² tradicional suele ser suficiente. Sin embargo, cuando el número de características cambia entre modelos, el R² Ajustado proporciona una evaluación más justa.

Cálculo en Python

Scikit-Learn no incluye una función específica para calcular el R² Ajustado, pero puede obtenerse fácilmente a partir del R² tradicional.

from sklearn.metrics import r2_score

# R² tradicional
r2 = r2_score(y_test, y_pred)

# Número de observaciones
n = len(y_test)

# Número de variables predictoras
p = X_test.shape[1]

# R² Ajustado
adjusted_r2 = 1 - ((1 - r2) * (n - 1) / (n - p - 1))

print(f"R²: {r2:.4f}")
print(f"Adjusted R²: {adjusted_r2:.4f}")

from sklearn.metrics import r2_score

# R² tradicional
r2 = r2_score(y_test, y_pred)

# Número de observaciones
n = len(y_test)

# Número de variables predictoras
p = X_test.shape[1]

# R² Ajustado
adjusted_r2 = 1 - ((1 - r2) * (n - 1) / (n - p - 1))

print(f"R²: {r2:.4f}")
print(f"Adjusted R²: {adjusted_r2:.4f}")

Conclusión

El coeficiente de determinación (R²) es una de las métricas fundamentales para evaluar modelos de regresión. Su principal objetivo es medir qué proporción de la variabilidad de la variable objetivo es explicada por el modelo. Gracias a su interpretación intuitiva, se ha convertido en una herramienta imprescindible para comparar modelos y evaluar su capacidad predictiva.

El R² Ajustado surge para corregir una de las principales limitaciones del coeficiente de determinación tradicional. Mientras que el R² tiende a favorecer modelos cada vez más complejos, el R² Ajustado introduce una penalización que obliga a que cada nueva variable aporte un valor real al modelo. Por este motivo, cuando se trabaja con regresión múltiple y se comparan modelos con diferente número de características, el R² Ajustado suele ser una métrica más fiable para evaluar la calidad y capacidad explicativa de un modelo.

No obstante, el R² no debe utilizarse de forma aislada. Una evaluación rigurosa requiere complementarlo con métricas de error como MAE, MSE o RMSE, así como validar el comportamiento del modelo sobre datos que no haya visto previamente. Comprender el significado de R² y sus limitaciones es un paso esencial para cualquier profesional que trabaje con Machine Learning y Ciencia de Datos.

Cuando construimos un modelo de regresión, el objetivo principal es realizar predicciones lo más cercanas posible a los valores reales. Sin embargo, ningún modelo es perfecto. Siempre existirá cierta diferencia entre lo que el modelo predice y lo que realmente ocurre. Para medir esa diferencia utilizamos métricas de evaluación, siendo una de las más importantes el Error Cuadrático Medio (Mean Squared Error o MSE).

El MSE es una de las métricas más utilizadas en Machine Learning y estadística porque proporciona una medida clara de cuánto se equivocan, en promedio, las predicciones de un modelo.

¿Qué es el error cuadrático medio?

El error cuadrático medio mide el promedio de los errores al cuadrado entre los valores reales y los valores predichos por un modelo.

En términos simples:

1. Calculamos la diferencia entre el valor real y la predicción.
2. Elevamos esa diferencia al cuadrado.
3. Sumamos todos los errores cuadrados.
4. Dividimos entre el número total de observaciones.

La fórmula matemática es:

$$MSE=\frac{1}{n}\sum_{i=1}^{n}(y_i-\hat{y}_i)^2$$

Donde:

• n = número de observaciones.
• yᵢ = valor real.
• ŷᵢ = valor predicho por el modelo.
• (yᵢ − ŷᵢ)² = error cuadrado para cada observación.

¿Por qué se eleva el error al cuadrado?

Podríamos preguntarnos por qué no simplemente promediar los errores.

Supongamos estas diferencias:

Si calculamos el promedio de los errores:

$$\frac{10 + (-10)}{2}=0$$

El resultado sería cero, sugiriendo incorrectamente que el modelo no se equivoca.

Al elevar cada error al cuadrado:

$$10^2 = 100$$
$$(-10)^2 = 100$$

Ambos errores contribuyen positivamente al resultado final, evitando cancelaciones. Además, el cuadrado penaliza más severamente los errores grandes, algo muy útil en muchos problemas de negocio.

Ejemplo de Cálculo Paso a Paso

Supongamos que tenemos un modelo que predice la recaudación de películas.

Paso 1: Calcular los errores

Paso 2: Elevar al cuadrado

Paso 3: Calcular la media

$$MSE = \frac{100 + 100 + 400}{3}$$
$$MSE = \frac{600}{3}$$
$$MSE = 200$$

El Error Cuadrático Medio del modelo es:

$$MSE = 200$$

Interpretación del MSE

La interpretación básica es sencilla:

• MSE pequeño → El modelo realiza buenas predicciones.
• MSE grande → El modelo comete errores importantes.

Sin embargo, existe un detalle importante. Debido a que los errores se elevan al cuadrado, las unidades también quedan elevadas al cuadrado. Esto hace que la interpretación directa del valor sea menos intuitiva.

Sensibilidad a los Valores Atípicos

Una de las principales características del MSE es que penaliza fuertemente los errores grandes. Veamos un ejemplo.

Modelo A

Errores:

$$2,3,4$$

MSE:

$$\frac{4+9+16}{3}=9.67$$

Modelo B

Errores:

$$1,1,10$$

MSE:

$$\frac{1+1+100}{3}=34$$

Aunque la mayoría de los errores del segundo modelo son pequeños, un único error grande provoca que el MSE aumente considerablemente. Por este motivo, el MSE es especialmente útil cuando queremos detectar y penalizar predicciones muy alejadas de la realidad.

Ventajas del MSE

• Fácil de calcular: La fórmula es sencilla y eficiente incluso para grandes volúmenes de datos.
• Penaliza errores grandes: Los errores importantes tienen un peso mucho mayor que los errores pequeños. Esto resulta útil en aplicaciones donde los fallos graves tienen un alto coste económico o operativo.
• Compatible con muchos algoritmos: Numerosos algoritmos de Machine Learning utilizan el MSE como función objetivo durante el entrenamiento. Por ejemplo:
  • Regresión Lineal.
  • Redes Neuronales.
  • Gradient Boosting.
  • XGBoost.
  • Random Forest Regressor.

Limitaciones del MSE

• Sensibilidad a Outliers: Los valores atípicos pueden dominar completamente la métrica. Un único error extremo puede aumentar significativamente el MSE.
• Interpretación menos intuitiva: Al estar expresado en unidades al cuadrado, resulta más difícil comprender su significado práctico. Por esta razón suele utilizarse junto con otras métricas.

Relación con el RMSE

Una métrica muy popular derivada del MSE es el Root Mean Squared Error (RMSE). Su fórmula es:

$$RMSE=\sqrt{MSE}$$

Por ejemplo:

Si:

$$MSE = 200$$

entonces:

$$RMSE = \sqrt{200}$$
$$RMSE \approx 14.14$$

La ventaja es que el RMSE vuelve a expresarse en las mismas unidades de la variable objetivo, facilitando la interpretación. Si estamos prediciendo ingresos en miles de euros, un RMSE de 14 indica que el modelo se equivoca aproximadamente en 14 mil euros por predicción.

MSE en Machine Learning

Durante el entrenamiento de muchos modelos de regresión, el algoritmo intenta minimizar el MSE. Esto significa que ajusta sus parámetros para que la suma de los errores cuadrados sea lo más pequeña posible. En una regresión lineal, por ejemplo, el proceso de aprendizaje consiste precisamente en encontrar los coeficientes de la recta que minimizan el Error Cuadrático Medio sobre los datos de entrenamiento. En otras palabras, el modelo aprende buscando la línea que produzca el menor MSE posible.

¿Cuándo utilizar el MSE?

El MSE es especialmente recomendable cuando:

• Estamos trabajando con problemas de regresión.
• Los errores grandes son especialmente costosos.
• Queremos una métrica sensible a predicciones muy alejadas del valor real.
• Necesitamos una función objetivo para optimizar modelos.

Por el contrario, si los datos contienen muchos valores atípicos o deseamos una métrica más robusta, puede ser conveniente complementar el análisis con métricas como el MAE (Mean Absolute Error).

MSE en Python

La biblioteca Scikit-Learn incluye la función mean_squared_error(), que permite calcular fácilmente el Error Cuadrático Medio de un modelo de regresión. Una vez generadas las predicciones, basta con comparar los valores reales con los valores estimados.

Supongamos que tenemos los siguientes valores reales y predicciones:

from sklearn.metrics import mean_squared_error

# Valores reales
y_true = [100, 150, 200]

# Predicciones
y_pred = [90, 160, 180]

# Calcular MSE
mse = mean_squared_error(y_true, y_pred)

print(f"MSE: {mse:.2f}")

from sklearn.metrics import mean_squared_error

# Valores reales
y_true = [100, 150, 200]

# Predicciones
y_pred = [90, 160, 180]

# Calcular MSE
mse = mean_squared_error(y_true, y_pred)

print(f"MSE: {mse:.2f}")

MSE: 200.00

MSE: 200.00

Este resultado coincide con el ejemplo calculado manualmente anteriormente.

Cálculo Tras Entrenar un Modelo

En un flujo de trabajo real, el MSE suele calcularse después de entrenar el modelo y generar predicciones sobre el conjunto de prueba.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# División Train/Test
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

# Crear modelo
model = LinearRegression()

# Entrenar
model.fit(X_train, y_train)

# Predicciones
y_pred = model.predict(X_test)

# Calcular MSE
mse = mean_squared_error(y_test, y_pred)

print(f"MSE: {mse:.2f}")

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# División Train/Test
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

# Crear modelo
model = LinearRegression()

# Entrenar
model.fit(X_train, y_train)

# Predicciones
y_pred = model.predict(X_test)

# Calcular MSE
mse = mean_squared_error(y_test, y_pred)

print(f"MSE: {mse:.2f}")

Comparando Varios Modelos

Una práctica habitual consiste en entrenar varios algoritmos y comparar sus valores de MSE.

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

models = {
    "Linear Regression": LinearRegression(),
    "Random Forest": RandomForestRegressor(random_state=42)
}

for name, model in models.items():

    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)

    mse = mean_squared_error(y_test, y_pred)

    print(f"{name}: MSE = {mse:.2f}")

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

models = {
    "Linear Regression": LinearRegression(),
    "Random Forest": RandomForestRegressor(random_state=42)
}

for name, model in models.items():

    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)

    mse = mean_squared_error(y_test, y_pred)

    print(f"{name}: MSE = {mse:.2f}")

En general:

• Cuanto menor sea el MSE, mejor será el modelo.
• Un MSE de cero indica predicciones perfectas.
• Valores elevados indican errores importantes.

Relación con RMSE

A menudo se calcula también la raíz cuadrada del MSE para obtener una métrica más interpretable:

from sklearn.metrics import mean_squared_error
import numpy as np

mse = mean_squared_error(y_test, y_pred)

rmse = np.sqrt(mse)

print(f"MSE: {mse:.2f}")
print(f"RMSE: {rmse:.2f}")

from sklearn.metrics import mean_squared_error
import numpy as np

mse = mean_squared_error(y_test, y_pred)

rmse = np.sqrt(mse)

print(f"MSE: {mse:.2f}")
print(f"RMSE: {rmse:.2f}")

El RMSE se expresa en las mismas unidades que la variable objetivo, mientras que el MSE está expresado en unidades al cuadrado.

Utilizando NumPy

Aunque Scikit-Learn es la opción más habitual, también podemos calcular el MSE manualmente utilizando NumPy:

import numpy as np

y_true = np.array([100, 150, 200])
y_pred = np.array([90, 160, 180])

mse = np.mean((y_true - y_pred) ** 2)

print(f"MSE: {mse:.2f}")

import numpy as np

y_true = np.array([100, 150, 200])
y_pred = np.array([90, 160, 180])

mse = np.mean((y_true - y_pred) ** 2)

print(f"MSE: {mse:.2f}")

Este cálculo implementa directamente la fórmula matemática del Error Cuadrático Medio y produce exactamente el mismo resultado que mean_squared_error().

Conclusión

El Error Cuadrático Medio (MSE) es una de las métricas fundamentales para evaluar modelos de regresión. Su principal objetivo es medir cuánto se alejan las predicciones de los valores reales, penalizando especialmente los errores grandes. Esta característica lo convierte en una herramienta extremadamente útil tanto para evaluar modelos como para entrenarlos.

Aunque su interpretación puede resultar menos intuitiva debido a las unidades al cuadrado, su simplicidad matemática y su capacidad para detectar errores significativos explican por qué sigue siendo una de las métricas más utilizadas en Machine Learning, Estadística y Ciencia de Datos. Comprender cómo funciona el MSE es un paso esencial para analizar el rendimiento de cualquier modelo predictivo y tomar decisiones informadas durante el proceso de modelado.