Evaluación de resultados del modelo de clasificación con random forest

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

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:

• Train accuracy: 0.97
• Test accuracy: 0.93

Además la matriz de confusión fue el sgte:

Despues usé GridSearchCV
obteniendo un modelo con los sgtes parámetros:
{‘criterion’: ‘gini’, ‘max_depth’: 10, ‘n_estimators’: 20}
con un score de 0.94

usando el sgte codigo

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

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.

Accurancy del reto anterior("safety ",“persons”)

En lo que anteriormente concluimos como las variables relevantes.

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 * lo cuál indica que el especificar la profundidad del árbol es muy importante para obtener los mejores resultados * 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 * Lo curioso es que este resultado es parecido *(aunque no exactamente igual)* que simplemente no colocar especificar este parámetro. * (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:  ```python # 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() ```

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. ```python 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.

Código para gráfica la matrix de confución: `disp = ConfusionMatrixDisplay(confusion_matrix=cm,                               display_labels=rf.classes_)disp.plot(cmap='Blues')` 

Yo tuve exactamente los mismo valores en el algoritmo de arbol de decision y random forest.... Raaro