Natuurlijk! Hieronder vind je een stapsgewijze aanpak om je DataFrame te optimaliseren voor machine learning, inclusief codevoorbeelden en uitleg: ```python import pandas as pd from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.feature_selection import SelectKBest, f_regression from imblearn.over_sampling import SMOTE ``` ### 1. Kenmerkselectie **Reden:** Het selecteren van de meest relevante kenmerken vermindert overfitting en verbetert de modelprestaties. **Hoe:** Gebruik bijvoorbeeld `SelectKBest` met een passende statistische test (bijvoorbeeld `f_regression` voor regressieproblemen). ```python # Veronderstel dat 'target' de doelvariabele is X = df[['lengte', 'gewicht', 'leeftijd']] y = df['target'] # Kenmerkselectie toepassen selector = SelectKBest(score_func=f_regression, k=2) # kies de 2 beste kenmerken X_new = selector.fit_transform(X, y) # Verkrijg de geselecteerde kenmerken mask = selector.get_support() # Boolean mask van geselecteerde features geselecteerde_features = X.columns[mask] print("Geselecteerde kenmerken:", geselecteerde_features.tolist()) ``` ### 2. Omgaan met ongebalanceerde gegevens **Reden:** Bij classificatieproblemen kunnen ongebalanceerde klassen zorgen voor slechte prestaties. SMOTE synthetisch nieuwe voorbeelden genereren voor de minderheidsklasse. **Hoe:** ```python # Split de data eerst in training en test X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) # Pas SMOTE toe op de trainingsgegevens smote = SMOTE(random_state=42) X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train) ``` ### 3. Juiste gegevensschaal **Reden:** Veel algoritmen (zoals SVM, KNN, regresiemodellen) presteren beter als de gegevens geschaald zijn, omdat ze gevoelig zijn voor de schaal van features. **Hoe:** ```python scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train_resampled) X_test_scaled = scaler.transform(X_test) ``` ### Samenvatting: - **Kenmerkselectie:** Vermindert complexiteit en verbetert prestaties. - **Ongebalanceerde gegevens:** SMOTE zorgt voor een evenwichtiger dataset. - **Schaalverdeling:** StandardScaler brengt features op dezelfde schaal voor betere modeltraining. Hiermee heb je een DataFrame voorbereid voor machine learning met geoptimaliseerde features, gebalanceerde klassen en juiste schaal.

Hier is een gedetailleerde handleiding voor het optimaliseren van je Pandas DataFrame voor machine learning, met focus op de drie genoemde aspecten: ## 1. Kenmerkselectie (Feature Selection) ### Correlatie-analyse ```python import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.feature_selection import SelectKBest, f_classif # Laad je DataFrame (voorbeeld) # df = pd.read_csv('jouw_data.csv') # Correlatiematrix analyseren correlatie_matrix = df.corr() plt.figure(figsize=(8, 6)) sns.heatmap(correlatie_matrix, annot=True, cmap='coolwarm', center=0) plt.title('Correlatiematrix tussen kenmerken') plt.show() # Sterk gecorreleerde kenmerken identificeren (bijv. > 0.85) sterk_gecorreleerd = [] for i in range(len(correlatie_matrix.columns)): for j in range(i): if abs(correlatie_matrix.iloc[i, j]) > 0.85: colnaam = correlatie_matrix.columns[i] sterk_gecorreleerd.append(colnaam) print(f"Sterk gecorreleerde kenmerken: {sterk_gecorreleerd}") ``` **Reden**: Sterk gecorreleerde kenmerken kunnen multicollineariteit veroorzaken en het model onnodig complex maken. ### Selectie op basis van statistische significantie ```python # Stel dat je een doelvariabele 'doel' hebt # X = df[['lengte', 'gewicht', 'leeftijd']] # y = df['doel'] # Selecteer beste kenmerken met ANOVA F-test selector = SelectKBest(score_func=f_classif, k='all') selector.fit(X, y) # Scores weergeven kenmerk_scores = pd.DataFrame({ 'kenmerk': X.columns, 'score': selector.scores_ }).sort_values('score', ascending=False) print("Kenmerkrangschikking op basis van F-test:") print(kenmerk_scores) ``` ## 2. Omgaan met ongebalanceerde gegevens ### Analyse van klassenverdeling ```python from collections import Counter from sklearn.utils import resample # Analyseer klassenverdeling klasse_verdeling = Counter(y) print(f"Klassenverdeling: {klasse_verdeling}") plt.figure(figsize=(8, 5)) y.value_counts().plot(kind='bar') plt.title('Verdeling van doelklassen') plt.xlabel('Klasse') plt.ylabel('Aantal') plt.show() ``` ### Oplossingen voor ongebalanceerde data ```python from imblearn.over_sampling import SMOTE from imblearn.under_sampling import RandomUnderSampler # Methode 1: SMOTE (Synthetic Minority Over-sampling Technique) smote = SMOTE(random_state=42) X_balanced, y_balanced = smote.fit_resample(X, y) print(f"Verdeling na SMOTE: {Counter(y_balanced)}") # Methode 2: Combinatie van over- en undersampling over = SMOTE(sampling_strategy=0.5, random_state=42) under = RandomUnderSampler(sampling_strategy=0.8, random_state=42) X_balanced_comb, y_balanced_comb = over.fit_resample(X, y) X_balanced_comb, y_balanced_comb = under.fit_resample(X_balanced_comb, y_balanced_comb) print(f"Verdeling na combinatie: {Counter(y_balanced_comb)}") ``` **Reden**: Ongebalanceerde data kan leiden tot modellen die de meerderheidsklasse bevoordelen en de minderheidsklasse negeren. ## 3. Gegevensschaal optimaliseren ### Verschillende schaaltechnieken ```python from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler from sklearn.model_selection import train_test_split # Split data eerst X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) # Methode 1: StandardScaler (aanbevolen voor meeste gevallen) scaler_standard = StandardScaler() X_train_scaled = scaler_standard.fit_transform(X_train) X_test_scaled = scaler_standard.transform(X_test) # Methode 2: MinMaxScaler (voor neural networks) scaler_minmax = MinMaxScaler() X_train_minmax = scaler_minmax.fit_transform(X_train) X_test_minmax = scaler_minmax.transform(X_test) # Methode 3: RobustScaler (voor data met uitschieters) scaler_robust = RobustScaler() X_train_robust = scaler_robust.fit_transform(X_train) X_test_robust = scaler_robust.transform(X_test) ``` **Reden**: Verschillende schalen tussen kenmerken kunnen algoritmes beïnvloeden die afstandsberekeningen gebruiken (zoals SVM, KNN). ## Complete optimalisatiepijplijn ```python def optimaliseer_dataframe(df, doel_kolom): """ Complete optimalisatiepijplijn voor machine learning """ # 1. Voorbereiding X = df.drop(columns=[doel_kolom]) y = df[doel_kolom] # 2. Kenmerkselectie selector = SelectKBest(score_func=f_classif, k=2) # Selecteer top 2 kenmerken X_selected = selector.fit_transform(X, y) geselecteerde_kenmerken = X.columns[selector.get_support()] print(f"Geselecteerde kenmerken: {list(geselecteerde_kenmerken)}") # 3. Data splitsen X_train, X_test, y_train, y_test = train_test_split( X_selected, y, test_size=0.2, random_state=42, stratify=y ) # 4. Balanceren (alleen als nodig) if len(np.unique(y_train)) > 1 and max(Counter(y_train).values()) / min(Counter(y_train).values()) > 2: smote = SMOTE(random_state=42) X_train, y_train = smote.fit_resample(X_train, y_train) print("Data gebalanceerd met SMOTE") # 5. Schalen scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) return X_train_scaled, X_test_scaled, y_train, y_test, geselecteerde_kenmerken # Gebruik de functie # X_train, X_test, y_train, y_test, kenmerken = optimaliseer_dataframe(df, 'doel_kolom') ``` ## Belangrijkste redenen voor elke stap: 1. **Kenmerkselectie**: Vermindert overfitting, verbetert modelprestaties, reduceert rekentijd 2. **Data balanceren**: Zorgt voor eerlijke vertegenwoordiging van alle klassen 3. **Data schalen**: Zorgt voor consistente schaal tussen kenmerken, essentieel voor veel ML-algoritmes Deze aanpak zorgt voor robuuste en efficiënte gegevensvoorbereiding voor je machine learning modellen.