Evaluación de resultados del modelo de clasificación con random forest
Curso de Decision Trees y Random Forest con Python y scikit-learn
Contenido del curso
Edwin Uldarico Hernandez Osorio
Layla Scheli
Profesor
Elihu Sebasthian Copca Godinez
FELIX DAVID CORDOVA GARCIA
Layla Scheli
Profesor
Juan José Cabrera
Christian Anthony Suca Velando
Layla Scheli
Profesor
Miguel Sanchez
Mauricio Combariza
Layla Scheli
Profesor
Paolo Joaquin Pinto Perez
Johan Diaz
Layla Scheli
Profesor
Mauricio Escobar
Layla Scheli
Profesor
Marlon Marin
Paolo Joaquin Pinto Perez
Nixon Rolando García Ramírez
Diego Mauricio Zuluaga Rodríguez
Diego Mauricio Zuluaga Rodríguez
Diego Mauricio Zuluaga Rodríguez
Alex Xiomar Rubio Lopez
Sebastián Franco
Mario Alexander Vargas Celis
Leandro Tenjo
Layla Scheli
ProfesorLeandro Tenjo
Luis Vidal
Axel Yaguana
Team Platzi
Rigoberto Acosta González
Layla Scheli
Profesor
Gustavo Lago de Azevedo Moura
Layla Scheli
Profesor
Diego Hurtado
Al 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 💪💪💪.
AJUSTES EN EL MODELO
Para este nuevo modelo, ejecuta las siguientes celdas **en orden**. No necesitas usar category\_encoders ni el OrdinalEncoder.
La idea será:
1. Separar X e y.
2. Usar únicamente safety, buying y persons.
3. Dividir los datos.
4. Codificar variables categóricas con OneHotEncoder.
5. Buscar hiperparámetros con GridSearchCV.
6. Evaluar con accuracy, matriz de confusión y classification\_report.
## Celda 1: importar librerías
import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn.model\_selection import train\_test\_split, GridSearchCV from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder from sklearn.pipeline import Pipeline from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import (   accuracy\_score,   confusion\_matrix,   classification\_report )
## Celda 2: verificar el dataframe
Esta celda supone que ya ejecutaste la carga de df\_car y que sus columnas tienen nombres.
df\_car.head()
Si todavía no asignaste los nombres, ejecuta primero:
col\_names = \[   'buying',   'maint',   'doors',   'persons',   'lug\_boot',   'safety',   'class' ] df\_car.columns = col\_names
## Celda 3: seleccionar únicamente las variables necesarias
Usaremos como características:
- safety
- buying
- persons
La variable objetivo será class.
features = \['safety', 'buying', 'persons'] X = df\_car\[features] y = df\_car\['class']
## Celda 4: verificar X e y
print("Características utilizadas:") display(X.head()) print("\nVariable objetivo:") display(y.head()) print("\nDimensiones de X:", X.shape) print("Dimensiones de y:", y.shape)
El resultado esperado para X será:
(1728, 3)
## Celda 5: revisar los valores categóricos
for column in features:   print(f"\nValores de {column}:")   print(X\[column].unique())
También puedes revisar la distribución de la variable objetivo:
y.value\_counts()
## Celda 6: separar entrenamiento y prueba
Usaremos el 70 % para entrenar y el 30 % para evaluar.
stratify=y conserva aproximadamente la misma proporción de clases en ambos conjuntos.
X\_train, X\_test, y\_train, y\_test = train\_test\_split(   X,   y,   test\_size=0.30,   random\_state=42,   stratify=y )
## Celda 7: comprobar las dimensiones
print("X\_train:", X\_train.shape) print("X\_test:", X\_test.shape) print("y\_train:", y\_train.shape) print("y\_test:", y\_test.shape)
## Celda 8: crear el OneHotEncoder
El modelo no puede trabajar directamente con textos como:
low, med, high, vhigh
Por eso convertiremos cada categoría en columnas numéricas.
categorical\_features = \['safety', 'buying', 'persons'] one\_hot\_encoder = OneHotEncoder(   handle\_unknown='ignore',   sparse\_output=False )
Si aparece un error indicando que sparse\_output no existe, usa esta versión:
one\_hot\_encoder = OneHotEncoder(   handle\_unknown='ignore',   sparse=False )
## Celda 9: crear el transformador de columnas
preprocessor = ColumnTransformer(   transformers=\[   (   'categorical',   one\_hot\_encoder,   categorical\_features   )   ] )
El ColumnTransformer aplicará el OneHotEncoder únicamente a las tres columnas seleccionadas.
## Celda 10: crear el pipeline
El Pipeline une el preprocesamiento y el modelo.
Esto es importante porque el OneHotEncoder se ajustará correctamente dentro de cada partición de validación cruzada.
random\_forest = RandomForestClassifier(   random\_state=42,   n\_jobs=-1 ) pipeline = Pipeline(   steps=\[   ('preprocessor', preprocessor),   ('model', random\_forest)   ] )
## Celda 11: definir los hiperparámetros
Estos son los parámetros que probaremos:
- n\_estimators: cantidad de árboles.
- max\_depth: profundidad máxima de los árboles.
- min\_samples\_split: mínimo de observaciones para dividir un nodo.
- min\_samples\_leaf: mínimo de observaciones en una hoja.
- max\_features: cantidad de características consideradas en cada división.
param\_grid = {   'model\_\_n\_estimators': \[50, 100, 200],   'model\_\_max\_depth': \[3, 5, 8, None],   'model\_\_min\_samples\_split': \[2, 5, 10],   'model\_\_min\_samples\_leaf': \[1, 2, 4],   'model\_\_max\_features': \['sqrt', 'log2'] }
El prefijo model\_\_ indica que los parámetros pertenecen al modelo llamado model dentro del pipeline.
## Celda 12: crear GridSearchCV
Usaremos cinco particiones de validación cruzada.
grid\_search = GridSearchCV(   estimator=pipeline,   param\_grid=param\_grid,   cv=5,   scoring='accuracy',   n\_jobs=-1,   verbose=1 )
## Celda 13: entrenar el Grid Search
grid\_search.fit(X\_train, y\_train)
Esta celda puede tardar unos segundos o minutos, porque probará varias combinaciones de hiperparámetros.
## Celda 14: consultar la mejor combinación
print("Mejores hiperparámetros:") print(grid\_search.best\_params\_)
También puedes consultar el mejor accuracy promedio obtenido durante la validación cruzada:
print("Mejor accuracy promedio en validación cruzada:") print(grid\_search.best\_score\_)
## Celda 15: obtener el mejor modelo
best\_model = grid\_search.best\_estimator\_
Este modelo ya contiene:
- El OneHotEncoder entrenado.
- El RandomForestClassifier.
- La mejor combinación de hiperparámetros encontrada.
## Celda 16: generar predicciones
y\_train\_pred = best\_model.predict(X\_train) y\_test\_pred = best\_model.predict(X\_test)
## Celda 17: calcular accuracy en entrenamiento y prueba
train\_accuracy = accuracy\_score(y\_train, y\_train\_pred) test\_accuracy = accuracy\_score(y\_test, y\_test\_pred) print("Accuracy en entrenamiento:", train\_accuracy) print("Accuracy en prueba:", test\_accuracy)
El valor más importante es el accuracy de prueba:
test\_accuracy
Con estas tres variables, normalmente deberías obtener un resultado dentro o cerca del rango solicitado de 0.7 a 0.9. El valor exacto depende de la versión de las librerías y de la división de los datos.
No conviene forzar artificialmente el accuracy. Si supera 0.9, significa que el modelo obtuvo un resultado mejor que el rango solicitado; en ese caso debes reportarlo correctamente.
## Celda 18: comprobar el rango solicitado
if 0.7 \<= test\_accuracy \<= 0.9:   print("El accuracy está dentro del rango solicitado.") else:   print("El accuracy está fuera del rango solicitado.")
## Celda 19: calcular la matriz de confusión
cm = confusion\_matrix(y\_test, y\_test\_pred) print("Matriz de confusión:") print(cm)
Para conocer el orden de las clases:
class\_labels = best\_model.named\_steps\['model'].classes\_ print("Orden de las clases:") print(class\_labels)
La matriz se interpreta así:
- Filas: clases reales.
- Columnas: clases predichas.
- Diagonal principal: predicciones correctas.
## Celda 20: visualizar la matriz de confusión
plt.figure(figsize=(7, 5)) sns.heatmap(   cm,   annot=True,   fmt='d',   cmap='Blues',   xticklabels=class\_labels,   yticklabels=class\_labels ) plt.xlabel('Clase predicha') plt.ylabel('Clase real') plt.title('Matriz de confusión - Random Forest') plt.show()
## Celda 21: generar el reporte de clasificación
print(   classification\_report(   y\_test,   y\_test\_pred,   labels=class\_labels,   target\_names=class\_labels,   zero\_division=0   ) )
El reporte mostrará:
- precision: qué tan precisas fueron las predicciones de cada clase.
- recall: cuántos ejemplos reales de cada clase encontró el modelo.
- f1-score: equilibrio entre precision y recall.
- support: cantidad de ejemplos de cada clase.
- accuracy: accuracy general.
## Celda 22: revisar todos los resultados del Grid Search
results = pd.DataFrame(grid\_search.cv\_results\_) results\[   \[   'mean\_test\_score',   'std\_test\_score',   'param\_model\_\_n\_estimators',   'param\_model\_\_max\_depth',   'param\_model\_\_min\_samples\_split',   'param\_model\_\_min\_samples\_leaf',   'param\_model\_\_max\_features'   ] ].sort\_values(   by='mean\_test\_score',   ascending=False ).head(10)
El flujo principal queda resumido así:
df\_car   -> X e y   -> train\_test\_split   -> OneHotEncoder   -> Pipeline   -> GridSearchCV   -> Random Forest optimizado   -> accuracy   -> confusion\_matrix   -> classification\_report
Este enfoque evita entrenar el encoder con información del conjunto de prueba y permite que GridSearchCV compare las combinaciones de hiperparámetros de forma correcta.
Mejores hiperparámetros:
{'model__max_depth': 5,
'model__max_features': 'sqrt',
'model__min_samples_leaf': 1,
'model__min_samples_split': 2,
'model__n_estimators': 200}
¿Puedo saber qué variables importan más?
¡Totalmente! Una de las grandes ventajas de usar Random Forest frente a otros algoritmos más opacos es que te permite ver dentro de su proceso de decisión mediante la importancia de características (feature importance). Una vez que tu modelo está entrenado, puedes extraer un ranking de cuáles variables tuvieron más peso al momento de clasificar. Por ejemplo, si estás prediciendo el tipo de un vehículo, el modelo podría revelarte que el 'número de puertas' y el 'tamaño del motor' definen el 80% de la decisión, mientras que el 'color' casi no importa. Esta evaluación no solo te ayuda a entender el modelo, sino que te permite simplificarlo en el futuro eliminando las variables que solo aportan ruido.
¿Cómo mido el éxito de mi modelo?
Para evaluar un modelo de Random Forest, no basta con mirarlo por encima; necesitas métricas específicas que actúen como un 'examen médico' de tus predicciones. En clasificación, las herramientas más comunes son la matriz de confusión y el reporte de clasificación (que incluye Precision, Recall y F1-Score). Imagina que tu modelo es un filtro de spam. No solo quieres saber cuántos correos clasificó bien en total, sino también cuántos correos importantes mandó a la papelera por error. Usando la librería scikit-learn, puedes generar estas métricas rápidamente con funciones como classification_report. Esto te dará una visión panorámica de dónde tu bosque aleatorio es fuerte y en qué categorías específicas se está confundiendo, permitiéndote ajustar los hiperparámetros de manera mucho más estratégica.
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
