Evaluación de tu primer modelo de random forest con scikit-learn
Curso de Decision Trees y Random Forest con Python y scikit-learn
Contenido del curso
Jeison Gerardo Rodriguez
Layla Scheli
Profesor
Juan Acevedo
Elias Dudamel
Layla Scheli
Profesor
Julián Cárdenas
Jose Martin Rangel Espinoza
Juan R. Vergara M.
Leandro Tenjo
David Duque Uribe
Layla Scheli
Profesor
Juan José Cabrera
Antonio Demarco Bonino
David Duque Uribe
Layla Scheli
Profesor
Jesus E. Rocca
jhon Robert Matamoros
Layla Scheli
Profesor
Carlos Mazzaroli
Diego Mauricio Zuluaga Rodríguez
Diego Mauricio Zuluaga Rodríguez
Diego Mauricio Zuluaga Rodríguez
Alex Xiomar Rubio Lopez
Juan Diego Velásquez Pinzón
Braylin Alexander Jiménez Reynoso
Sebastián Franco
Juan Acevedo
Mario Alexander Vargas Celis
Daniel Santana
Hyperparameter tuning con Grid SearchCV
Repliqué el algoritmo de random forest usando GridSearchCV para encontrar la mejor combinación de parámetros. El código es:
from sklearn.model_selection import GridSearchCV rf = RandomForestClassifier() parametros = { 'n_estimators' : range(4,101), 'criterion' : ['mse', 'mae', 'gini', 'entropy', 'log_loss'], 'max_depth' : range(2,11) } rf_grid = GridSearchCV(rf, parametros, cv = 5, scoring='accuracy').fit(X,y)
El mejor modelo tiene las combinaciones:
{'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 22}
Y el accuracy fue de 0.7888549359137594 usando CV.
Excelente Jeison, muy buen aporte :)
acá hay un detalle , todo bien con el código , a excepción de la parte donde pones el criterion para medir la pureza de los nodos , pones mse y mae , lo cual básicamente no está bien ya que esto es para clasificación no regresión y esos otros dos son medidas para mirar la pureza de predicciones numéricas continuas
Quise ver que pasaba si sumábamos más estimadores(arboles) y este es el resultado. El accuracy dentro de la parte de train no cambia a partir del 30 estimadores a diferencia de accuracy en test, va mostrando mejoras a medida que se suman más estimadores pero cada vez aumentar un estimador más, aporta mucho menos.
n_estimators = list() accuracy_score_train = list() accuracy_score_test = list() for n in range(10, 301, 5): n_estimators.append(n) rf = RandomForestClassifier(n_estimators=n, random_state = 00000) rf.fit(X_train, y_train) y_train_pred = rf.predict(X_train) y_test_pred = rf.predict(X_test) accuracy_score_train.append(accuracy_score(y_train, y_train_pred)) accuracy_score_test.append(accuracy_score(y_test, y_test_pred)) plt.figure(figsize=(12, 12)) plt.plot(n_estimators, accuracy_score_train, 'g', marker='o', label='train') plt.plot(n_estimators, accuracy_score_test, 'b', marker='o', label='test') plt.xlabel('n_estimators') plt.ylabel('Accuracy') plt.title('Accuracy Score') plt.legend() plt.grid() plt.show()
Muy interesante, excelente analisis :)
Brutaaal!
Agregar más estimadores (también conocidos como árboles) a un modelo de Random Forest puede mejorar la precisión y la estabilidad del modelo.
Cada árbol en el modelo aporta información independiente y tiene una probabilidad de equivocarse en algunas predicciones. Al combinar múltiples árboles, los errores en las predicciones individuales tienden a cancelarse mutuamente, lo que resulta en un modelo más robusto y generalizable.
Sin embargo, agregar demasiados árboles puede llevar a un sobreajuste (overfitting), donde el modelo se ajusta demasiado a los datos de entrenamiento y pierde la capacidad de generalizar a nuevos datos. En la práctica, se suele encontrar un equilibrio entre la cantidad de árboles y la precisión del modelo mediante la validación cruzada o la curva de aprendizaje.
En general, agregar más estimadores puede ser beneficioso para mejorar la precisión del modelo, siempre y cuando se controle el sobreajuste y se encuentre un equilibrio adecuado entre la complejidad del modelo y la cantidad de datos disponibles para entrenarlo.
Gracias por el aporte
También pueden hacer el gráfico de forma horizontal.
sns.barplot(data=feature_importances_df, y='Feature', x='Importance')
Un heatmap de correlación de variables nos permitiría ver cuáles variables se correlacionan más en nuestro DF
< sns.heatmap(df_raw.corr(), annot=True, cmap='coolwarm') plt.title('Correlación de variables') plt.show() >
Gracias :) buen aporte!
Modificaste algunos datos antes de crear el heatmap?
Me hice otra gráfica que me gustó más:
import warnings warnings.filterwarnings('ignore') plt.figure(figsize=(10, 4)) sns.barplot(x=feature_importances['feature'], y=feature_importances['importance'], palette='rocket', edgecolor='black') plt.xlabel('Features') plt.ylabel('Importance') plt.title('Feature Importance Score') for i, value in enumerate(feature_importances['importance']): plt.text(i, value + 0.003, f'{value * 100:.2f}%', ha='center') plt.show()
Al aumentarle mucho el umero de estimadores se puede obtener un overfitting lo cual no es lo más conveniente
Totalmente David, tenes que considerar la cantidad de datos que dispones :)
Eh optimizado el modelo Random Forest mediante validación cruzada (5 folds), evaluando 54 combinaciones de parámetros. El mejor modelo utilizó 200 árboles, profundidad máxima de 8, selección de variables sqrt, 10 muestras mínimas por hoja y 5 por división.
Porque no se calcula directamente con el .score?? Mi pregunta viene dada a saber si asi es más precisa o porque??
Hola Jhon, porque es el primer ejemplo simplemente :)
Validacion cruzada
from sklearn.model_selection import cross_val_score, KFold k = 5 cv = KFold(n_splits=k, shuffle=True, random_state=42) scores = cross_val_score(best_model, X_train, y_train, cv=cv, scoring='accuracy') print("Accuracy scores for each fold:", scores) print("Mean accuracy: ", scores.mean()) print("Standard deviation: ", scores.std())
Resultados
Accuracy scores for each fold: [0.7804878 0.76422764 0.72357724 0.74796748 0.79508197] Mean accuracy: 0.7622684259629482 Standard deviation: 0.02495611367618129
Parametros usados en el modelo
{'criterion': 'entropy', 'max_depth': 5, 'min_samples_leaf': 2, 'min_samples_split': 2, 'n_estimators': 50}
¿Por qué es mejor usar matriz de confusión?
Porque el accuracy (exactitud) puede ser engañoso, especialmente si tienes datos desbalanceados. Imagina que el 90% de tus datos pertenece a una sola clase; un modelo que siempre prediga esa clase tendrá un 90% de exactitud, pero será inútil. La matriz de confusión te permite ver exactamente dónde se equivoca el modelo, mostrando los verdaderos positivos, falsos positivos, verdaderos negativos y falsos negativos. En scikit-learn, puedes generarla fácilmente con confusion_matrix. Esto te ayuda a entender si tu Random Forest está confundiendo categorías específicas y si necesitas ajustar el umbral de decisión.
¿Cómo detecto el overfitting en mi modelo?
Para detectar el sobreajuste (overfitting), debes comparar el rendimiento de tu modelo en los datos de entrenamiento versus los datos de prueba. Si obtienes un puntaje casi perfecto en entrenamiento, pero un rendimiento muy bajo en las pruebas, tu modelo simplemente memorizó los datos en lugar de aprender patrones generales. En scikit-learn, puedes usar la función score() en ambos conjuntos de datos. Para solucionarlo en un Random Forest, puedes limitar la profundidad máxima de los árboles usando el hiperparámetro max_depth o aumentar el número mínimo de muestras requeridas para dividir un nodo con min_samples_split.
Resultado con n_estimators=15
Accuracy en Train: 0.9906890130353817 Accuracy en Test: 0.7619047619047619
Resultado con n_estimators=5
Accuracy en Train: 0.9702048417132216 Accuracy en Test: 0.7445887445887446
Reto: Cambio el número de estimadores
Para valores mayores a 10 el accuracy empieza a cambiar, nota que a partir de 55 el accuracy de entrenamiento llega a 1.0
Con 100 estimadores consegui Train Accuracy Score: 1.0 Test Accuracy Score: 0.7705627705627706
Parece que sucedio overfitting
Esta clase me encanta y como nos enseña a realizar de distintas formas los códigos y análsis de modo que tengamos más de un camino para realizarlo.
Ahora se calculará el score de accuracy
\# Use accuracy score from sklearn.metrics import accuracy\_score train\_accuracy = accuracy\_score(y\_train, y\_train\_pred\_random\_forest) test\_accuracy = accuracy\_score(y\_test, y\_test\_pred\_random\_forest) print(f"Train Accuracy: {train\_accuracy}") print(f"Test Accuracy: {test\_accuracy}") Train Accuracy: 0.9944029850746269 Test Accuracy: 0.7316017316017316
Posterior se crea un dataframe con los feature importances y se plotea con seaborn
\# check feature importances feature\_importances\_df = pd.DataFrame( { "feature" : list(X.columns), "importance" : list(random\_forest.feature\_importances\_) } ).sort\_values("importance", ascending=False) feature\_importances\_df import seaborn as sns import matplotlib.pyplot as plt sns.barplot( x=feature\_importances\_df.feature, y=feature\_importances\_df.importance ) plt.title("Feature Importance for Diabetes detection") plt.xlabel("Features") plt.ylabel("Feature Importance Score") plt.xticks(rotation=45, horizontalalignment="right", fontweight="light") plt.plot()
Este fue mi resultado utilizando GridSearchCVpara busqueda de hyperparemtros
¡Perfecto! Una vez entrenado tu primer modelo de Random Forest con scikit-learn, es fundamental evaluarlo correctamente para entender su rendimiento. Aquí te explico cómo hacerlo paso a paso:
✅ 1. Predicción en datos de prueba
y_pred = rf_model.predict(X_test)
También puedes obtener las probabilidades de clase si lo necesitas:
y_proba = rf_model.predict_proba(X_test)
📊 2. Métricas de evaluación
a. Exactitud (Accuracy)
from sklearn.metrics import accuracy_score print("Accuracy:", accuracy_score(y_test, y_pred))
b. Reporte de Clasificación (precision, recall, f1-score)
from sklearn.metrics import classification_report print(classification_report(y_test, y_pred, target_names=iris.target_names))
c. Matriz de confusión
from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=iris.target_names, yticklabels=iris.target_names) plt.xlabel('Predicción') plt.ylabel('Real') plt.title('Matriz de Confusión') plt.show()
🧠 3. Importancia de características
Para entender qué variables son más relevantes:
import pandas as pd
importances = pd.Series(rf_model.feature_importances_, index=iris.feature_names) importances.sort_values(ascending=True).plot(kind='barh') plt.title('Importancia de las características') plt.show()
🧪 4. Validación cruzada (opcional)
Para evaluar el modelo de forma más robusta:
from sklearn.model_selection import cross_val_score
scores = cross_val_score(rf_model, X, y, cv=5) print("Accuracy promedio con CV:", scores.mean())
🔍 Resultado esperado
Con un dataset como el Iris, podrías obtener:
petal length o petal width)Es normal que mis métricas me dieron un poco diferente al igual que las importances?
