Contenido del curso
Evaluación de resultados del modelo de clasificación con random forest
Edwin Uldarico Hernandez Osorio
Estudiante
Layla Scheli
Profesor
Elihu Sebasthian Copca Godinez
Estudiante
FELIX DAVID CORDOVA GARCIA
EstudianteLayla Scheli
Profesor
Juan José Cabrera
Estudiante
Christian Anthony Suca Velando
EstudianteLayla Scheli
Profesor
Miguel Sanchez
Estudiante
Mauricio Combariza
EstudianteLayla Scheli
Profesor
Paolo Joaquin Pinto Perez
Estudiante
Johan Diaz
EstudianteLayla Scheli
Profesor
Mauricio Escobar
EstudianteLayla Scheli
Profesor
Marlon Marin
EstudiantePaolo Joaquin Pinto Perez
Estudiante
Nixon Rolando García Ramírez
Estudiante
Alex Xiomar Rubio Lopez
Estudiante
Sebastián Franco
Estudiante
Mario Alexander Vargas Celis
Estudiante
Leandro Tenjo
EstudianteLayla Scheli
ProfesorLeandro Tenjo
Estudiante
Luis Vidal
Estudiante
Axel Yaguana
Team Platzi
Rigoberto Acosta González
EstudianteLayla Scheli
Profesor
Gustavo Lago de Azevedo Moura
EstudianteLayla Scheli
Profesor
Diego Hurtado
EstudianteAl ser un curso de nivel intermedio, agradezco que el curso maneje solo 2 algoritmos y altamente relacionados
PERO siento que le faltaron modulos, y algunas cosas fueron superficiales, los EDA no fueron propiamente EDA
No se toco como hacer PCA, esos dos aspectos pasables, complementamos con otros cursos
Lo que si falto fue dedicar un modulo a los parametros de los algoritmos en sklearn, y como su modificación afecta nuestros resultados, EJ no se dijo nada de n_jobs, class_weight, max_features y muchas otras
o como seleccionar su valores mas correctos
sin dejar de lado que tampoco se planteo la búsqueda de los mejores hyper parametros
No digo que lo que hay este mal, solo que puede ser mejor y si alguien dice, pues ve y lee la documentación ... Eso lo puedo hacer sin pagar una subscripción a un curso
Hola Edwin :) gracias por tus comentarios, sin dudas hay muchos temas que se podrian agregar y se toman en cuenta. Respecto a los otros algoritmos que comentan, en este curso solo se abordan unicamente esos dos, ninguno mas! forma parte de la propuesta educativa. Un saludo!
No tiene mucho sentido entrenar árboles y bosques con PCA, incluso Sin normalización z-core de los datos les va bien porque no son tan sensibles a valores atípicos. Mas bien encontrar variables altamente correlacionadas en el EDA es más relevante porque estos modelos se sobre ajustan mucho.
Gracias Felix, excelente aporte :)
me genera curiosidad como lograste eso. Es posible que nos puedas compartir como se logra? Saludos.
Experimentos con Random Forest
Entrenando con 5 features
["buying","maint","persons","lugboot","safety"]
descontando el feature "doors" por tener un bajo feature_importance
Aplicando Random Forest el accuracy fue:
Además la matriz de confusión fue el sgte:
from sklearn.model_selection import GridSearchCV parametros = { "n_estimators" : range(1,40), "criterion": ["gini", "entropy", "log_loss"], "max_depth": range(2,11) } rf_grid = GridSearchCV( rf, parametros, cv=5, scoring="accuracy", verbose=1, n_jobs=-1 ).fit(X_train,y_train)
Fitting 5 folds for each of 1053 candidates, totalling 5265 fits
# mejores parametros rf_grid.best_params_
{'criterion': 'gini', 'max_depth': 10, 'n_estimators': 20}
# mejor score rf_grid.best_score_
0.9404409999657076
Excelente aporte Christian, gracias :)
Es demasiado alto; overfitting?
En lo personal, si me gusto que el curso se mantuviera básico. Hay muchos cursos que termina uno haciendo cosas increibles, pero de los que se entiende muy poco de fondo. Es más, me gustaría uno donde se pudiera explorar de donde salen las formulas básicas de sklearn antes de seguir sacando librerias para obtener resultados.
Gracias por el curso.
Gracias Mauricio, se anexo informacion sobre este tema, para complementar! Un saludo!
Accurancy del reto anterior("safety ","persons")
En lo que anteriormente concluimos como las variables relevantes.
Disculpa, podrías explciar la matriz de confusión para este caso?
Hola Johan, se explica. Fijate en los recursos que se menciona, el tema. Sino tambien, lee los post, lo han comentado otros estudiantes. Saludos :)
Al re entrenar el modelo con menos variables no logré un cambio significativo en el modelo. Pero al cambiar el max_depth si que se han notado los cambios. Aquí un sumario:
maxdepth = 2. Vemos que el desicion tree por si solo ha tenido mejor desempeño que el random forest, lo cuál "tendría" sentido dado que el random forest brilla mucho más con datasets grandes. y el dataset actual es pequeño (1708 filas)
sin embargo no es la máxima capacidad del algoritmo y tampoco es el mejor resultado que podemos obtener
resultados: train 0.71, test 0.70
aclaraciones: El desempeño del Decision Tree y el Random Forest puede variar dependiendo de varios factores, no solo del tamaño del dataset. En este caso, el Decision Tree puede haber obtenido un mejor desempeño debido a la configuración específica de los parámetros o a la naturaleza de los datos. A grandes rasgos no se podría generalizar que el Decision Tree siempre superará al Random Forest en datasets pequeños
maxdepth = 5. El desempeño del random forest ha mejorado de manera significativa (~ más de 10 puntos porcentuales), llegando a train 0.83, test 0.80
max depth = 10 .El desempeño del random forest ha mejorado aún más que las vez anterior, habiendo un incremento de 20 puntos porcentuales que el mínimo obtenido con el max_depth = 2 siendo: train 0.98, test 0.90
(sin especificar max depth) El parámetro max_depth en el Random Forest no tiene un valor predeterminado, por lo que si no se especifica se expandirá hasta que todas las hojas sean puras o hasta que todas las hojas contengan menos de min_samples_split muestras. En este caso específico, la mejora en el desempeño del modelo con max_depth = 10 puede deberse a una mejor capacidad de generalización y control del sobreajuste. En resumen, le atiné con el 10 :D
feature importances tree vs forest:
También me aventé esta cosa que encontré chusmeando en sklearn, que no tengo idea de qué significa pero se ve muy intelectual y elegante:
# plot_tree(tree_model, filled= True, # rellenar nodos con colores feature_names= X.columns, class_names= y.unique(), # exitar que se repitan las clases fontsize= 10) plt.show()
Genial la prueba Mauricio :) excelente.
Si queremos conocer el performance de nuestro modelo en función del número de estimadores, podemos usar este código que escribí basado en el aporte de un compañero.
def performance_plot(n_estimators, X, y) -> plt.plot: perform_dict = {"test" : [], "train": []} for i in range(1, n_estimators+1): # Spliting data, 30% for training and 70% for testing. X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.3) # Encoding data encoder = ce.OrdinalEncoder(cols=['buying_price', 'maint_cost', 'n_doors', 'n_person', 'lug_boot', 'safety']) X_train = encoder.fit_transform(X_train) X_test = encoder.transform(X_test) # Creating Random Forest model random_forest = RandomForestClassifier(n_estimators=i) # Training model random_forest.fit(X_train, y_train) # Predicting y_pred_test = random_forest.predict(X_test) y_pred_train = random_forest.predict(X_train) # Metrics a_test = accuracy_score(y_test, y_pred_test) a_train = accuracy_score(y_train, y_pred_train) perform_dict["test"].append(a_test) perform_dict["train"].append(a_train) # Dataframe perform_data = pd.DataFrame(perform_dict).reset_index().rename(columns={"index" : "iteration"}) ( perform_data[["test", "train"]] .pipe( lambda df: ( df.test.interpolate(method="linear").plot(color="black", marker="o", alpha=6/9, linestyle="dashed"), df.train.interpolate(method="linear").plot(color="red", marker="o", alpha=6/9, linestyle="dashed") ) ) ) plt.grid() plt.xlabel("Number of iterations") plt.ylabel("Performance") plt.show() ```De esta forma, tendremos gráficas como estas:
Un muy buen curso sin duda de los que más aprendi siendo alguien que recien comienza en el mundo del DataScience.
De las mejores explicacion con los modulos muy parametrizados.
Muy buen curso, muy bueno para entender de forma adecuada los modelos de ML, ya que en cierto aspecto, algunos pasos o tematicas son similares entre si, muchas gracias 💪💪💪.
reto: reducir el numero de estimadores y usando solo los features mas importantes se obtiene los siguientes resultados:
Al reducir el estimador por debajho de 10, no se apreciaban cambios en los valores de acurracy
Comparando los valores de clasificacion se puede notar que si se ven valores significativos cuando se usa todos los valores o solo los mas importantes en cuanto a la precision, recall y el f1-score y mantiene igual el support.
Como paso final, se comparará el performance del modelo de Decision Tree y Random Forest
train\_accuracy\_rf = accuracy\_score(Y\_train, y\_pred\_train\_rf) test\_accuracy\_rf = accuracy\_score(Y\_test, y\_pred\_test\_rf) print(f"Train accuracy Decision Tree: {train\_accuracy\_tree}") print(f"Test accuracy Decision Tree: {test\_accuracy\_tree}") print(f"Train accuracy RF: {train\_accuracy\_rf}") print(f"Test accuracy RF: {test\_accuracy\_rf}") \# Train accuracy Decision Tree: 0.7733664185277088 \# Test accuracy Decision Tree: 0.626204238921002 \# Train accuracy RF: 0.9975186104218362 \# Test accuracy RF: 0.5202312138728323
Y exponer las features de importancia
\# Create Feature Importance plot feature\_scores\_tree = pd.Series(tree.feature\_importances\_, index=X\_train.columns).sort\_values(ascending=False) feature\_scores\_rf = pd.Series(rf.feature\_importances\_, index=X\_train.columns).sort\_values(ascending=False) sns.barplot(x=feature\_scores\_tree, y=feature\_scores\_tree.index) plt.xlabel("Importance Score") plt.ylabel("Features") plt.title("Features Importance Score for Decision Tree") plt.plot() sns.barplot(x=feature\_scores\_rf, y=feature\_scores\_rf.index) plt.xlabel("Importance Score") plt.ylabel("Features") plt.title("Features Importance Score for Random Forest") plt.plot()
Aquí se puede notar que para el Random Forest hay importancia en todas las variables en diferencia al Decision Tree
Finalmente se usará una Confussion Matrix y un Classification Report para obtener información clave de los resultados del modelo
\# Create confussion matrix from sklearn.metrics import confusion\_matrix confussion\_matrix\_tree = confusion\_matrix(Y\_test, y\_pred\_test\_tree) confussion\_matrix\_rf = confusion\_matrix(Y\_test, y\_pred\_test\_rf) confussion\_matrix\_tree array(\[\[ 29, 0, 89, 0], \[ 5, 0, 14, 0], \[ 62, 0, 296, 0], \[ 10, 0, 14, 0]]) confussion\_matrix\_rf array(\[\[ 20, 0, 94, 4], \[ 3, 0, 14, 2], \[ 83, 21, 247, 7], \[ 4, 1, 16, 3]]) \# Get classification Report from sklearn.metrics import classification\_report \# tree report print(classification\_report(Y\_test, y\_pred\_test\_tree)) precision recall f1-score support acc 0.27 0.25 0.26 118 good 0.00 0.00 0.00 19 unacc 0.72 0.83 0.77 358 vgood 0.00 0.00 0.00 24 accuracy 0.63 519 macro avg 0.25 0.27 0.26 519 weighted avg 0.56 0.63 0.59 519 \# rf report print(classification\_report(Y\_test, y\_pred\_test\_rf)) precision recall f1-score support acc 0.18 0.17 0.18 118 good 0.00 0.00 0.00 19 unacc 0.67 0.69 0.68 358 vgood 0.19 0.12 0.15 24 accuracy 0.52 519 macro avg 0.26 0.25 0.25 519 weighted avg 0.51 0.52 0.51 519
La evaluación de resultados de un modelo de clasificación con Random Forest en scikit-learn se realiza principalmente con métricas como:
✅ 1. Accuracy (exactitud)
Mide el porcentaje de predicciones correctas sobre el total.
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, y_pred) print(f"Accuracy del modelo: {accuracy:.2f}")
✅ 2. Matriz de confusión
Muestra cuántos ejemplos se clasificaron correctamente y cuáles fueron confundidos entre clases.
from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(5,4)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=le_target.classes_, yticklabels=le_target.classes_) plt.xlabel("Predicción") plt.ylabel("Real") plt.title("Matriz de Confusión") plt.show()
✅ 3. Reporte de clasificación
Incluye precisión, recall y F1-score para cada clase:
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred, target_names=le_target.classes_))
🔹 Precision: De los que predije como clase X, ¿cuántos eran realmente X? 🔹 Recall: De todos los que eran clase X, ¿cuántos los detecté correctamente? 🔹 F1-score: Promedio ponderado de precisión y recall.
✅ 4. Importancia de características
Para saber qué variables influyen más en el modelo:
importances = model.feature_importances_ for col, imp in zip(X.columns, importances): print(f"{col}: {imp:.4f}")
🎯 Ejemplo de salida esperada (si se usó el código anterior)
Accuracy del modelo: 0.80
precision recall f1-score support
alto 0.75 1.00 0.86 1 bajo 1.00 0.50 0.67 2 medio 1.00 1.00 1.00 1
accuracy 0.80 4 macro avg 0.92 0.83 0.84 4 weighted avg 0.88 0.80 0.79 4
¿En que situación podría ser mejor un solo Árbol de Decision, frente a un Random Forest?
Hola Leandro, generalmente cuando tenes pocos datos y un dataset chico. Ya cuando tenes mas cantidad de datos siempre es mejor un RF :) Pero acordate que es muy importante que estes validando con metricas tus modelos. Un saludo!
Entiendo. Muchas Gracias.
Este tipo de evaluación solo funciona con los Randon forest o se puede utilizar con otros modelos como regresión lineal, logística, etc?
Hola, Luis.
La evaluación de resultados en un modelo de clasificación, utilizando métricas como precisión, recall, F1-score, matriz de confusión, etc., no está limitada exclusivamente al modelo de Random Forest. Estas métricas pueden ser utilizadas para evaluar el rendimiento de cualquier modelo de clasificación, incluyendo modelos como regresión logística, regresión lineal, SVM (Support Vector Machines), entre otros.
Es importante tener en cuenta que cada modelo tiene sus propias características y supuestos, por lo que las métricas y técnicas de evaluación pueden variar en función del modelo utilizado. Por ejemplo, en un modelo de regresión logística, se pueden utilizar métricas como la precisión, recall y F1-score, así como el área bajo la curva ROC (AUC-ROC), que es específica para problemas de clasificación binaria.
Código para gráfica la matrix de confución:
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=rf.classes_)disp.plot(cmap='Blues')
Gracias Rigoberto, efectamente se actualizo eso, y hay que cambiar y adaptar el script. Enhorabuena :)
Yo tuve exactamente los mismo valores en el algoritmo de arbol de decision y random forest.... Raaro
Hola Gustavo :) te respondi en el hilo anterior!
Me ocurrió lo mismo, pero fue porque en el reto anterior eliminé los features de menor importancia, pero ahora se tienen que tomar en cuenta de nuevo
