Random undersampling en ClusterCentroids
Cursisten samplen de meerderheidsklasse willekeurig en met ClusterCentroids under, en vergelijken het informatieverlies en de resulterende modelprestaties.
Random undersampling en ClusterCentroids is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 3 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.
Undersampling: de meerderheidsklasse verkleinen
Terwijl oversampling de minderheidsklasse uitbreidt, verkleint undersampling de meerderheidsklasse om de dataset in balans te brengen. Het belangrijkste voordeel is dat de training sneller verloopt, omdat er in totaal minder gegevens zijn. Het belangrijkste risico is dat je echte informatie over de meerderheidsklasse weggooit, waardoor het model mogelijk meer fout-positieve gevallen voorspelt. Undersampling is vooral nuttig wanneer de meerderheidsklasse zo groot is dat oversampling de training onaanvaardbaar traag zou maken.
Willekeurige undersampling: voorbeelden van de meerderheidsklasse willekeurig verwijderen
RandomUnderSampler selecteert willekeurig voorbeelden van de meerderheidsklasse en verwijdert deze totdat de gewenste verhouding is bereikt. Dit is de snelste methode voor undersampling, maar mogelijk nuttige informatie wordt weggegooid. Bij kleine datasets kan willekeurige undersampling het model aanzienlijk slechter maken doordat voorbeelden van de meerderheidsklasse in de buurt van de beslissingsgrens worden verwijderd.
from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05],
n_features=10, random_state=42)
print('Before undersampling:', np.bincount(y))
rus = RandomUnderSampler(sampling_strategy=1.0, random_state=42)
X_res, y_res = rus.fit_resample(X, y)
print('After undersampling:', np.bincount(y_res))
print('New total samples:', len(y_res))De samplingstrategie beheren
De parameter sampling_strategy bepaalt de uiteindelijke verhouding tussen de minderheids- en meerderheidsklasse. Met 1.0 worden ze gelijk; met 0.5 behoudt de meerderheidsklasse een voorsprong van 2:1. Voor zeer grote gegevensverzamelingen kun je 0.1 instellen voor een verhouding van 10:1 — nog altijd beter dan de oorspronkelijke 100:1, terwijl de training snel blijft. Kies dit op basis van de zakelijke kosten van fout-positieven tegenover fout-negatieven.
from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=10000, weights=[0.99, 0.01], random_state=42)
print('Original:', np.bincount(y))
for ratio in [1.0, 0.5, 0.2]:
rus = RandomUnderSampler(sampling_strategy=ratio, random_state=0)
_, y_r = rus.fit_resample(X, y)
counts = np.bincount(y_r)
print(f'ratio={ratio}: {counts} ({counts[1]/counts[0]:.2f} min:maj)')ClusterCentroids: intelligente undersampling
ClusterCentroids past K-Means-clustering toe op de meerderheidsklasse en vervangt elk cluster door zijn zwaartepunt. In plaats van willekeurige voorbeelden uit de meerderheidsklasse te behouden, houdt het een gecomprimeerde, representatieve verzameling over. Hierdoor blijft de algemene structuur van de meerderheidsklasse beter behouden dan bij willekeurig verwijderen, maar de methode is trager en vereist het afstemmen van het aantal clusters (dat na het opnieuw samplen gelijk is aan het gewenste aantal voorbeelden in de meerderheidsklasse).
from imblearn.under_sampling import ClusterCentroids
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.9, 0.1],
n_features=5, random_state=42)
print('Before:', np.bincount(y))
cc = ClusterCentroids(sampling_strategy=1.0, random_state=42)
X_cc, y_cc = cc.fit_resample(X, y)
print('After ClusterCentroids:', np.bincount(y_cc))
print('Note: synthetic centroids replace real majority samples')Undersamplingmethoden vergelijken
Laten we willekeurige undersampling, clusterzwaartepunten en geen resampling vergelijken op dezelfde onevenwichtige gegevensverzameling, met de F1-score van de minderheidsklasse als evaluatiemaatstaf.
from imblearn.under_sampling import RandomUnderSampler, ClusterCentroids
from imblearn.pipeline import Pipeline as ImbPipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import f1_score
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
sc = StandardScaler()
X_tr = sc.fit_transform(X_train)
X_te = sc.transform(X_test)
for name, sampler in [('None', None),
('RUS', RandomUnderSampler(random_state=0)),
('ClusterCentroids', ClusterCentroids(random_state=0))]:
if sampler:
Xr, yr = sampler.fit_resample(X_tr, y_train)
else:
Xr, yr = X_tr, y_train
lr = LogisticRegression().fit(Xr, yr)
f1 = f1_score(y_test, lr.predict(X_te))
print(f'{name:20s}: F1={f1:.4f} n_train={len(yr)}')Informatieverlies bij undersampling
Het belangrijkste nadeel van undersampling is informatieverlies. Wanneer 95 van elke 100 voorbeelden uit de meerderheidsklasse worden verwijderd, ziet het model tijdens de training een verdeling die sterk afwijkt van de werkelijkheid. Hierdoor kunnen de aantallen fout-positieven in productie toenemen. Daarom wordt undersampling vaak gecombineerd met oversampling (bijvoorbeeld met SMOTEENN of SMOTETomek) om de gegevensverzameling in balans te brengen en tegelijkertijd het informatieverlies te beperken.
Oversampling en undersampling combineren
SMOTETomek combineert SMOTE (de minderheidsklasse overbemonsteren) met het verwijderen van Tomek Links (dubbelzinnige voorbeelden aan de grens van de meerderheidsklasse opschonen). Het resultaat brengt beide klassen in balans en verwijdert voorbeelden uit de meerderheidsklasse aan de grens die de classificator in verwarring brengen. Deze gecombineerde aanpak presteert vaak beter dan alleen oversampling of undersampling.
from imblearn.combine import SMOTETomek
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
print('Before:', np.bincount(y))
st = SMOTETomek(random_state=42)
X_res, y_res = st.fit_resample(X, y)
print('After SMOTETomek:', np.bincount(y_res))Near Miss: geïnformeerde undersampling op basis van afstand
NearMiss selecteert voorbeelden uit de meerderheidsklasse op basis van hun afstand tot voorbeelden uit de minderheidsklasse — door de dichtstbijzijnde (NearMiss-1) of juist de verste (NearMiss-3) te kiezen. In tegenstelling tot willekeurige undersampling behoudt NearMiss de voorbeelden uit de meerderheidsklasse die het relevantst zijn voor het bepalen van de beslissingsgrens. NearMiss-3 behoudt de voorbeelden uit de meerderheidsklasse die het verst van alle voorbeelden uit de minderheidsklasse liggen, waardoor een schoner grensgebied ontstaat.
from imblearn.under_sampling import NearMiss
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.9, 0.1], random_state=42)
print('Before:', np.bincount(y))
for version in [1, 2, 3]:
nm = NearMiss(version=version)
_, y_nm = nm.fit_resample(X, y)
print(f'NearMiss-{version}:', np.bincount(y_nm))Undersampling binnen een imblearn-pijplijn
Net als oversampling moet undersampling binnen een pijplijn plaatsvinden om gegevenslekken tijdens kruisvalidatie te voorkomen. Gebruik imblearn.pipeline.Pipeline met de undersampler als stap vóór de classificator. De fit_resample van de sampler wordt op elke trainingsvouw aangeroepen en testvouwen worden nooit aangepast.
from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.under_sampling import RandomUnderSampler
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
pipe = ImbPipeline([
('sc', StandardScaler()),
('rus', RandomUnderSampler(random_state=42)),
('lr', LogisticRegression())
])
scores = cross_val_score(pipe, X, y, cv=5, scoring='f1')
print(f'CV F1 (RUS): {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Wanneer kies je undersampling in plaats van oversampling
Kies bij voorkeur undersampling wanneer: de meerderheidsklasse enorm is (miljoenen voorbeelden), de trainingstijd een knelpunt vormt of de beschikbare rekenmiddelen beperkt zijn. Kies bij voorkeur oversampling (SMOTE) wanneer: de minderheidsklasse zeer klein is (minder dan enkele honderden voorbeelden), het verwijderen van gegevens uit de meerderheidsklasse de trainingsverzameling te klein zou maken of de minderheidsklasse een complexe, niet-convexe structuur heeft die SMOTE kan aanvullen. Probeer in de praktijk beide methoden en vergelijk ze op validatiemaatstaven.
Evalueren na undersampling
Evalueer na het opnieuw samplen altijd op de oorspronkelijke onevenwichtige testgegevensset — nooit op een opnieuw gesamplede testgegevensset. Het opnieuw samplen van de testgegevens zou een onrealistisch beeld van de prestaties in productie geven. Het doel is het gedrag van het model op de werkelijke gegevensverdeling te verbeteren, niet het optimaliseren voor een kunstmatig gebalanceerde verdeling.
from sklearn.metrics import classification_report
from imblearn.under_sampling import RandomUnderSampler
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42)
sc = StandardScaler()
X_train_s = sc.fit_transform(X_train)
X_test_s = sc.transform(X_test)
rus = RandomUnderSampler(random_state=0)
X_r, y_r = rus.fit_resample(X_train_s, y_train)
lr = LogisticRegression().fit(X_r, y_r)
# Evaluate on ORIGINAL imbalanced test set
print(classification_report(y_test, lr.predict(X_test_s)))Korte controle
Toets je begrip van undersampling en Cluster Centroids uit deze les.
Samenvatting van de les
In deze les heb je geleerd: RandomUnderSampler verwijdert willekeurig voorbeelden uit de meerderheidsklasse — snel, maar met het risico dat belangrijke informatie over de grens verloren gaat; ClusterCentroids vervangt clusters uit de meerderheidsklasse door hun zwaartepunten om de klassendistributie getrouwer te behouden; en evalueer altijd op de oorspronkelijke onevenwichtige testgegevensset om het gedrag van het model in de praktijk te meten. Hierna bekijken we klasseweging en het verschuiven van de drempel als alternatieven voor resampling.
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 “Random undersampling en ClusterCentroids” gratis?
Ja — de volledige tekst van “Random undersampling en ClusterCentroids” 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 “Random undersampling en ClusterCentroids”?
Cursisten samplen de meerderheidsklasse willekeurig en met ClusterCentroids under, en vergelijken het informatieverlies en de resulterende modelprestaties. 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 3 van 4.
Hoe lang duurt de les “Random undersampling en ClusterCentroids”?
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
- Onbalans detecteren: klassenverdeling en valkuilen van baselines
- Random oversampling en SMOTE
- Random undersampling en ClusterCentroids
- Klassegewichten en drempelverschuiving