Tilfeldig oversampling og SMOTE
Deltakere vil bruke RandomOverSampler og SMOTE fra imbalanced-learn for å oversample minoritetsklassen og deretter evaluere om presisjon og gjenkalling forbedres.
Tilfeldig oversampling og SMOTE er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hvorfor oversampling hjelper ubalanserte modeller
Mange klassifikatorer lærer en skjev beslutningsgrense når treningsdataene domineres av én klasse – de ignorerer i praksis minoritetsklassen. Oversampling øker representasjonen av minoritetsklassen i treningsdataene og tvinger modellen til å vie den mer oppmerksomhet. To populære metoder er tilfeldig oversampling (duplisering av eksisterende minoritetsprøver) og SMOTE (syntetisering av nye prøver).
Tilfeldig oversampling: duplisering av minoritetsprøver
RandomOverSampler fra biblioteket imbalanced-learn dupliserer eksempler fra minoritetsklassen tilfeldig til ønsket klasseforhold er oppnådd. Metoden er enkel og effektiv, men de dupliserte prøvene tilfører ingen ny informasjon – modellen kan overtilpasse seg de gjentatte minoritetseksemplene hvis den ikke regulariseres nøye.
from imblearn.over_sampling import RandomOverSampler
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 resampling:', np.bincount(y))
ros = RandomOverSampler(random_state=42)
X_res, y_res = ros.fit_resample(X, y)
print('After resampling: ', np.bincount(y_res))Installere imbalanced-learn
imbalanced-learn er et scikit-learn-kompatibelt bibliotek for håndtering av klasseubalanse. Installer det med pip install imbalanced-learn. Det følger sklearn-API-et – samplere har fit_resample i stedet for fit_transform. Biblioteket integreres med sklearn Pipelines via imblearn.pipeline.Pipeline, som er en direkte erstatning og støtter samplere som trinn i pipelinen.
# pip install imbalanced-learn
from imblearn import __version__ as imb_version
from imblearn.over_sampling import RandomOverSampler, SMOTE
from imblearn.under_sampling import RandomUnderSampler
from imblearn.pipeline import Pipeline as ImbPipeline
print('imbalanced-learn version:', imb_version)SMOTE: syntetisk oversampling av minoritetsklassen
SMOTE (Synthetic Minority Oversampling TEchnique) oppretter nye syntetiske minoritetseksempler i stedet for å duplisere eksisterende. For hver minoritetsprøve finner SMOTE de k nærmeste minoritetsnaboene og oppretter nye punkter langs linjestykkene som forbinder dem. Disse syntetiske prøvene ligger i det indre av minoritetsklassens egenskapsrom og gir klassifikatoren rikere informasjon om minoritetsklassens grense.
SMOTE i praksis
Bruk imblearn.over_sampling.SMOTE. Viktige parametere: k_neighbors (standardverdi 5) – hvor mange minoritetsnaboer som skal vurderes. Parameteren sampling_strategy styrer målforholdet: 'auto' oversampler alle minoritetsklasser slik at de får samme antall som majoritetsklassen.
from imblearn.over_sampling import SMOTE
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 SMOTE:', np.bincount(y))
smote = SMOTE(k_neighbors=5, random_state=42)
X_res, y_res = smote.fit_resample(X, y)
print('After SMOTE:', np.bincount(y_res))
print('New shape:', X_res.shape)Sammenligning av tilfeldig oversampling og SMOTE
Tilfeldig oversampling kopierer ganske enkelt eksisterende data og er raskere; SMOTE syntetiserer nye data og har en tendens til å generalisere bedre. SMOTE kan imidlertid opprette urealistiske prøver hvis minoritetsklassen er svært sparsom, eller hvis egenskapene har komplekse samspill. For svært ikke-lineære problemer kan borderline-SMOTE eller ADASYN (Adaptive Synthetic Sampling) fungere bedre enn standard SMOTE.
from imblearn.over_sampling import RandomOverSampler, SMOTE
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
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_train_s = sc.fit_transform(X_train)
X_test_s = sc.transform(X_test)
for name, sampler in [('None', None), ('ROS', RandomOverSampler(random_state=0)),
('SMOTE', SMOTE(random_state=0))]:
if sampler:
X_r, y_r = sampler.fit_resample(X_train_s, y_train)
else:
X_r, y_r = X_train_s, y_train
lr = LogisticRegression().fit(X_r, y_r)
f1 = f1_score(y_test, lr.predict(X_test_s))
print(f'{name:6s}: F1={f1:.4f}')Bruke imbalanced-learn Pipeline
Den kritiske regelen er: Bruk bare SMOTE på treningsfolden, aldri på testfolden. imblearn.pipeline.Pipeline håndhever dette automatisk – SMOTEs fit_resample kalles under fit, men ikke under predict eller transform. Derfor må De bruke imblearn.pipeline.Pipeline, ikke sklearn sin, når De inkluderer en sampler.
from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.over_sampling import SMOTE
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()),
('smote', SMOTE(random_state=42)), # applied only during fit
('lr', LogisticRegression())
])
scores = cross_val_score(pipe, X, y, cv=5, scoring='f1')
print(f'CV F1: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Visualisering av SMOTE-prøver
I et todimensjonalt datasett kan De visualisere hvor SMOTE plasserer syntetiske prøver. De nye punktene ligger langs linjestykker mellom eksisterende minoritetsprøver i egenskapsrommet. Dette bekrefter at SMOTE interpolerer innenfor minoritetsklassens område – den ekstrapolerer ikke utenfor det.
import matplotlib.pyplot as plt
from imblearn.over_sampling import SMOTE
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, weights=[0.9, 0.1],
n_features=2, n_redundant=0,
n_informative=2, random_state=42)
smote = SMOTE(random_state=0)
X_res, y_res = smote.fit_resample(X, y)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
for ax, data, labels, title in [(ax1, X, y, 'Before SMOTE'),
(ax2, X_res, y_res, 'After SMOTE')]:
ax.scatter(data[labels==0, 0], data[labels==0, 1], label='Class 0', alpha=0.5)
ax.scatter(data[labels==1, 0], data[labels==1, 1], label='Class 1', alpha=0.5)
ax.set_title(title)
ax.legend()
plt.tight_layout()
plt.show()SMOTE-varianter: Borderline og ADASYN
Borderline-SMOTE genererer syntetiske prøver bare nær beslutningsgrensen (minoritetsprøver på grensen som ligger nærmest majoritetsklassen), slik at modellens oppmerksomhet rettes mot områdene der klassifiseringen er vanskeligst. ADASYN genererer adaptivt flere prøver i områder der klassifiseringen er vanskeligst, og tilfører proporsjonalt flere syntetiske eksempler der klassifikatoren har størst problemer.
from imblearn.over_sampling import BorderlineSMOTE, ADASYN
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))
bs = BorderlineSMOTE(random_state=0)
X_bs, y_bs = bs.fit_resample(X, y)
print('After BorderlineSMOTE:', np.bincount(y_bs))
adas = ADASYN(random_state=0)
X_ad, y_ad = adas.fit_resample(X, y)
print('After ADASYN:', np.bincount(y_ad))Kombinere SMOTE med undersampling (SMOTEENN)
SMOTE alene kan introdusere støyende prøver nær majoritetsklassens grense. SMOTEENN kombinerer SMOTE med opprydding ved hjelp av Edited Nearest Neighbours (ENN): Etter at SMOTE har oversamplet, fjerner ENN feilklassifiserte prøver fra begge klasser nær grensen. Resultatet er et renere datasett med både oversamplede minoritetsområder og rensede majoritetsområder.
from imblearn.combine import SMOTEENN
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))
smoteenn = SMOTEENN(random_state=42)
X_res, y_res = smoteenn.fit_resample(X, y)
print('After SMOTEENN:', np.bincount(y_res))Evaluering av SMOTE: avveiningen mellom precision og recall
Etter oversampling bør De alltid evaluere med mål som er følsomme for minoritetsklassen – F1-skåre, ROC-AUC eller PR-AUC. SMOTE forbedrer vanligvis recall (færre oversette positive tilfeller), men kan redusere precision (flere falske alarmer). Bruk precision-recall-kurven for å finne terskelen som gir ønsket driftspunkt, basert på den konkrete kostnaden ved falske positive versus falske negative.
Kort kontroll
Test forståelsen Deres av oversampling og SMOTE fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært: RandomOverSampler dupliserer minoritetseksempler – enkelt, men med risiko for overtilpasning til gjentatte data, SMOTE syntetiserer nye minoritetsprøver ved å interpolere mellom eksisterende prøver, noe som gir klassifikatoren rikere informasjon, og imblearn.pipeline.Pipeline sikrer at SMOTE bare brukes på treningsfolder, slik at datalekkasje hindres. Deretter utforsker vi undersamplingsteknikker som reduserer majoritetsklassen i stedet for å utvide minoritetsklassen.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Tilfeldig oversampling og SMOTE» gratis?
Ja – hele teksten i «Tilfeldig oversampling og SMOTE» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Tilfeldig oversampling og SMOTE»?
Deltakere vil bruke RandomOverSampler og SMOTE fra imbalanced-learn for å oversample minoritetsklassen og deretter evaluere om presisjon og gjenkalling forbedres. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Machine Learning Academy?
Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Tilfeldig oversampling og SMOTE»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?
Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Oppdage ubalanse: Klassefordeling og fallgruver ved baseline
- Tilfeldig oversampling og SMOTE
- Tilfeldig undersampling og klyngesentrumpunkter
- Klassevekter og flytting av terskelen