Om je RandomForestClassifier beter uitlegbaar te maken, kun je gebruik maken van verschillende methoden en tools binnen Scikit-learn en gerelateerde bibliotheken. Hier zijn enkele veelgebruikte technieken: 1. **Feature Importances** Biedt inzicht in welke kenmerken het meest bijdragen aan de voorspellingen. 2. **Decission Plots en Partial Dependence Plots (PDP)** Visualiseren de invloed van individuele features op de voorspellingen. 3. **Tree Visualisatie** Bekijk individuele bomen uit de bos voor gedetailleerde interpretatie. 4. **Gebruik van `sklearn.inspection` en `sklearn.tree` modules** Voor interpretatie en visualisatie. Hieronder een voorbeeldcode die deze methoden demonstreert: ```python import numpy as np import pandas as pd from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from sklearn.inspection import plot_partial_dependence, permutation_importance from sklearn.tree import plot_tree import matplotlib.pyplot as plt # Voorbeeld: dataset laden en splitsen (vervang dit door je eigen data) # X, y = jouw_dataset_features, jouw_dataset_target # Bijvoorbeeld: # X = df.drop('verloop', axis=1) # y = df['verloop'] # Splitsen in training en test sets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Model trainen model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42) model.fit(X_train, y_train) # 1. Feature importances importances = model.feature_importances_ features = X.columns # Plot feature importances plt.figure(figsize=(10,6)) indices = np.argsort(importances) plt.barh(range(len(indices)), importances[indices], align='center') plt.yticks(range(len(indices)), [features[i] for i in indices]) plt.xlabel('Feature importance') plt.title('Feature importances van RandomForest') plt.show() # 2. Permutation importance (betere interpretatie) result = permutation_importance(model, X_test, y_test, n_repeats=10, random_state=42) sorted_idx = result.importances_mean.argsort() plt.figure(figsize=(10,6)) plt.barh([features[i] for i in sorted_idx], result.importances_mean[sorted_idx]) plt.xlabel('Permutatie feature importance') plt.title('Permutatie importance voor testdata') plt.show() # 3. Partial Dependence Plots voor belangrijke features # Bijvoorbeeld voor de top 2 features top_features = [features[i] for i in indices[-2:]] # laatste twee zijn meest belangrijk plot_partial_dependence(model, X_test, top_features, grid_resolution=50) plt.suptitle('Partial Dependence Plots') plt.show() # 4. Visualisatie van een individuele boom # Neem bijvoorbeeld de eerste boom uit het bos estimator = model.estimators_[0] plt.figure(figsize=(20,10)) plot_tree(estimator, feature_names=features, class_names=['Niet verloop', 'Verloop'], filled=True, max_depth=3) plt.title('Visualisatie van een enkele boom uit het Random Forest') plt.show() ``` ### Uitleg van de methoden: - **Feature importances** geven aan welke kenmerken het meest bijdragen aan de beslissingen van het model. - **Permutation importance** is een robuustere maat voor feature relevance, omdat het de modelprestaties meet nadat de features zijn geschud. - **Partial Dependence Plots (PDP)** tonen de verwachte voorspelling van het model afhankelijk van één of twee features, waardoor je inzicht krijgt in de relatie tussen features en de voorspelling. - **Tree visualisatie** laat je een enkele decision tree uit de bos zien, wat de logica achter die specifieke boom verduidelijkt. Door deze technieken te combineren, krijg je een beter begrip van hoe je model beslissingen neemt, wat de transparantie en uitlegbaarheid verbetert.

Zeker! Hier zijn methoden en tools binnen Scikit-learn om je Random Forest model beter uitlegbaar te maken: ## 1. Feature Importance (Functie-importantie) ```python import matplotlib.pyplot as plt import numpy as np from sklearn.ensemble import RandomForestClassifier # Train je model model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42) model.fit(X_train, y_train) # Feature importance feature_importance = model.feature_importances_ feature_names = X_train.columns # Sorteer features op importantie indices = np.argsort(feature_importance)[::-1] # Visualiseer plt.figure(figsize=(10, 6)) plt.title("Feature Importantie - Random Forest") plt.bar(range(X_train.shape[1]), feature_importance[indices]) plt.xticks(range(X_train.shape[1]), [feature_names[i] for i in indices], rotation=45) plt.tight_layout() plt.show() ``` ## 2. Permutation Importance ```python from sklearn.inspection import permutation_importance # Bereken permutation importance result = permutation_importance(model, X_test, y_test, n_repeats=10, random_state=42) # Visualiseer resultaten sorted_idx = result.importances_mean.argsort()[::-1] plt.figure(figsize=(10, 6)) plt.boxplot(result.importances[sorted_idx].T, vert=False, labels=X_test.columns[sorted_idx]) plt.title("Permutation Importance (test set)") plt.tight_layout() plt.show() ``` ## 3. Partial Dependence Plots (PDP) ```python from sklearn.inspection import PartialDependenceDisplay # Selecteer de belangrijkste features top_features = [feature_names[i] for i in indices[:4]] # Maak PDP plots fig, ax = plt.subplots(figsize=(12, 8)) PartialDependenceDisplay.from_estimator( model, X_train, top_features, ax=ax, grid_resolution=20 ) plt.suptitle('Partial Dependence Plots') plt.tight_layout() plt.show() ``` ## 4. SHAP Values (via scikit-learn compatible library) ```python # Eerst installeren: pip install shap import shap # Initialize SHAP explainer explainer = shap.TreeExplainer(model) shap_values = explainer.shap_values(X_test) # Summary plot shap.summary_plot(shap_values[1], X_test, feature_names=feature_names) # Voor individuele voorspellingen sample_idx = 0 shap.force_plot(explainer.expected_value[1], shap_values[1][sample_idx], X_test.iloc[sample_idx], feature_names=feature_names) ``` ## 5. Decision Path Analysis ```python # Kies een specifieke boom voor inspectie tree_index = 0 tree = model.estimators_[tree_index] # Exporteer beslissingsregels from sklearn.tree import export_text tree_rules = export_text(tree, feature_names=list(feature_names)) print(f"Beslissingsregels voor boom {tree_index}:\n") print(tree_rules) ``` ## 6. Model-specifieke uitlegmethoden ```python # Voor individuele voorspellingen def explain_prediction(model, sample, feature_names): probabilities = model.predict_proba([sample])[0] print(f"Voorspelling: {probabilities}") print(f"Klassen: {model.classes_}") # Feature bijdragen voor deze voorspelling for i, (feature, value) in enumerate(zip(feature_names, sample)): print(f"{feature}: {value}") # Gebruik sample = X_test.iloc[0] explain_prediction(model, sample, feature_names) ``` ## Aanbevolen workflow: 1. **Start met feature importance** om algemene inzichten te krijgen 2. **Gebruik permutation importance** voor robuustere resultaten 3. **Analyseer PDP plots** voor niet-lineaire relaties 4. **Gebruik SHAP** voor gedetailleerde individuele uitleg 5. **Inspecteer decision paths** voor rule-based inzichten ## Extra tips: - Normaliseer je features voor betere interpretatie - Documenteer de belangrijkste patronen die je ontdekt - Combineer meerdere methoden voor compleet beeld - Valideer je inzichten met domeinkennis Deze methoden helpen je om niet alleen te begrijpen *wat* het model voorspelt, maar ook *waarom* het bepaalde voorspellingen doet.