Tutorial ScikitLearn: Métricas de Regresión

Error Medio Absoluto (MAE)

El Error Medio Absoluto (MAE) es una medida estadística que cuantifica la media de las discrepancias absolutas entre los valores predichos y los valores reales en un modelo de regresión. Representa, en promedio, cuánto se desvían las predicciones respecto a los valores observados, proporcionando una interpretación directa del error en las mismas unidades que la variable objetivo.

El MAE se calcula sumando las diferencias absolutas entre las predicciones y los valores reales, y luego dividiendo entre el número total de observaciones. A diferencia de otras métricas, el MAE es robusto frente a valores atípicos, ya que no eleva al cuadrado las diferencias, evitando la penalización excesiva de errores grandes.

La fórmula para calcular el MAE es la siguiente:

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

donde:

• $n$ es el número de observaciones,
• $( y_i )$ es el valor real,
• $( \hat{y}_i )$ es el valor predicho.

Un MAE más bajo indica un mejor desempeño del modelo, ya que implica que, en promedio, las predicciones están más cerca de los valores reales. Es especialmente útil en contextos donde se requiere una interpretación sencilla y cuando se necesita comprender el error promedio de las predicciones.

A continuación, se presenta un ejemplo de cómo calcular el MAE utilizando Scikit-Learn en Python. Se construirá un modelo de regresión lineal simple sobre un conjunto de datos sintéticos.

import numpy as np
from sklearn.metrics import mean_absolute_error
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Crear una instancia de Generator
rng = np.random.default_rng(seed=0)

# Generación de datos sintéticos
X = 2 * rng.random((100, 1))
y = 4 + 3 * X[:, 0] + rng.standard_normal(100)

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

# Creación y entrenamiento del modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Predicciones sobre el conjunto de prueba
y_pred = modelo.predict(X_test)

# Cálculo del Error Medio Absoluto
mae = mean_absolute_error(y_test, y_pred)
print(f"Error Medio Absoluto (MAE): {mae:.2f}")

En este código, se utiliza la función mean_absolute_error de Scikit-Learn para calcular el MAE entre los valores reales y las predicciones del modelo. El resultado proporciona una medida directa del error promedio en las mismas unidades que la variable objetivo.

Es importante considerar que el MAE no penaliza severamente los errores grandes, ya que todas las diferencias absolutas tienen el mismo peso en el cálculo. Por tanto, en casos donde los errores extremos son especialmente críticos, podría ser recomendable complementar el MAE con otras métricas que sí penalicen más estos desvíos significativos.

Error Cuadrático Medio (MSE) y Raíz del Error Cuadrático Medio (RMSE)

El Error Cuadrático Medio (MSE) es una métrica que cuantifica la media de los cuadrados de las diferencias entre los valores predichos y los valores reales en un modelo de regresión. Al elevar al cuadrado las discrepancias, el MSE penaliza de manera más severa los errores grandes, lo que lo hace sensible a los valores atípicos. Esta métrica es fundamental para evaluar el desempeño de un modelo y optimizar sus parámetros.

La fórmula del MSE es la siguiente:

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

donde:

• $n$ es el número total de observaciones,
• $( y_i )$ representa los valores reales,
• $( \hat{y}_i )$ son los valores predichos por el modelo.

Aunque el MSE proporciona información valiosa, sus unidades son el cuadrado de las unidades originales de la variable objetivo, lo que puede dificultar su interpretación directa. Para abordar este inconveniente, se utiliza la Raíz del Error Cuadrático Medio (RMSE), que es simplemente la raíz cuadrada del MSE:

$$
\text{RMSE} = \sqrt{\text{MSE}}
$$

El RMSE devuelve las unidades a la escala original de la variable objetivo, facilitando la comprensión del error promedio que comete el modelo en sus predicciones.

Ventajas y consideraciones:

• El MSE y el RMSE son sensibles a errores grandes, debido al cuadrado de las diferencias.
• Un RMSE más bajo indica un mejor ajuste del modelo a los datos observados.
• Estas métricas son muy utilizadas en algoritmos de optimización y en la evaluación de modelos de regresión.

A continuación, se presenta un ejemplo práctico utilizando Scikit-Learn para calcular el MSE y el RMSE de un modelo de regresión lineal sobre un conjunto de datos sintéticos:

import numpy as np
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Generación de datos sintéticos
rng = np.random.default_rng(seed=42)  
X = 2 * rng.random((200, 1))  
y = 5 + 7 * X[:, 0] + rng.standard_normal(200)

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

# Creación y entrenamiento del modelo de regresión lineal
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Predicciones sobre el conjunto de prueba
y_pred = modelo.predict(X_test)

# Cálculo del Error Cuadrático Medio (MSE)
mse = mean_squared_error(y_test, y_pred)
print(f"Error Cuadrático Medio (MSE): {mse:.2f}")

# Cálculo de la Raíz del Error Cuadrático Medio (RMSE)
rmse = np.sqrt(mse)
print(f"Raíz del Error Cuadrático Medio (RMSE): {rmse:.2f}")

En este código:

• Se genera un conjunto de datos aleatorios para simular una relación lineal.
• Se divide el conjunto de datos en entrenamiento y prueba utilizando train_test_split.
• Se entrena un modelo de regresión lineal con los datos de entrenamiento.
• Se realizan predicciones sobre el conjunto de prueba.
• Se calcula el MSE utilizando la función mean_squared_error de Scikit-Learn.
• Se calcula el RMSE tomando la raíz cuadrada del MSE con NumPy.

Interpretación de los resultados:

• El MSE proporciona una medida global del error cuadrático promedio entre las predicciones y los valores reales.
• El RMSE, al estar en las mismas unidades que la variable objetivo, permite interpretar fácilmente el error estándar de las predicciones.

Es importante tener en cuenta que, debido a la sensibilidad del MSE y RMSE a los valores atípicos, es recomendable analizar la presencia de estos en los datos y considerar su tratamiento adecuado. Además, al comparar modelos, es esencial utilizar la misma escala y unidades para que las métricas sean comparables.

Finalmente, el RMSE es ampliamente utilizado como función de costo en procesos de optimización y ajuste de modelos, ya que refleja de manera efectiva cómo de confiables son las predicciones del modelo en términos de desviación estándar.

Coeficiente de determinación R² y R² ajustado

El Coeficiente de Determinación R² es una medida estadística que evalúa la proporción de la variabilidad total de la variable dependiente que es explicada por el modelo de regresión. Indica qué tan bien las variables independientes predicen el valor de la variable objetivo, proporcionando una indicación de la calidad del ajuste del modelo.

Matemáticamente, el R² se calcula mediante la siguiente fórmula:

$$
R^2 = 1 - \frac{SS_{\text{res}}}{SS_{\text{tot}}}
$$

donde:

• $( SS_{\text{res}} )$ es la suma de los cuadrados de los residuos (Sum of Squares of Residuals),
• $( SS_{\text{tot}} )$ es la suma total de los cuadrados (Total Sum of Squares).

Un valor de R² cercano a 1 indica que el modelo explica gran parte de la variabilidad observada en los datos, mientras que un valor cercano a 0 sugiere que el modelo no captura eficazmente la relación entre las variables. Sin embargo, el R² siempre aumenta o se mantiene igual al agregar más variables independientes al modelo, incluso si estas no contribuyen significativamente, lo que puede ser engañoso en modelos con múltiples predictores.

Para corregir esta limitación, se utiliza el Coeficiente de Determinación R² ajustado, que ajusta el R² en función del número de predictores y del tamaño de la muestra. Este ajuste penaliza la inclusión de variables irrelevantes, proporcionando una estimación más realista del desempeño del modelo.

La fórmula para calcular el R² ajustado es:

$$
R_{\text{ajustado}}^2 = 1 - \left( \frac{(1 - R^2)(n - 1)}{n - p - 1} \right)
$$

donde:

• $( n )$ es el número total de observaciones,
• $( p )$ es el número de variables independientes en el modelo.

El R² ajustado puede disminuir si las nuevas variables no mejoran el modelo de manera significativa, lo que ayuda a identificar si la complejidad adicional es justificada. Es especialmente útil en modelos de regresión múltiple donde se evalúa el impacto de agregar o remover predictores.

A continuación, se presenta un ejemplo práctico utilizando Scikit-Learn para calcular el R² y el R² ajustado en un modelo de regresión lineal múltiple:

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Generación de datos sintéticos
rng = np.random.default_rng(seed=42)
n = 150  # Número de observaciones
p = 5    # Número de predictores

X = rng.random((n, p))
# Coeficientes reales
coeficientes_reales = np.array([1.5, -2.0, 3.0, 0.0, 4.5])
# Generación de la variable dependiente con ruido aleatorio
y = X @ coeficientes_reales + rng.normal(0, 0.5, n)

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

# Creación y entrenamiento del modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Predicciones sobre el conjunto de prueba
y_pred = modelo.predict(X_test)

# Cálculo del Coeficiente de Determinación R²
r2 = modelo.score(X_test, y_test)
print(f"Coeficiente de Determinación R²: {r2:.4f}")

# Cálculo del R² ajustado
n_test = X_test.shape[0]  # Número de observaciones en prueba
p = X_test.shape[1]       # Número de predictores
r2_ajustado = 1 - (1 - r2) * (n_test - 1) / (n_test - p - 1)
print(f"Coeficiente de Determinación R² ajustado: {r2_ajustado:.4f}")

En este ejemplo:

• Se generan datos sintéticos con cinco variables independientes y una variable dependiente afectada por ruido aleatorio.
• Se divide el conjunto de datos en entrenamiento y prueba utilizando train_test_split.
• Se entrena un modelo de regresión lineal múltiple con los datos de entrenamiento.
• Se calcula el R² utilizando el método .score() del modelo, que mide el desempeño sobre el conjunto de prueba.
• Se calcula el R² ajustado aplicando la fórmula correspondiente, considerando el número de observaciones y de predictores.

El resultado proporciona una comparación entre el R² y el R² ajustado, permitiendo evaluar si el modelo es adecuado y si la complejidad está justificada. Un R² ajustado significativamente menor que el R² sugiere que algunas variables pueden no ser relevantes y que el modelo podría mejorarse eliminándolas.

Es importante tener en cuenta que el R² ajustado es más conservador al evaluar la calidad del modelo, ya que penaliza la inclusión de predictores que no contribuyen significativamente. De este modo, es una herramienta valiosa para la selección de variables y la simplificación de modelos complejos.

Error Porcentual Absoluto Medio (MAPE)

El Error Porcentual Absoluto Medio (MAPE) es una métrica de evaluación utilizada en modelos de regresión para medir el error promedio en términos porcentuales entre los valores predichos y los valores reales. Representa el promedio de las desviaciones absolutas entre los valores predichos y los observados, expresado como un porcentaje de los valores reales, lo que facilita la interpretación en diferentes escalas de datos.

La fórmula del MAPE es la siguiente:

$$ \text{MAPE} = \frac{100\%}{n} \sum_{i=1}^{n} \left| \frac{y_i - \hat{y}_i}{y_i} \right| $$

donde:

• $( n )$ es el número total de observaciones,
• $( y_i )$ son los valores reales,
• $( \hat{y}_i )$ son los valores predichos por el modelo.

El MAPE se expresa en porcentaje, lo que lo hace independiente de las unidades de la variable objetivo y permite comparar el desempeño del modelo en diferentes conjuntos de datos. Un MAPE más bajo indica un mejor ajuste del modelo, reflejando que las predicciones están más cerca de los valores reales en términos relativos.

Ventajas y consideraciones:

• El MAPE es fácil de interpretar y comunicar, ya que expresa el error en porcentaje.
• Es útil para comparar el desempeño entre modelos o conjuntos de datos con diferentes escalas.
• Sin embargo, tiene limitaciones cuando los valores reales son cercanos a cero, ya que puede generar valores de error extremadamente altos o indefinidos.
• No es simétrico, penaliza más las predicciones por encima del valor real que las que están por debajo.

A continuación, se presenta un ejemplo práctico de cómo calcular el MAPE utilizando Scikit-Learn en Python. Se utilizará un modelo de regresión lineal sobre un conjunto de datos sintéticos.

import numpy as np
from sklearn.metrics import mean_absolute_percentage_error
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Generación de datos sintéticos
rng = np.random.default_rng(seed=2024)
n = 250  # Número de observaciones
p = 5    # Número de predictores

X = 5 * rng.random((n, p))
# Coeficientes reales
coeficientes_reales = np.array([1.5, -2.0, 3.0, 0.0, 4.5])

# Generación de la variable dependiente con ruido aleatorio
y = X @ coeficientes_reales + rng.normal(0, 0.5, n)

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

# Creación y entrenamiento del modelo de regresión lineal
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Predicciones sobre el conjunto de prueba
y_pred = modelo.predict(X_test)

# Cálculo del Error Porcentual Absoluto Medio (MAPE)
mape = mean_absolute_percentage_error(y_test, y_pred)
print(f"Error Porcentual Absoluto Medio (MAPE): {mape * 100:.2f}%")

En este código:

• Se generan datos sintéticos para simular una relación lineal simple.
• Se utiliza train_test_split para dividir los datos en conjuntos de entrenamiento y prueba.
• Se crea y entrena un modelo de regresión lineal con los datos de entrenamiento.
• Se realizan predicciones sobre el conjunto de prueba.
• Se calcula el MAPE utilizando la función mean_absolute_percentage_error de Scikit-Learn.

Interpretación de los resultados:

• El valor obtenido del MAPE indica el porcentaje promedio de desviación entre los valores predichos y los reales.
• Un MAPE del, por ejemplo, 5% sugiere que, en promedio, las predicciones se desvían un 5% de los valores reales.

Consideraciones importantes:

• Es fundamental verificar que no existan valores reales iguales a cero para evitar divisiones por cero. Si existen, se debe considerar agregar una pequeña constante o excluir esas observaciones si es justificable.
• Debido a que el MAPE es una medida proporcional, es más adecuado para datos donde las escalas son relevantes y se desea entender el error en términos relativos.

Ventajas del uso del MAPE:

• Proporciona una medida intuitiva del error en términos porcentuales.
• Facilita la comparación del rendimiento entre diferentes modelos o conjuntos de datos.

Limitaciones del MAPE:

• No es adecuado cuando hay valores reales cercanos o iguales a cero.
• Puede ser sensible a valores atípicos que influyen desproporcionadamente en el porcentaje de error.

Ejemplo adicional con tratamiento de ceros:

Si el conjunto de datos incluye valores reales iguales a cero, es posible manejar esta situación reemplazando los ceros por un valor mínimo muy pequeño. A continuación, se muestra cómo hacerlo:

# Reemplazo de ceros en y_test
y_test_no_zero = np.where(y_test == 0, np.finfo(float).eps, y_test)

# Cálculo del MAPE evitando división por cero
mape_safe = np.mean(np.abs((y_test_no_zero - y_pred) / y_test_no_zero)) * 100
print(f"Error Porcentual Absoluto Medio (MAPE) ajustado: {mape_safe:.2f}%")

En este fragmento:

• Se reemplazan los ceros en y_test por el menor número positivo representable (np.finfo(float).eps).
• Se calcula el MAPE manualmente para evitar errores de división por cero.
• Se obtiene un MAPE ajustado que considera estas correcciones.

Es esencial adaptar el cálculo del MAPE según las características del conjunto de datos y las necesidades específicas del análisis. Al comprender y manejar adecuadamente estas consideraciones, se pueden obtener evaluaciones más precisas y significativas del desempeño del modelo de regresión.

Uso de métricas de regresión en Scikit-Learn

Las métricas de evaluación de regresión en Scikit-Learn son herramientas fundamentales para cuantificar el desempeño de los modelos al predecir valores continuos. Estas métricas permiten medir la discrepancia entre los valores reales y las predicciones, facilitando la toma de decisiones sobre la eficacia del modelo y las mejoras necesarias.

Scikit-Learn proporciona una variedad de funciones para calcular métricas como el Error Medio Absoluto (MAE), Error Cuadrático Medio (MSE), Raíz del Error Cuadrático Medio (RMSE), Coeficiente de Determinación (R²) y Error Porcentual Absoluto Medio (MAPE). A continuación, se muestra cómo utilizar estas métricas en un ejemplo práctico de regresión.

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_absolute_error, mean_squared_error,
                             r2_score, mean_absolute_percentage_error)

# Carga del conjunto de datos de California Housing
datos = fetch_california_housing()
X = pd.DataFrame(datos.data, columns=datos.feature_names)
y = datos.target

# División de los datos en entrenamiento y prueba
X_entreno, X_prueba, y_entreno, y_prueba = train_test_split(
    X, y, test_size=0.2, random_state=2024
)

# Creación y entrenamiento del modelo de regresión lineal
modelo = LinearRegression()
modelo.fit(X_entreno, y_entreno)

# Predicción sobre el conjunto de prueba
y_pred = modelo.predict(X_prueba)

# Cálculo de las métricas de evaluación
mae = mean_absolute_error(y_prueba, y_pred)
mse = mean_squared_error(y_prueba, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_prueba, y_pred)
mape = mean_absolute_percentage_error(y_prueba, y_pred)

print(f"Error Medio Absoluto (MAE): {mae:.3f}")
print(f"Error Cuadrático Medio (MSE): {mse:.3f}")
print(f"Raíz del Error Cuadrático Medio (RMSE): {rmse:.3f}")
print(f"Coeficiente de Determinación (R²): {r2:.3f}")
print(f"Error Porcentual Absoluto Medio (MAPE): {mape * 100:.2f}%")

En este ejemplo, se utiliza el conjunto de datos California Housing para predecir el valor medio de las viviendas. Se implementa un modelo de regresión lineal y se calculan varias métricas para evaluar su rendimiento. Las funciones de Scikit-Learn como mean_absolute_error y r2_score permiten calcular estas métricas de manera sencilla y eficiente.

Es importante tener en cuenta que, al utilizar varias métricas, se obtiene una visión más completa del desempeño del modelo. Por ejemplo, el MAE proporciona el error promedio en las mismas unidades que la variable objetivo, mientras que el R² indica la proporción de varianza explicada por el modelo. La combinación de estas métricas ayuda a identificar fortalezas y debilidades en las predicciones.

Las métricas también pueden integrarse en procesos de validación cruzada y ajuste de hiperparámetros. A continuación, se muestra cómo utilizar cross_val_score para evaluar el modelo mediante validación cruzada con el MSE como métrica.

from sklearn.model_selection import cross_val_score

# Evaluación del modelo utilizando validación cruzada con MSE
mse_scores = cross_val_score(
    modelo, X, y, scoring='neg_mean_squared_error', cv=5
)
mse_scores = -mse_scores  # Invertir el signo para obtener valores positivos
rmse_scores = np.sqrt(mse_scores)

print(f"MSE por fold: {mse_scores}")
print(f"RMSE promedio: {rmse_scores.mean():.3f}")

En este fragmento, se realiza una validación cruzada de 5 folds y se calcula el MSE en cada uno. Dado que Scikit-Learn pretende maximizar las métricas, las devuelve como valores negativos cuando se trata de errores que se desean minimizar. Por ello, se multiplica por -1 para obtener los valores correctos. El cálculo del RMSE promedio proporciona una estimación del error estándar del modelo en diferentes particiones de los datos.

Para optimizar los hiperparámetros del modelo, se puede utilizar GridSearchCV junto con las métricas de evaluación. El siguiente ejemplo muestra cómo ajustar el parámetro alpha de un modelo de Ridge Regression utilizando el MAE como métrica de optimización.

from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV

# Definición del rango de valores para alpha
param_grid = {'alpha': np.logspace(-3, 3, 7)}

# Configuración de GridSearchCV con MAE como métrica
grid_search = GridSearchCV(
    Ridge(), param_grid, scoring='neg_mean_absolute_error', cv=5
)
grid_search.fit(X_entreno, y_entreno)

# Mejor valor de alpha encontrado
mejor_alpha = grid_search.best_params_['alpha']
print(f"Mejor valor de alpha: {mejor_alpha}")

# Evaluación del modelo con el mejor alpha
modelo_optimo = Ridge(alpha=mejor_alpha)
modelo_optimo.fit(X_entreno, y_entreno)
y_pred_optimo = modelo_optimo.predict(X_prueba)
mae_optimo = mean_absolute_error(y_prueba, y_pred_optimo)
print(f"MAE con modelo optimizado: {mae_optimo:.3f}")

Aquí, GridSearchCV explora diferentes valores de alpha y selecciona el que minimiza el Error Medio Absoluto. Este proceso automatiza la búsqueda del hiperparámetro óptimo, mejorando potencialmente el rendimiento del modelo.

Para utilizar métricas personalizadas o específicas, se puede emplear make_scorer para crear un scorer independiente. Por ejemplo, si se desea optimizar el RMSE directamente, se puede proceder de la siguiente manera:

from sklearn.metrics import make_scorer

# Definición de la función para RMSE
def rmse_metric(y_real, y_predicho):
    return np.sqrt(mean_squared_error(y_real, y_predicho))

# Creación del scorer personalizado
rmse_scorer = make_scorer(rmse_metric, greater_is_better=False)

# Uso de GridSearchCV con el scorer personalizado
grid_search_rmse = GridSearchCV(
    Ridge(), param_grid, scoring=rmse_scorer, cv=5
)
grid_search_rmse.fit(X_entreno, y_entreno)

# Mejor valor de alpha encontrado basado en RMSE
mejor_alpha_rmse = grid_search_rmse.best_params_['alpha']
print(f"Mejor valor de alpha según RMSE: {mejor_alpha_rmse}")

En este caso, se define una función rmse_metric que calcula el RMSE, y se crea un scorer personalizado con make_scorer. Al establecer greater_is_better=False, se indica que un valor menor es mejor para esta métrica. Así, GridSearchCV utiliza el RMSE para encontrar el mejor hiperparámetro.

Es crucial prestar atención al tratamiento de los valores negativos en las métricas que Scikit-Learn minimiza. Las métricas de error se representan como negativas para mantener la consistencia en la maximización de las puntuaciones. Por ello, se aplica el signo negativo al mostrar o interpretar estos valores.

Al integrar las métricas de regresión en el flujo de trabajo de Scikit-Learn, se facilita la comparación entre modelos, la optimización de hiperparámetros y la validación del desempeño en diferentes conjuntos de datos. La selección de la métrica adecuada depende del contexto y los objetivos específicos del proyecto. Por ejemplo:

• Utilizar el MAE cuando se desea una interpretación directa del error promedio.
• Elegir el MSE o RMSE si se quiere penalizar más los errores grandes.
• Optar por el R² para entender la proporción de varianza explicada por el modelo.
• Emplear el MAPE al necesitar una medida de error relativa en porcentaje.

Finalmente, es recomendable combinar varias métricas para obtener una evaluación integral del modelo. Esto ayuda a identificar posibles compromisos y a tomar decisiones más informadas sobre ajustes y mejoras necesarias en el proceso de modelado.