Contenido del curso
Evaluación de tu primer modelo de random forest con scikit-learn
Jeison Gerardo Rodriguez
student
Layla Scheli
teacher
Juan Acevedo
student
Elias Dudamel
studentLayla Scheli
teacher
Julián Cárdenas
student
Jose Martin Rangel Espinoza
student
Juan R. Vergara M.
student
Leandro Tenjo
student
David Duque Uribe
studentLayla Scheli
teacher
Juan José Cabrera
student
Antonio Demarco Bonino
studentDavid Duque Uribe
studentLayla Scheli
teacher
jhon Robert Matamoros
studentLayla Scheli
teacher
Carlos Mazzaroli
student
Alex Xiomar Rubio Lopez
student
Jesus E. Rocca
student
Juan Diego Velásquez Pinzón
student
Braylin Alexander Jiménez Reynoso
student
Sebastián Franco
studentJuan Acevedo
student
Mario Alexander Vargas Celis
student
Daniel Santana
student
Gabriel Andrés Alzate Acuña
studentLayla Scheli
teacher
david jurado
studentLayla Scheli
teacher
Daniel Esponda
studentLayla Scheli
teacherHyperparameter 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 :)
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}
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
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.
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?
No deberian ser los datos normalizados? Creo que por eso las variables más grandes y con mejor variación contienen la mayor ponderancia.
Hola Gabriel, se puede y deberia hacerse ambas pruebas para comparar :)
No creo que haya sido la mejor idea usar un modelo "robusto" con un dataset tan simple, y con un EDA tan básico, obligado da overfitting
Hola David, es buena tu apreciacion, en cursos mas avanzados se puede hacer un tunning, esto es un curso basico a estos temas :) Un saludo!
Tengo la impresión de que el modelo tiene al sobreajuste, hay muy buenas precisiones sobre los datos de entrenamiento, pero no sobre los datos de prueba.
Gracias Daniel, por tu aportacion :)