Het verwerken van categorische gegevens in een Pandas DataFrame is essentieel voor het verbeteren van machine learning modellen. Hieronder bespreek ik de meest gebruikte methoden: label codering en one-hot codering, inclusief Python-codevoorbeelden en de impact op modelprestaties. 1. Label codering (Label Encoding) **Omschrijving:** Elke unieke categorie krijgt een integerwaarde toegewezen. Bijvoorbeeld: 'man' = 0, 'vrouw' = 1. **Voordelen:** Eenvoudig, geschikt voor ordinalische data. **Nadelen:** Kan de modelinterpretatie beïnvloeden bij nominale data doordat de model een rangorde ziet. **Python code:** ```python from sklearn.preprocessing import LabelEncoder le = LabelEncoder() df['geslacht_encoded'] = le.fit_transform(df['geslacht']) df['beroep_encoded'] = le.fit_transform(df['beroep']) ``` **Impact op prestaties:** - Kan snel zijn en minder geheugen gebruiken. - Kan problematisch zijn bij nominale categorische variabelen omdat het rangorde suggereert. --- 2. One-hot codering (OneHotEncoder) **Omschrijving:** Elke categorie wordt een aparte binaire kolom. Bijvoorbeeld: 'man' wordt [1,0], 'vrouw' [0,1]. **Voordelen:** Geen impliciete rangorde, geschikt voor nominale data. **Nadelen:** Kan veel meer kolommen genereren, wat de computationele complexiteit verhoogt. **Python code:** ```python from sklearn.preprocessing import OneHotEncoder ohe = OneHotEncoder(sparse=False, drop='first') # drop='first' om multicollineariteit te verminderen categorical_cols = ['geslacht', 'beroep'] encoded_features = ohe.fit_transform(df[categorical_cols]) encoded_df = pd.DataFrame(encoded_features, columns=ohe.get_feature_names_out(categorical_cols)) df = pd.concat([df, encoded_df], axis=1).drop(categorical_cols, axis=1) ``` **Impact op prestaties:** - Verbeterde interpretatie en geen rangorde-informatie. - Kan leiden tot hoge dimensies bij veel categorieën, wat de training kan vertragen, maar vaak resulteert in betere modelprestaties. --- 3. Gecombineerde methoden en verdere optimalisaties - Voor hoge cardinaliteit kan je technieken zoals target encoding overwegen. - Voor sommige modellen (zoals boompjes) kunnen label encodering voldoende zijn. - Voor neurale netwerken wordt one-hot of embedding vaak aanbevolen. **Samenvatting van de impact:** | Methode | Modelprestaties | Complexiteit | Geschikt voor | |----------------------|-----------------|--------------|--------------------------| | Label Encoding | Snel, eenvoudig | Laag | Ordinale data, snelheidskritisch | | One-hot encoding | Betere interpretatie, geen rangorde | Hoog | Nominale data, meeste modellen | | Target encoding | Kan prestatieverbeteringen geven bij hoge cardinaliteit | Matig | Zeer hoge cardinaliteit | **Kort samengevat:** - Gebruik label encoding voor ordinal data of snelle prototyping. - Gebruik one-hot encoding voor nominale data en wanneer interpretatie belangrijk is. - Overweeg meer geavanceerde technieken voor grote datasets met veel categorieën. --- Heeft u nog specifieke vragen over data of modellen?

Zeker! Ik help je met het behandelen van categorische variabelen in Pandas. Hier zijn de belangrijkste methoden met codevoorbeelden en uitleg over hun impact: ## 1. Label Encoding ```python import pandas as pd from sklearn.preprocessing import LabelEncoder # Voorbeeld DataFrame data = { 'geslacht': ['man', 'vrouw', 'man', 'vrouw', 'man'], 'beroep': ['leraar', 'arts', 'ingenieur', 'leraar', 'arts'] } df = pd.DataFrame(data) # Label Encoding toepassen label_encoder = LabelEncoder() df['geslacht_encoded'] = label_encoder.fit_transform(df['geslacht']) df['beroep_encoded'] = label_encoder.fit_transform(df['beroep']) print(df) ``` **Impact op modelprestaties:** - ✅ Goed voor ordinale data (waar volgorde belangrijk is) - ❌ Kan problemen veroorzaken bij nominale data (model kan denken dat hogere getallen belangrijker zijn) - Geschikt voor tree-based algoritmes (Random Forest, XGBoost) ## 2. One-Hot Encoding ```python # One-Hot Encoding met pandas df_onehot = pd.get_dummies(df, columns=['geslacht', 'beroep'], prefix=['geslacht', 'beroep']) print(df_onehot) # Of met sklearn from sklearn.preprocessing import OneHotEncoder import numpy as np onehot_encoder = OneHotEncoder(sparse_output=False) encoded_array = onehot_encoder.fit_transform(df[['geslacht', 'beroep']]) # Maak DataFrame van het resultaat encoded_df = pd.DataFrame( encoded_array, columns=onehot_encoder.get_feature_names_out(['geslacht', 'beroep']) ) print(encoded_df) ``` **Impact op modelprestaties:** - ✅ Elimineert ordinale assumpties - ❌ Kan leiden tot de "curse of dimensionality" bij veel categorieën - ❌ Verwijder één kolom om multicollineariteit te voorkomen (gebruik `drop_first=True`) ## 3. One-Hot Encoding met drop_first ```python # Voorkom multicollineariteit df_onehot_safe = pd.get_dummies(df, columns=['geslacht', 'beroep'], prefix=['geslacht', 'beroep'], drop_first=True) print(df_onehot_safe) ``` ## 4. Target Encoding (Mean Encoding) ```python # Stel we hebben een target variabele df['target'] = [1, 0, 1, 0, 1] # Target encoding voor 'beroep' beroep_target_mean = df.groupby('beroep')['target'].mean() df['beroep_target_encoded'] = df['beroep'].map(beroep_target_mean) print(df) ``` **Impact op modelprestaties:** - ✅ Zeer krachtig voor tree-based modellen - ❌ Kan overfitting veroorzaken (gebruik cross-validation) - ✅ Behoudt dimensionaliteit ## 5. Frequency Encoding ```python # Frequency encoding geslacht_freq = df['geslacht'].value_counts(normalize=True) beroep_freq = df['beroep'].value_counts(normalize=True) df['geslacht_freq_encoded'] = df['geslacht'].map(geslacht_freq) df['beroep_freq_encoded'] = df['beroep'].map(beroep_freq) print(df) ``` ## 6. Complete preprocessing pipeline ```python from sklearn.compose import ColumnTransformer from sklearn.pipeline import Pipeline from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split # Voorbereiding X = df[['geslacht', 'beroep']] y = df['target'] # Train/test split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Preprocessing pipeline preprocessor = ColumnTransformer( transformers=[ ('cat', OneHotEncoder(drop='first'), ['geslacht', 'beroep']) ]) # Complete pipeline met model pipeline = Pipeline([ ('preprocessor', preprocessor), ('classifier', RandomForestClassifier(random_state=42)) ]) # Training pipeline.fit(X_train, y_train) score = pipeline.score(X_test, y_test) print(f"Model accuracy: {score:.2f}") ``` ## Aanbevelingen per situatie: ### **Voor tree-based modellen (Random Forest, XGBoost):** ```python # Label encoding of target encoding werken vaak het beste from sklearn.preprocessing import OrdinalEncoder ordinal_encoder = OrdinalEncoder() X_encoded = ordinal_encoder.fit_transform(X) ``` ### **Voor lineaire modellen (Logistic Regression):** ```python # One-hot encoding is essentieel X_encoded = pd.get_dummies(X, drop_first=True) ``` ### **Bij veel categorieën:** ```python # Gebruik target encoding of frequency encoding om dimensionaliteit te beperken # Of overweeg categorieën samen te voegen ``` ## Prestatie-optimalisatie tips: 1. **Gebruik `sparse=True`** bij OneHotEncoder voor geheugenoptimalisatie 2. **Combineer zeldzame categorieën** in "other" groep 3. **Kies encoding op basis van je algoritme** 4. **Valideer altijd** met cross-validation De beste methode hangt af van je specifieke dataset en machine learning algoritme. Experimenteer met verschillende methoden en valideer de prestaties!