Nieuwe features maken: logtransformaties, binning en interacties
Cursisten passen logtransformaties toe op scheve kolommen, delen continue waarden in ordinale categorieën in en vermenigvuldigen paren features om interactie-effecten vast te leggen.
Nieuwe features maken: logtransformaties, binning en interacties is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Waarom feature-engineering belangrijk is
Feature-engineering is het proces waarbij ruwe gegevens worden omgezet in representaties die patronen toegankelijker maken voor machinelearningmodellen. Zelfs het beste algoritme wordt beperkt door de kwaliteit van de invoerkenmerken. Het toevoegen van het juiste geconstrueerde kenmerk kan de modelnauwkeurigheid sterker verbeteren dan elke hoeveelheid afstemming van hyperparameters. De intuïtie hierachter: als je het model de juiste getallen geeft om mee te werken, kan het eenvoudigere, beter generaliseerbare regels leren dan wanneer het zelf complexe transformaties moet ontdekken.
Logtransformaties: scheve verdelingen beheersbaar maken
Veel grootheden uit de echte wereld — inkomen, huizenprijzen, bevolkingsomvang en transactiebedragen — volgen rechts-scheve verdelingen, waarbij de meeste waarden klein zijn maar enkele extreme waarden de staart uitrekken. Lineaire modellen en algoritmen die op afstanden zijn gebaseerd (KNN, SVM) presteren slecht met zulke kenmerken, omdat de grote waarden de afstandsberekeningen domineren. Het toepassen van np.log1p() (de logaritme van x+1, veilig voor nulwaarden) comprimeert de schaal, maakt de verdeling symmetrischer en vermindert de invloed van extreme uitschieters.
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
data = fetch_california_housing()
df = pd.DataFrame(data.data, columns=data.feature_names)
print('Population skewness (raw):', round(df['Population'].skew(), 2))
df['Population_log'] = np.log1p(df['Population'])
print('Population skewness (log): ', round(df['Population_log'].skew(), 2))
print('AveRooms skewness (raw):', round(df['AveRooms'].skew(), 2))
df['AveRooms_log'] = np.log1p(df['AveRooms'])
print('AveRooms skewness (log): ', round(df['AveRooms_log'].skew(), 2))Logtransformatie en modelprestaties
Het voordeel van het logtransformeren van scheve kenmerken is niet alleen visueel: het verbetert rechtstreeks de modelprestaties van algoritmen die normaal verdeelde kenmerken veronderstellen (lineaire/logistische regressie) of afstanden gebruiken (KNN, SVM). Voor boomgebaseerde modellen (beslisbomen, random forests en gradient boosting) is het voordeel kleiner, omdat bomen splitsen op drempelwaarden en van nature schaalinvariant zijn. Controleer de verbetering altijd met kruisvalidatie in plaats van aan te nemen dat de transformatie helpt.
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score
from sklearn.datasets import fetch_california_housing
import pandas as pd
data = fetch_california_housing()
X, y = pd.DataFrame(data.data, columns=data.feature_names), data.target
X_log = X.copy()
for col in ['Population', 'AveRooms', 'AveBedrms', 'AveOccup']:
X_log[col] = np.log1p(X_log[col])
for name, Xdata in [('Raw', X), ('Log-transformed', X_log)]:
rmse = np.sqrt(-cross_val_score(Ridge(), Xdata, y, scoring='neg_mean_squared_error', cv=5).mean())
print(f'{name} Ridge RMSE: {round(rmse, 4)}')Binning: continue kenmerken discretiseren
Binning (of bucketing) zet een continu kenmerk om in discrete categorieën. Zo kan leeftijd [0-100] bijvoorbeeld worden ingedeeld in [kind, tiener, volwassene, senior]. Dit kan helpen wanneer de relatie tussen een kenmerk en het doel niet-lineair is op een manier die op een stapfunctie lijkt: het model leert één coëfficiënt per bak in plaats van een lineaire helling te proberen modelleren. Pandas pd.cut() gebruikt bakken met gelijke breedte; pd.qcut() gebruikt bakken met gelijke frequentie (kwantielen), waarbij in elke bak evenveel voorbeelden terechtkomen.
import pandas as pd
import numpy as np
ages = pd.Series([5, 12, 18, 25, 45, 62, 80, 90])
# Equal-width bins
equal_bins = pd.cut(ages, bins=[0, 12, 18, 35, 60, 100],
labels=['child', 'teen', 'young_adult', 'adult', 'senior'])
print('Equal-width bins:', equal_bins.values)
# Quantile bins
quantile_bins = pd.qcut(ages, q=4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
print('Quantile bins:', quantile_bins.values)KBinsDiscretizer: binning met Sklearn voor pijplijnen
Voor gebruik in scikit-learn-pijplijnen biedt KBinsDiscretizer dezelfde functionaliteit met de standaard-API van fit/transform. De parameter strategy bepaalt de grenzen van de bakken: 'uniform' (gelijke breedte), 'quantile' (gelijke frequentie) of 'kmeans' (k-means-clustering op het kenmerk). De parameter encode bepaalt de indeling van de uitvoer: 'onehot' (schaarse one-hotmatrix), 'onehot-dense' of 'ordinal' (gehele labels).
from sklearn.preprocessing import KBinsDiscretizer
import numpy as np
X = np.array([[15], [25], [35], [45], [55], [65], [75]])
kbd = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile')
print('Original ages:', X.flatten())
print('Bin labels: ', kbd.fit_transform(X).flatten())
print('Bin edges: ', kbd.bin_edges_[0])Interactiekenmerken: combinaties vastleggen
Interactiekenmerken zijn producten of verhoudingen van bestaande kenmerken die effecten vastleggen die geen van beide kenmerken afzonderlijk kan uitdrukken. Zo legt rooms_per_person = total_rooms / population de woningdichtheid beter vast dan elk kenmerk afzonderlijk. Een lineair model kan niet zelf ontdekken dat room count × house age van belang is; je moet dat product expliciet maken. Domeinkennis is hierbij onmisbaar — vraag jezelf af: 'Welke combinatie van deze getallen zou een domeinexpert betekenisvol vinden?'
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
import numpy as np
data = fetch_california_housing()
df = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target
# Add meaningful interaction features
df['rooms_per_person'] = df['AveRooms'] / df['AveOccup'].clip(lower=0.1)
df['beds_per_room'] = df['AveBedrms'] / df['AveRooms'].clip(lower=0.1)
base_rmse = np.sqrt(-cross_val_score(make_pipeline(StandardScaler(), Ridge()), df[data.feature_names], y, cv=5, scoring='neg_mean_squared_error').mean())
enriched_rmse = np.sqrt(-cross_val_score(make_pipeline(StandardScaler(), Ridge()), df, y, cv=5, scoring='neg_mean_squared_error').mean())
print('Base RMSE:', round(base_rmse, 4))
print('Enriched RMSE:', round(enriched_rmse, 4))Polynomiale kenmerken: geautomatiseerde interacties
PolynomialFeatures uit scikit-learn automatiseert het genereren van interactie- en polynomiale termen. Met degree=2 maakt het alle producten van paren en kwadratische termen. Voor p oorspronkelijke kenmerken genereert het p(p+1)/2 interactiekenmerken plus p kwadratische kenmerken. Dit is krachtig voor lineaire modellen met gegevens met weinig dimensies, maar wordt rekenkundig onhaalbaar voor gegevens met veel dimensies (100 kenmerken → 5.050 interactietermen). Pas bij het gebruik van polynomiale kenmerken altijd kenmerkselectie of regularisatie toe.
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
for degree in [1, 2]:
model = make_pipeline(StandardScaler(), PolynomialFeatures(degree=degree, include_bias=False), Ridge())
rmse = np.sqrt(-cross_val_score(model, X, y, scoring='neg_mean_squared_error', cv=5).mean())
print(f'Degree {degree}: RMSE={round(rmse, 4)}, n_features={PolynomialFeatures(degree).fit_transform(X[:1]).shape[1]}')Verhoudingskenmerken: normaliseren voor schaal
Verhoudingskenmerken normaliseren ruwe aantallen met een relevante noemer, waardoor schaaleffecten verdwijnen. Voorbeelden: crime_rate = crimes / population, revenue_per_user = revenue / active_users, defect_rate = defects / total_units. Verhoudingen zijn informatief wanneer de teller en noemer onafhankelijk van elkaar variëren en de verhouding een betekenisvolle frequentie vastlegt die geen van beide afzonderlijk kan vastleggen. Bescherm je altijd tegen delen door nul met .clip(lower=epsilon) of door een kleine constante op te tellen.
Doelcodering: wanneer je voorzichtig moet zijn
Bij categorische kenmerken met een hoge kardinaliteit (honderden unieke waarden) maakt one-hotcodering te veel dimensies. Doelcodering vervangt elke categorie door het gemiddelde van het doel voor die categorie. Zo wordt het kenmerk 'city' vervangen door de gemiddelde verkoopprijs in elke stad. Dit is krachtig, maar gevoelig voor lekken als je het naïef toepast — de doelcodering moet uitsluitend op de trainingsgegevens worden berekend en op de testvouw worden toegepast. Gebruik TargetEncoder uit scikit-learn binnen een pijplijn voor een correcte implementatie.
De impact van kenmerkengineering evalueren
De juiste manier om te evalueren of een nieuw kenmerk helpt: (1) begin met een baseline-CV-score op de oorspronkelijke kenmerken; (2) voeg het nieuwe kenmerk toe binnen de trainingspijplijn; (3) vergelijk de CV-scores. Verbeteringen van >0,5% op een robuuste metriek (5-voudige CV-AUC of RMSE) zijn het behouden waard. Kenmerken die de prestaties verslechteren of geen verbetering laten zien, moet je verwijderen — irrelevante kenmerken voegen ruis toe en vertragen het trainen. Gebruik kenmerkbelang (uit boommodellen) of permutatiebelang om vast te stellen welke gemaakte kenmerken daadwerkelijk worden gebruikt.
Domeinkennis versus geautomatiseerde engineering
Feature-engineering kan handmatig worden uitgevoerd (met domeinkennis om specifieke kenmerken te maken) of automatisch (met hulpmiddelen zoals featuretools voor diepe kenmerksynthese of PolynomialFeatures van scikit-learn). Handmatige, door het domein gestuurde kenmerken presteren doorgaans beter dan geautomatiseerde benaderingen, omdat ze menselijk inzicht in de daadwerkelijke betekenis van de gegevens bevatten. Geautomatiseerde hulpmiddelen verkennen een veel grotere kenmerkenruimte en kunnen onverwachte interacties vinden, maar genereren ook veel nutteloze kenmerken die selectie vereisen. De beste werkwijze is om te beginnen met door het domein gestuurde kenmerken en daarna eventueel geautomatiseerde kandidaten toe te voegen en met kenmerkselectie te filteren.
Korte controle
Test je begrip van feature-engineering uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat: logtransformaties scheefheid verminderen en lineaire modellen beter laten werken met exponentieel verdeelde kenmerken, binning continue kenmerken discretiseert tot categorieën die stapsgewijze relaties vastleggen, en interactiekenmerken multiplicatieve effecten vastleggen die geen van beide kenmerken afzonderlijk kan uitdrukken. Hierna bekijken we hoe je kenmerken uit datum- en tijdkolommen haalt.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Nieuwe features maken: logtransformaties, binning en interacties” gratis?
Ja — de volledige tekst van “Nieuwe features maken: logtransformaties, binning en interacties” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “Nieuwe features maken: logtransformaties, binning en interacties”?
Cursisten passen logtransformaties toe op scheve kolommen, delen continue waarden in ordinale categorieën in en vermenigvuldigen paren features om interactie-effecten vast te leggen. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Nieuwe features maken: logtransformaties, binning en interacties”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Nieuwe features maken: logtransformaties, binning en interacties
- Features uit datum en tijd extraheren
- Featureselectie: Variance Threshold en SelectKBest
- Recursieve feature-eliminatie met crossvalidatie