Tutorial ScikitLearn: Validación y evaluación de modelos

Importancia de la validación de modelos

La validación de modelos es un paso crucial en el desarrollo de algoritmos de aprendizaje automático. Permite evaluar cómo se desempeñará un modelo cuando se enfrente a datos nuevos, garantizando que las conclusiones obtenidas durante el entrenamiento sean generalizables a situaciones reales.

Sin una validación adecuada, existe el riesgo de que el modelo aprenda patrones específicos del conjunto de entrenamiento que no se repiten en otros datos. Esto puede llevar a una falsa percepción de rendimiento, donde el modelo muestra una alta precisión durante el entrenamiento pero falla al aplicarse en producción.

La validación ayuda a identificar y prevenir problemas como el sobreajuste (overfitting), donde el modelo se ajusta demasiado a los datos de entrenamiento, y el subajuste (underfitting), donde no captura suficientemente los patrones subyacentes. Detectar estos problemas es esencial para ajustar el modelo y mejorar su capacidad predictiva.

En Scikit-Learn, existen diversas herramientas que facilitan la validación de modelos. Por ejemplo, la función train_test_split permite dividir el conjunto de datos en conjuntos de entrenamiento y prueba, ofreciendo una estimación inicial del rendimiento del modelo en datos no vistos. Esto es fundamental para asegurar la fiabilidad del modelo antes de su despliegue.

A continuación, se muestra un ejemplo de cómo utilizar train_test_split con Python y Scikit-Learn:

import numpy as np
from sklearn.model_selection import train_test_split

# Crear una instancia de Generator con una semilla específica para reproducibilidad
rng = np.random.default_rng(seed=42)

# Generación de datos de ejemplo utilizando el generador moderno
X = rng.random((100, 10))  # 100 muestras, 10 características
y = rng.integers(low=0, high=2, size=100)  # Etiquetas binarias (0 o 1)

# División de los datos en entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print("Tamaño del conjunto de entrenamiento:", X_entrenamiento.shape)
print("Tamaño del conjunto de prueba:", X_prueba.shape)

Además, la validación es esencial para la selección de modelos y el ajuste de hiperparámetros. Al comparar diferentes modelos y configuraciones mediante técnicas de validación, es posible elegir el modelo que mejor se adapte a los datos y que tenga un rendimiento óptimo en situaciones reales.

Una validación adecuada contribuye a garantizar la integridad y robustez del modelo. Esto es particularmente importante en aplicaciones críticas donde las decisiones basadas en las predicciones del modelo pueden tener consecuencias significativas.

Conceptos básicos de evaluación de modelos

La evaluación de modelos es un proceso esencial en el aprendizaje automático que permite medir el rendimiento de un modelo predictivo. Consiste en utilizar datos no vistos por el modelo durante el entrenamiento para obtener una estimación objetiva de su capacidad para generalizar a nuevos datos. Esta evaluación es fundamental para asegurar que el modelo no solo ha aprendido patrones de los datos de entrenamiento, sino que también puede aplicarlos eficazmente en situaciones reales.

Uno de los conceptos clave en la evaluación es la separación de datos en conjuntos de entrenamiento y prueba. El conjunto de entrenamiento se utiliza para ajustar el modelo, mientras que el conjunto de prueba evalúa su rendimiento en datos independientes. Esta práctica ayuda a detectar problemas como el sobreajuste, donde el modelo se ajusta demasiado a los datos de entrenamiento y pierde capacidad de generalización.

En tareas de clasificación, una métrica común para evaluar el rendimiento es la precisión, que mide la proporción de predicciones correctas sobre el total de casos evaluados. Sin embargo, dependiendo del problema, otras métricas como la exhaustividad (recall) o el puntaje F1 pueden ser más adecuadas, especialmente en casos de clases desbalanceadas. Es crucial seleccionar la métrica de evaluación que mejor refleje los objetivos del modelo.

En el caso de problemas de regresión, métricas como el error cuadrático medio (MSE) o el error absoluto medio (MAE) son utilizadas para cuantificar la diferencia entre los valores predichos y los reales. Estas métricas ayudan a entender cuánto se desvían, en promedio, las predicciones del modelo respecto a los valores verdaderos, proporcionando una medida de su exactitud.

A continuación, se presenta un ejemplo práctico de cómo entrenar y evaluar un modelo de clasificación utilizando Scikit-Learn y Python:

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# Carga del conjunto de datos Iris
datos = load_iris()
X = datos.data
y = datos.target

# División de los datos en entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Creación y entrenamiento del modelo
modelo = DecisionTreeClassifier()
modelo.fit(X_entrenamiento, y_entrenamiento)

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

# Cálculo de la precisión
precision = accuracy_score(y_prueba, y_pred)
print(f"Precisión del modelo: {precision:.2f}")

En este ejemplo, el conjunto de datos se divide en un 70% para entrenamiento y un 30% para prueba. El modelo entrenado es un árbol de decisión, y la métrica utilizada para evaluar su rendimiento es la precisión. La función accuracy_score calcula la proporción de predicciones correctas.

Es importante tener en cuenta que la elección del modelo y de la métrica de evaluación debe basarse en las características específicas del problema. Por ejemplo, en un problema de detección de fraude, una alta precisión podría no ser suficiente si el modelo no es capaz de identificar correctamente los casos positivos. En tales situaciones, métricas como la sensibilidad o el índice Kappa pueden proporcionar una evaluación más adecuada.

Además de las métricas, es esencial evaluar el comportamiento del modelo ante diferentes condiciones. Esto incluye analizar cómo cambia el rendimiento al variar los datos de entrada o los parámetros del modelo. Esta práctica ayuda a identificar posibles limitaciones y a mejorar la robustez del modelo.

Comprender los conceptos básicos de evaluación de modelos es crucial para desarrollar algoritmos de aprendizaje automático efectivos. Una evaluación adecuada no solo proporciona una medida del rendimiento actual del modelo, sino que también guía el proceso de mejora y optimización, asegurando que el modelo sea fiable y útil en aplicaciones reales.

Sobreajuste y subajuste

El sobreajuste y el subajuste son dos problemas comunes en el aprendizaje automático que afectan negativamente al rendimiento de los modelos. Comprender estas situaciones es fundamental para desarrollar modelos que generalicen adecuadamente y sean útiles en aplicaciones reales.

El sobreajuste ocurre cuando un modelo aprende demasiado bien los detalles y el ruido del conjunto de entrenamiento, perdiendo capacidad para generalizar a nuevos datos. Esto se traduce en un alto rendimiento en el conjunto de entrenamiento pero un bajo rendimiento en el conjunto de prueba. El modelo captura patrones específicos de los datos de entrenamiento que no se repiten en datos no vistos, lo que provoca una disminución en su eficacia predictiva.

Por otro lado, el subajuste se produce cuando el modelo es demasiado simple para capturar la estructura subyacente de los datos. En este caso, el modelo muestra un rendimiento deficiente tanto en el conjunto de entrenamiento como en el de prueba. Esto suele ocurrir cuando el modelo elegido es incapaz de representar la complejidad de la relación entre las variables de entrada y la salida, lo que resulta en predicciones inexactas.

Para ilustrar estos conceptos, consideremos un ejemplo práctico utilizando Scikit-Learn y Python. Utilizaremos un conjunto de datos sintético y ajustaremos modelos de regresión polinómica con diferentes grados de complejidad.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

# Generación de datos sintéticos
rng = np.random.default_rng(seed=0)
X = np.sort(rng.random(30))
y = np.sin(2 * np.pi * X) + rng.standard_normal(30) * 0.1

# División de los datos en conjuntos de entrenamiento y prueba
X_entrenamiento = X[:20].reshape(-1, 1)
y_entrenamiento = y[:20]
X_prueba = X[20:].reshape(-1, 1)
y_prueba = y[20:]

# Función para evaluar y graficar el modelo
def evaluar_modelo(grado):
    modelo = make_pipeline(
        PolynomialFeatures(grado),
        LinearRegression(),
        memory=None
    )
    modelo.fit(X_entrenamiento, y_entrenamiento)
    y_pred_entrenamiento = modelo.predict(X_entrenamiento)
    y_pred_prueba = modelo.predict(X_prueba)
    
    # Calcular el Error Cuadrático Medio (MSE) para entrenamiento y prueba
    error_entrenamiento = np.mean((y_entrenamiento - y_pred_entrenamiento)**2)
    error_prueba = np.mean((y_prueba - y_pred_prueba)**2)
    
    print(f"Grado del polinomio: {grado}")
    print(f"Error en entrenamiento: {error_entrenamiento:.4f}")
    print(f"Error en prueba: {error_prueba:.4f}\n")
    
    # Generar puntos para la línea de regresión
    x_linea = np.linspace(0, 1, 100).reshape(-1, 1)
    y_linea = modelo.predict(x_linea)
    
    plt.scatter(X_entrenamiento, y_entrenamiento, color='blue', label='Datos de entrenamiento')
    plt.scatter(X_prueba, y_prueba, color='green', label='Datos de prueba')
    plt.plot(x_linea, y_linea, color='red', label='Modelo predictivo')
    plt.legend()
    plt.title(f"Regresión polinómica de grado {grado}")
    plt.show()

# Modelo con grado 1 (subajuste)
evaluar_modelo(1)

# Modelo con grado 4 (ajuste adecuado)
evaluar_modelo(4)

# Modelo con grado 15 (sobreajuste)
evaluar_modelo(15)

Salida:

En este ejemplo, hemos generado datos que siguen una función sinusoidal con algo de ruido aleatorio. Ajustamos modelos de regresión polinómica con grados 1, 4 y 15 para observar cómo varía el rendimiento.

• Con grado 1, el modelo es una línea recta que no puede capturar la naturaleza no lineal de los datos, resultando en un subajuste. Ambos errores, de entrenamiento y prueba, son altos.
• Con grado 4, el modelo es lo suficientemente flexible para aproximar la función subyacente sin ajustarse al ruido, mostrando un buen equilibrio y menores errores.
• Con grado 15, el modelo es extremadamente complejo y se ajusta a los puntos de datos hasta en sus menores desviaciones, incluyendo el ruido. Esto conduce a un sobreajuste, donde el error en entrenamiento es muy bajo pero el error en prueba aumenta significativamente.

El subajuste y el sobreajuste pueden detectarse comparando el rendimiento del modelo en los conjuntos de entrenamiento y prueba. Si el error en entrenamiento y prueba es alto, es probable que exista subajuste. Si el error en entrenamiento es bajo pero el error en prueba es alto, es indicativo de sobreajuste.

Para evitar el sobreajuste, se pueden emplear diversas técnicas como la regularización, la reducción de la complejidad del modelo o la obtención de más datos. La regularización añade una penalización a la función de coste del modelo, limitando su capacidad para ajustarse excesivamente a los datos de entrenamiento.

Por otro lado, para remediar el subajuste, es necesario aumentar la complejidad del modelo, por ejemplo, utilizando algoritmos más sofisticados o añadiendo características más informativas. También es importante asegurarse de que los datos están adecuadamente preprocesados y que el modelo dispone de suficiente capacidad para aprender los patrones relevantes.

Identificar y corregir el sobreajuste y el subajuste es esencial para desarrollar modelos que sean fiables y que proporcionen un rendimiento óptimo en situaciones reales. La selección cuidadosa del modelo, el ajuste de sus parámetros y la validación adecuada son pasos fundamentales en este proceso.

Compensación sesgo-varianza

La compensación sesgo-varianza es un concepto fundamental en el aprendizaje automático que describe el equilibrio entre la capacidad de un modelo para generalizar y su ajuste a los datos de entrenamiento. Esta compensación es crucial para entender y mejorar el rendimiento de los modelos predictivos.

El sesgo se refiere a los errores que resultan de las suposiciones hechas por el modelo para simplificar el problema de aprendizaje. Un sesgo alto implica que el modelo es demasiado simple y no captura las relaciones complejas en los datos, conduciendo a un subajuste. Por el contrario, la varianza mide cuánto varían las predicciones del modelo para diferentes conjuntos de entrenamiento. Una varianza alta indica que el modelo es demasiado complejo y se ajusta al ruido de los datos, resultando en sobreajuste.

La compensación surge porque reducir el sesgo suele aumentar la varianza y viceversa. Encontrar el equilibrio adecuado es esencial para minimizar el error total y mejorar la capacidad de generalización del modelo.

A continuación, se ilustra este concepto mediante un ejemplo práctico con Python y Scikit-Learn. Se utilizará un conjunto de datos sintético y se entrenarán modelos de regresión polinómica con diferentes grados para observar cómo afectan el sesgo y la varianza.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.model_selection import learning_curve

# Generación de datos sintéticos
rng = np.random.default_rng(seed=0)
x = np.sort(rng.uniform(-3, 3, size=100))
y = x ** 3 - 0.5 * x ** 2 + x + rng.normal(0, 3, size=100)

x_features = x.reshape(-1, 1)  # Asegurarse de que x sea 2D

# Función para plotear curvas de aprendizaje
def plot_learning_curve(estimator, x, y, title):
    train_sizes, train_scores, test_scores = learning_curve(
        estimator, x, y, cv=5, scoring='neg_mean_squared_error', train_sizes=np.linspace(0.1, 1.0, 10)
    )
    train_errors = -train_scores.mean(axis=1)
    test_errors = -test_scores.mean(axis=1)
    
    plt.figure(figsize=(10, 6))
    plt.plot(train_sizes, train_errors, label='Error de entrenamiento')
    plt.plot(train_sizes, test_errors, label='Error de validación')
    plt.title(title)
    plt.xlabel('Tamaño del conjunto de entrenamiento')
    plt.ylabel('Error cuadrático medio (MSE)')
    plt.legend()
    plt.grid(True)
    plt.show()

# Modelo con grado bajo (alto sesgo)
modelo_alto_sesgo = make_pipeline(PolynomialFeatures(degree=1), Ridge(alpha=1), memory= None)
plot_learning_curve(modelo_alto_sesgo, x_features, y, 'Modelo con Alto Sesgo (Grado 1)')

# Modelo con grado óptimo (equilibrio)
modelo_equilibrado = make_pipeline(PolynomialFeatures(degree=4), Ridge(alpha=1), memory= None)
plot_learning_curve(modelo_equilibrado, x_features, y, 'Modelo Equilibrado (Grado 4)')

# Modelo con grado alto (alta varianza)
modelo_alta_varianza = make_pipeline(PolynomialFeatures(degree=15), Ridge(alpha=1), memory= None)
plot_learning_curve(modelo_alta_varianza, x_features, y, 'Modelo con Alta Varianza (Grado 15)')

En este ejemplo, se entrenan tres modelos de regresión polinómica con grados 1, 4 y 15. Cada modelo representa un nivel diferente de complejidad:

• Grado 1 (alto sesgo): El modelo es demasiado simple y no captura la complejidad de los datos. Como resultado, ambos errores, de entrenamiento y validación, son altos y similares, indicando subajuste.
• Grado 4 (equilibrio): El modelo logra un equilibrio entre sesgo y varianza. El error de entrenamiento es bajo y el error de validación también disminuye, lo que sugiere una buena capacidad de generalización.
• Grado 15 (alta varianza): El modelo es muy complejo y se ajusta al ruido en los datos. El error de entrenamiento es muy bajo, pero el error de validación es alto y aumenta con el tamaño del conjunto de entrenamiento, evidenciando sobreajuste.

La gráfica de las curvas de aprendizaje muestra cómo varían los errores de entrenamiento y validación con el tamaño del conjunto de entrenamiento. Un modelo equilibrado presentará una convergencia entre ambos errores a medida que aumenta la cantidad de datos.

Para manejar la compensación sesgo-varianza, es importante aplicar estrategias como:

• Regularización: Añade una penalización a la función de coste del modelo para evitar coeficientes excesivamente grandes. En el ejemplo, se utiliza Ridge Regression, que aplica regularización L2 para reducir la varianza sin aumentar significativamente el sesgo.
• Validación cruzada: Permite evaluar el rendimiento del modelo en distintos subconjuntos de datos, facilitando la detección de sobreajuste y ayudando a seleccionar el modelo con mejor rendimiento general.
• Selección de características: Reducir el número de variables de entrada puede disminuir la varianza del modelo al eliminar características irrelevantes o redundantes que introducen ruido.
• Aumento del tamaño del conjunto de datos: Proporcionar más datos al modelo puede ayudar a reducir la varianza, especialmente en modelos complejos que requieren mucha información para aprender patrones significativos.

Es fundamental entender que no existe un método universal para resolver la compensación sesgo-varianza. La elección del algoritmo, la técnica de regularización y los hiperparámetros dependen del problema específico y de las características del conjunto de datos.

Además, herramientas como la curva de validación y la curva de aprendizaje son útiles para diagnosticar y visualizar cómo afectan el sesgo y la varianza al rendimiento del modelo. Estas herramientas facilitan la toma de decisiones informadas sobre cómo ajustar y mejorar el modelo.

En conclusión, la comprensión y el manejo adecuado de la compensación sesgo-varianza permiten desarrollar modelos más precisos y fiables, mejorando su capacidad para realizar predicciones acertadas en nuevos datos. Este equilibrio es esencial para el éxito en el desarrollo de aplicaciones de aprendizaje automático.

Errores comunes en la evaluación de modelos

La evaluación de modelos es una etapa crítica en el proceso de aprendizaje automático, y cometer errores en esta fase puede llevar a conclusiones incorrectas sobre el rendimiento real del modelo. A continuación, se describen algunos de los errores más frecuentes que se deben evitar:

1. Fugas de datos (Data Leakage)

Una fuga de datos ocurre cuando información del conjunto de prueba se filtra al modelo durante el entrenamiento, lo que resulta en una sobrestimación del rendimiento. Este error es común al realizar preprocesamientos antes de dividir los datos. Por ejemplo, si se escalan los datos o se imputan valores faltantes antes de hacer el particionamiento, el modelo indirectamente "ve" información del conjunto de prueba.

Para evitarlo, se deben aplicar las transformaciones de preprocesamiento dentro de un Pipeline que se ajuste únicamente con los datos de entrenamiento. He aquí un ejemplo:

from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
import pandas as pd

# Carga de datos
datos = pd.read_csv('dataset.csv')
X = datos.drop('objetivo', axis=1)
y = datos['objetivo']

# División de los datos
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Creación del Pipeline
pipeline = Pipeline([
    ('escalado', StandardScaler()),
    ('clasificador', LogisticRegression())
], memory = None)

# Entrenamiento del modelo
pipeline.fit(X_entrenamiento, y_entrenamiento)

# Evaluación del modelo
score = pipeline.score(X_prueba, y_prueba)
print(f"Puntuación del modelo: {score:.2f}")

2. No utilizar validación cruzada

Confiar únicamente en una sola partición de entrenamiento y prueba puede conducir a estimaciones sesgadas del rendimiento del modelo. La validación cruzada permite evaluar el modelo en múltiples particiones, proporcionando una estimación más robusta. Ignorar esta técnica puede ocultar problemas como la varianza en el rendimiento.

Implementar validación cruzada es sencillo con Scikit-Learn:

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression

# Modelo a evaluar
modelo = LinearRegression()

# Evaluación con validación cruzada
scores = cross_val_score(modelo, X, y, cv=5, scoring='neg_mean_squared_error')
print(f"Errores de validación cruzada: {-scores}")
print(f"Error medio: {-scores.mean():.2f}")

3. Uso inapropiado de métricas de evaluación

Seleccionar la métrica incorrecta puede dar una visión distorsionada del rendimiento del modelo. Por ejemplo, en conjuntos de datos desbalanceados, la precisión puede ser engañosa. Es crucial elegir métricas que reflejen adecuadamente los objetivos del modelo.

Por ejemplo, en un problema de detección de fraude con un 1% de casos positivos, un modelo que siempre prediga la clase negativa tendría una precisión del 99%, pero sería inútil. En este caso, métricas como la exhaustividad (recall) o el área bajo la curva ROC son más informativas.

4. No considerar la aleatoriedad en el modelado

Los algoritmos que incorporan aleatoriedad pueden producir resultados diferentes en cada ejecución. No establecer la semilla del generador aleatorio con el parámetro random_state dificulta la reproducibilidad y puede generar inconsistencias en la evaluación.

Es recomendable fijar random_state al crear modelos o al dividir los datos:

from sklearn.ensemble import RandomForestClassifier

modelo = RandomForestClassifier(random_state=42)

5. Optimización de hiperparámetros en el conjunto de prueba

Ajustar los hiperparámetros del modelo utilizando el conjunto de prueba conduce a un sobreajuste hacia ese conjunto específico, invalidando la estimación del rendimiento. Los hiperparámetros deben optimizarse utilizando un conjunto de validación o mediante validación cruzada, reservando el conjunto de prueba para la evaluación final.

Ejemplo de optimización correcta:

from sklearn.model_selection import GridSearchCV

parametros = {'n_estimators': [50, 100], 'max_depth': [None, 10, 20]}
modelo = RandomForestClassifier(random_state=42)

grid_search = GridSearchCV(modelo, parametros, cv=5)
grid_search.fit(X_entrenamiento, y_entrenamiento)

# Evaluación en el conjunto de prueba
mejor_modelo = grid_search.best_estimator_
score = mejor_modelo.score(X_prueba, y_prueba)
print(f"Puntuación del mejor modelo: {score:.2f}")

6. Ignorar el desbalanceo de clases

En problemas de clasificación con clases desbalanceadas, no manejar adecuadamente el desbalanceo puede resultar en modelos que ignoran la clase minoritaria. Es un error evaluar estos modelos con métricas inapropiadas o sin aplicar técnicas como el sobremuestreo o submuestreo.

Para abordar el desbalanceo, se pueden utilizar estrategias como class_weight='balanced' en algoritmos compatibles o emplear muestras sintéticas:

from sklearn.linear_model import LogisticRegression
from imblearn.over_sampling import SMOTE
from imblearn.pipeline import Pipeline as ImbPipeline

# Pipeline con sobremuestreo SMOTE
pipeline = ImbPipeline([
    ('smote', SMOTE()),
    ('clasificador', LogisticRegression())
], memory = None)

pipeline.fit(X_entrenamiento, y_entrenamiento)

7. Realizar selección de características antes de la partición

Al igual que con las transformaciones de preprocesamiento, ejecutar la selección de características antes de dividir los datos puede introducir sesgos. Las características deben seleccionarse utilizando únicamente los datos de entrenamiento para evitar fugas de información.

Implementación correcta dentro de un Pipeline:

from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('seleccion', SelectKBest(score_func=f_classif, k=10)),
    ('clasificador', LogisticRegression())
], memory = None)

pipeline.fit(X_entrenamiento, y_entrenamiento)

8. Despreciar la influencia de los datos atípicos

No detectar y manejar los datos atípicos puede distorsionar la evaluación del modelo, especialmente en algoritmos sensibles como la regresión lineal. Es importante analizar los datos y aplicar técnicas para mitigar el efecto de estos valores.

9. No probar suficientes valores de hiperparámetros

Explorar un espacio limitado de hiperparámetros puede dejar pasar combinaciones óptimas. Es un error común realizar una búsqueda superficial y asumir que los resultados son los mejores posibles. Emplear técnicas como la búsqueda aleatoria o algoritmos de optimización puede mejorar este proceso.

Ejemplo con RandomizedSearchCV:

from sklearn.model_selection import RandomizedSearchCV

parametros = {'n_estimators': [50, 100, 150],
              'max_depth': [None, 10, 20, 30]}
modelo = RandomForestClassifier(random_state=42)

random_search = RandomizedSearchCV(modelo, parametros, cv=5, n_iter=5, random_state=42)
random_search.fit(X_entrenamiento, y_entrenamiento)

10. Confiar exclusivamente en una métrica de rendimiento

Evaluar el modelo solo con una métrica puede dar una visión incompleta. Por ejemplo, en regresión, considerar únicamente el coeficiente de determinación R² puede ser engañoso si hay valores atípicos. Es recomendable utilizar múltiples métricas para obtener una evaluación más completa.

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

// Faltaría ajustar antes los datos de entrenamiento
y_pred = modelo.predict(X_prueba)

mse = mean_squared_error(y_prueba, y_pred)
mae = mean_absolute_error(y_prueba, y_pred)
r2 = r2_score(y_prueba, y_pred)

print(f"MSE: {mse:.2f}")
print(f"MAE: {mae:.2f}")
print(f"R²: {r2:.2f}")

Evitar estos errores comunes aumenta la probabilidad de desarrollar modelos que generalicen correctamente y sean fiables en entornos reales. Es esencial aplicar buenas prácticas en la evaluación para garantizar que las conclusiones obtenidas sean válidas y útiles para la toma de decisiones.