Natuurlijk! Hieronder vind je een voorbeeld van hoe je een aangepaste ensemble-methode kunt ontwikkelen en evalueren in Scikit-learn voor jouw dataset met de genoemde basismodellen. Ik zal ook uitleg geven over aanpassingen en vergelijkingen met standaardmethoden. Stap 1: Data voorbereiding Stap 2: Basismodellen trainen Stap 3: Ensemble maken met VotingClassifier (zachte stemming) Stap 4: Aangepaste ensemble-strategie ontwikkelen Stap 5: Prestaties evalueren en vergelijken Hier is een voorbeeldcode inclusief uitleg: ```python import numpy as np import pandas as pd from sklearn.model_selection import train_test_split, cross_val_score from sklearn.tree import DecisionTreeClassifier from sklearn.linear_model import LogisticRegression from sklearn.svm import SVC from sklearn.ensemble import VotingClassifier from sklearn.metrics import accuracy_score from sklearn.base import BaseEstimator, ClassifierMixin, clone # Stel dat je dataset in een DataFrame 'df' zit met features en target # X = df.drop('target', axis=1) # y = df['target'] # Voorbeeld data (vervang door je eigen dataset) # X, y = jouw_data, jouw_target # Splits de data in train en test X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Basismodellen dt = DecisionTreeClassifier(random_state=42) lr = LogisticRegression(max_iter=1000, random_state=42) svc = SVC(probability=True, random_state=42) # 1. Standaard VotingClassifier met zachte stemming voting_clf = VotingClassifier( estimators=[('dt', dt), ('lr', lr), ('svc', svc)], voting='soft' ) # Train en evalueer de standaard VotingClassifier voting_clf.fit(X_train, y_train) y_pred = voting_clf.predict(X_test) print('Standaard VotingClassifier nauwkeurigheid:', accuracy_score(y_test, y_pred)) # 2. Aangepaste ensemble - bijvoorbeeld met gewichten of stacking # Voorbeeld: Gewichten aanpassen op basis van prestatie # Eerst trainen we de basismodellen apart dt.fit(X_train, y_train) lr.fit(X_train, y_train) svc.fit(X_train, y_train) # Evalueer individuele modellen print('Decision Tree nauwkeurigheid:', accuracy_score(y_test, dt.predict(X_test))) print('Logistic Regression nauwkeurigheid:', accuracy_score(y_test, lr.predict(X_test))) print('SVC nauwkeurigheid:', accuracy_score(y_test, svc.predict(X_test))) # Bepaal gewichten op basis van prestaties weights = [ accuracy_score(y_test, dt.predict(X_test)), accuracy_score(y_test, lr.predict(X_test)), accuracy_score(y_test, svc.predict(X_test)) ] # Normaliseer gewichten weights = np.array(weights) / np.sum(weights) # 3. Aangepaste voting met gewichten class CustomWeightedVotingClassifier(BaseEstimator, ClassifierMixin): def __init__(self, estimators, weights): self.estimators = estimators self.weights = weights def fit(self, X, y=None): for name, estimator in self.estimators: estimator.fit(X, y) return self def predict(self, X): # Verzamel voorspellingen van elk model predictions = np.array([ estimator.predict(X) for _, estimator in self.estimators ]) # Weeg de voorspellingen # Voor classificatie met discrete labels: gebruik modus met gewichten from scipy.stats import mode # Bereken gewogen modus # Voor eenvoud: stem op basis van hoogste gewogen som weighted_votes = np.zeros((X.shape[0],)) for weight, (_, estimator) in zip(self.weights, self.estimators): preds = estimator.predict(X) for i, pred in enumerate(preds): # Voeg gewichten toe aan de voorspelling weighted_votes[i] += weight * pred # Converteer terug naar discrete labels # Aangezien dit niet ideaal is, beter is een stemmethode met gewichten # Maar voor het voorbeeld, neem de meest voorkomende voorspelling # (Hier simplistisch: kies de voorspelling met hoogste gewogen score) # Een meer geavanceerde aanpak zou nodig zijn voor echte implementatie final_predictions = [] for i in range(X.shape[0]): votes = {} preds = [estimator.predict(X[i].reshape(1, -1))[0] for _, estimator in self.estimators] for pred, weight in zip(preds, self.weights): votes[pred] = votes.get(pred, 0) + weight # Kies de voorspelling met de hoogste som final_predictions.append(max(votes, key=votes.get)) return np.array(final_predictions) # Instantieer en train de aangepaste classifier custom_ensemble = CustomWeightedVotingClassifier( estimators=[('dt', dt), ('lr', lr), ('svc', svc)], weights=weights ) custom_ensemble.fit(X_train, y_train) y_pred_custom = custom_ensemble.predict(X_test) print('Aangepaste gewogen ensemble nauwkeurigheid:', accuracy_score(y_test, y_pred_custom)) ``` **Uitleg:** - Eerst train je de basismodellen en evalueer je hun prestaties. - Vervolgens maak je een `VotingClassifier` met zachte stemming voor een standaard ensemble. - Voor een meer aangepaste aanpak, kun je gewichten toekennen aan elk model op basis van hun prestaties. - De `CustomWeightedVotingClassifier` is een eenvoudige implementatie die de voorspellingen combineert met gewichten. In praktijk zou je een meer robuuste methode kunnen gebruiken, zoals stacking of probabilistische combinaties. - Door deze aanpak te vergelijken met de standaard VotingClassifier, kun je bepalen of de aangepaste strategie beter presteert op jouw dataset. Mocht je verdere hulp nodig hebben bij het optimaliseren van de modellen of het ontwikkelen van complexere ensemble-methoden, laat het gerust weten!

Zeker, ik help je graag met het ontwikkelen en evalueren van aangepaste ensemble-methoden in Scikit-learn. Hier is een complete handleiding met codevoorbeelden: ## 1. Basis VotingClassifier Implementatie ```python import numpy as np import pandas as pd from sklearn.model_selection import train_test_split, cross_val_score from sklearn.ensemble import VotingClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.linear_model import LogisticRegression from sklearn.svm import SVC from sklearn.metrics import accuracy_score, classification_report, confusion_matrix from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline # Laad en prepareer je dataset # df = pd.read_csv('jouw_dataset.csv') # X = df[['inkomen', 'leeftijd', 'schuldenlast']] # y = df['target_variable'] # Voorbeeld: splitsing (vervang met jouw data) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Definieer basismodellen met pipelines models = [ ('dt', Pipeline([ ('scaler', StandardScaler()), ('classifier', DecisionTreeClassifier(random_state=42)) ])), ('lr', Pipeline([ ('scaler', StandardScaler()), ('classifier', LogisticRegression(random_state=42)) ])), ('svc', Pipeline([ ('scaler', StandardScaler()), ('classifier', SVC(probability=True, random_state=42)) ])) ] # Standaard VotingClassifier voting_clf = VotingClassifier( estimators=models, voting='soft', n_jobs=-1 ) # Train en evalueer voting_clf.fit(X_train, y_train) y_pred = voting_clf.predict(X_test) print("Standaard VotingClassifier Accuracy:", accuracy_score(y_test, y_pred)) ``` ## 2. Aangepaste Ensemble Strategieën ### Aangepaste gewogen stemming ```python class CustomWeightedVotingClassifier(VotingClassifier): def __init__(self, estimators, weights=None, voting='soft'): super().__init__(estimators=estimators, voting=voting) self.weights = weights if weights else [1] * len(estimators) def predict(self, X): if self.voting == 'soft': probas = self.predict_proba(X) # Pas gewichten toe op voorspellingskansen weighted_probas = np.zeros_like(probas[0]) for i, (name, estimator) in enumerate(self.estimators): estimator_proba = estimator.predict_proba(X) weighted_probas += self.weights[i] * estimator_proba return self.le_.classes_[np.argmax(weighted_probas, axis=1)] else: return super().predict(X) # Gebruik aangepaste gewichten custom_weights = [0.3, 0.4, 0.3] # Experimenteer met verschillende gewichten custom_voting = CustomWeightedVotingClassifier( estimators=models, weights=custom_weights, voting='soft' ) ``` ### Ensemble met feature selectie per model ```python from sklearn.feature_selection import SelectKBest, f_classif class FeatureSelectedEnsemble: def __init__(self, models, feature_selectors=None): self.models = models self.feature_selectors = feature_selectors def fit(self, X, y): self.fitted_models = [] for i, (name, model) in enumerate(self.models): if self.feature_selectors and i < len(self.feature_selectors): selector = self.feature_selectors[i] X_selected = selector.fit_transform(X, y) model.fit(X_selected, y) else: model.fit(X, y) self.fitted_models.append(model) def predict_proba(self, X): probas = [] for i, model in enumerate(self.fitted_models): if self.feature_selectors and i < len(self.feature_selectors): selector = self.feature_selectors[i] X_selected = selector.transform(X) probas.append(model.predict_proba(X_selected)) else: probas.append(model.predict_proba(X)) return np.mean(probas, axis=0) ``` ## 3. Uitgebreide Evaluatie en Vergelijking ```python def evaluate_ensemble(models_dict, X_train, X_test, y_train, y_test): results = {} for name, model in models_dict.items(): # Cross-validatie cv_scores = cross_val_score(model, X_train, y_train, cv=5, n_jobs=-1) # Training en test model.fit(X_train, y_train) y_pred = model.predict(X_test) y_pred_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, 'predict_proba') else None # Sla resultaten op results[name] = { 'cv_mean': cv_scores.mean(), 'cv_std': cv_scores.std(), 'test_accuracy': accuracy_score(y_test, y_pred), 'model': model } print(f"{name}: CV Accuracy = {cv_scores.mean():.3f} (±{cv_scores.std():.3f}), " f"Test Accuracy = {accuracy_score(y_test, y_pred):.3f}") return results # Vergelijk verschillende ensemble methoden ensemble_methods = { 'Standaard Voting': voting_clf, 'Gewogen Voting': custom_voting, 'Enkel Decision Tree': DecisionTreeClassifier(random_state=42), 'Enkel Logistic Regression': LogisticRegression(random_state=42), 'Enkel SVC': SVC(probability=True, random_state=42) } results = evaluate_ensemble(ensemble_methods, X_train, X_test, y_train, y_test) ``` ## 4. Geavanceerde Evaluatie Metrics ```python from sklearn.metrics import roc_auc_score, f1_score, precision_score, recall_score def detailed_evaluation(model, X_test, y_test): y_pred = model.predict(X_test) y_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, 'predict_proba') else None metrics = { 'accuracy': accuracy_score(y_test, y_pred), 'f1_score': f1_score(y_test, y_pred), 'precision': precision_score(y_test, y_pred), 'recall': recall_score(y_test, y_pred), } if y_proba is not None: metrics['roc_auc'] = roc_auc_score(y_test, y_proba) return metrics # Gedetailleerde vergelijking print("\nGedetailleerde Evaluatie:") for name, result in results.items(): metrics = detailed_evaluation(result['model'], X_test, y_test) print(f"\n{name}:") for metric, value in metrics.items(): print(f" {metric}: {value:.3f}") ``` ## 5. Hyperparameter Optimalisatie voor Ensemble ```python from sklearn.model_selection import GridSearchCV # Optimaliseer gewichten voor custom ensemble param_grid = { 'weights': [ [0.2, 0.4, 0.4], [0.3, 0.3, 0.4], [0.4, 0.3, 0.3], [0.5, 0.25, 0.25] ] } grid_search = GridSearchCV( custom_voting, param_grid, cv=5, scoring='accuracy', n_jobs=-1 ) grid_search.fit(X_train, y_train) print("Beste gewichten:", grid_search.best_params_) print("Beste score:", grid_search.best_score_) ``` ## Belangrijke Overwegingen: 1. **Data Preprocessing**: Zorg voor consistente scaling voor alle modellen 2. **Class Imbalance**: Overweeg class_weight parameters of SMOTE voor onbalans 3. **Feature Importance**: Analyseer welke features het belangrijkst zijn 4. **Computational Efficiency**: Gebruik n_jobs=-1 voor parallelle verwerking 5. **Random State**: Zet random_state voor reproduceerbare resultaten ## Aanbevolen Volgende Stappen: 1. Experimenteer met verschillende gewichten 2. Voeg meer basismodellen toe (Random Forest, Gradient Boosting) 3. Implementeer stacking ensembles 4. Gebruik Bayesian optimization voor hyperparameter tuning 5. Analyseer misclassificaties voor verbeteringsmogelijkheden Deze aanpak geeft je een solide basis om verschillende ensemble-strategieën te vergelijken en te optimaliseren voor jouw kredietdataset.