Rekursiv featureeliminering med krydsvalidering
De lærende bruger RFECV til at lade modellen selv fravælge de mindst nyttige features, samtidig med at krydsvalideringsløkken bevares for at forhindre datalæk.
Rekursiv featureeliminering med krydsvalidering er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Begrænsninger ved univariat udvælgelse
Univariate metoder til udvælgelse af egenskaber som SelectKBest evaluerer hver egenskab uafhængigt. De overser vigtige tilfælde: en egenskab, der er ubrugelig alene, men meget værdifuld i kombination med en anden, eller to egenskaber, der hver især er stærke, men meget redundante i kombination. Recursive Feature Elimination (RFE) overvinder dette ved at bruge selve modellen til at vurdere egenskabernes vigtighed: Den tilpasser modellen med alle egenskaber, fjerner den mindst vigtige, tilpasser modellen igen, fjerner endnu en og gentager processen. På den måde opfanges det, hvordan egenskaber interagerer i modellen.
Sådan fungerer RFE
RFE fungerer sådan: (1) Træn modellen med alle egenskaber; (2) rangér egenskaberne efter vigtighed (koefficientens størrelse for lineære modeller, feature_importances_ for træer); (3) fjern den lavest rangerede egenskab; (4) gentag, indtil det ønskede antal egenskaber er tilbage. Ved hvert trin beregnes rangeringen igen ved hjælp af modellen, der er tilpasset de resterende egenskaber. Det betyder, at egenskaber, der virker svage i nærvær af redundante konkurrenter, kan blive vigtige, når konkurrenterne fjernes.
from sklearn.feature_selection import RFE
from sklearn.svm import SVR
from sklearn.datasets import load_diabetes
import numpy as np
X, y = load_diabetes(return_X_y=True)
feature_names = load_diabetes().feature_names
# Select top 5 features
rfe = RFE(estimator=SVR(kernel='linear'), n_features_to_select=5)
rfe.fit(X, y)
print('Selected features:', [feature_names[i] for i in range(len(feature_names)) if rfe.support_[i]])
print('Feature rankings:', rfe.ranking_) # 1 = selectedRFECV: Vælg antallet af egenskaber automatisk
RFECV (Recursive Feature Elimination with Cross-Validation) udvider RFE ved også at bestemme det optimale antal egenskaber, der skal beholdes. Den udfører RFE og bruger samtidig krydsvalidering ved hvert trin til at vurdere delmængden. Derefter vælger den det antal egenskaber, der maksimerer scoren ved krydsvalidering. Det fjerner behovet for manuelt at angive n_features_to_select og forhindrer datalækage under udvælgelsen, fordi løkken til krydsvalidering holder testfolden isoleret.
from sklearn.feature_selection import RFECV
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = load_breast_cancer(return_X_y=True)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X) # scale first, then RFECV
rfecv = RFECV(
estimator=LogisticRegression(max_iter=1000),
step=1,
cv=5,
scoring='accuracy',
n_jobs=-1
)
rfecv.fit(X_scaled, y)
print('Optimal number of features:', rfecv.n_features_)
print('CV scores per feature count:', rfecv.cv_results_['mean_test_score'].round(4))RFECV og udvælgelsesmasken
Efter tilpasningen er rfecv.support_ et boolesk array, der angiver, hvilke af de oprindelige egenskaber der blev udvalgt. rfecv.ranking_ angiver elimineringsrangeringen (1 = udvalgt). Du kan bruge rfecv.transform(X) til at anvende udvælgelsen på nye data, så kun de kolonner, der overlevede elimineringen, beholdes. Det gør RFECV til en direkte erstatning for SelectKBest inde i Pipeline-objekter.
from sklearn.feature_selection import RFECV
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
import numpy as np
data = load_breast_cancer()
X, y = data.data, data.target
feature_names = data.feature_names
X_sc = StandardScaler().fit_transform(X)
rfecv = RFECV(LogisticRegression(max_iter=1000), cv=5, scoring='accuracy', n_jobs=-1)
rfecv.fit(X_sc, y)
selected = [feature_names[i] for i in range(len(feature_names)) if rfecv.support_[i]]
print(f'Selected {len(selected)} features:', selected)Brug af RFE med træsbaserede modeller
RFECV fungerer med alle modeller, der stiller feature_importances_ (træmodeller) eller coef_ (lineære modeller) til rådighed. Hvis du bruger en RandomForestClassifier som estimator, bliver RFECV på en effektiv måde modeluafhængig: Skovens egen vurdering af egenskabernes vigtighed styrer elimineringen. Det er især nyttigt, når den endelige model er en træsammensætning, og du vil have, at udvælgelsen af egenskaber stemmer overens med den endelige models interne rangering.
from sklearn.feature_selection import RFECV
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
X, y = load_breast_cancer(return_X_y=True)
rfecv = RFECV(
estimator=RandomForestClassifier(n_estimators=50, random_state=42),
step=1,
cv=5,
scoring='accuracy',
n_jobs=-1
)
rfecv.fit(X, y) # RF does not require scaling
print('Optimal features:', rfecv.n_features_)
print('Best CV score:', round(max(rfecv.cv_results_['mean_test_score']), 4))RFECV i en Pipeline: Forebyg datalækage
En subtil risiko for datalækage med RFECV opstår, når du bruger den sammen med en lineær model, der kræver skalering: Du skal skalere inde i løkken til krydsvalidering. Hvis du skalerer hele datasættet før RFECV, ser skaleringen CV-testfolden under tilpasningen, og statistik lækkes dermed. Den korrekte tilgang er at placere en StandardScaler før estimatoren i RFECV's interne estimator – men RFECV understøtter ikke direkte Pipeline-estimatorer som sin basismodel. Et alternativ er at udføre skalering før RFECV, men kun på træningsdata, implementeret i en brugerdefineret ydre Pipeline.
Step-parameteren: Hurtigere, men grovere
Som standard eliminerer RFE én egenskab pr. runde, hvilket kræver N modeltilpasninger for N egenskaber. Hvis du indstiller step til et større heltal eller en brøk (f.eks. eliminerer step=0.1 10 % af de resterende egenskaber pr. runde), reduceres antallet af runder. Det er afgørende for data med mange dimensioner: Med 1.000 egenskaber og step=1 kræver RFE 1.000 modeltilpasninger pr. CV-fold. Med step=0.1 er omkring 23 runder nok. Ulempen er en grovere eliminering – en gruppe på 100 egenskaber fjernes samlet i stedet for én ad gangen.
from sklearn.feature_selection import RFECV
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
import time
X, y = load_breast_cancer(return_X_y=True)
X_sc = StandardScaler().fit_transform(X)
for step in [1, 2, 5]:
start = time.time()
rfecv = RFECV(LogisticRegression(max_iter=1000), step=step, cv=5, n_jobs=-1)
rfecv.fit(X_sc, y)
print(f'step={step}: {round(time.time()-start,2)}s, optimal_features={rfecv.n_features_}')Sammenligning af RFECV og SelectKBest
RFECV og SelectKBest dækker forskellige behov. SelectKBest er hurtig, modeluafhængig og bygger på univariate korrelationer – den er et godt første trin for store egenskabssæt. RFECV er langsommere, men tager højde for interaktioner mellem egenskaber (hvordan egenskaber fungerer sammen i modellen) og vælger automatisk K. I praksis kan du bruge SelectKBest til hurtigt at reducere antallet fra 1000 til 100 egenskaber og derefter RFECV til at finjustere fra 100 til den optimale delmængde. En kombination af begge er hurtigere end RFECV alene på data med mange dimensioner.
from sklearn.feature_selection import SelectKBest, f_classif, RFECV
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_breast_cancer
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_sc = StandardScaler().fit_transform(X)
# Baseline: no selection
base = cross_val_score(LogisticRegression(max_iter=1000), X_sc, y, cv=5).mean()
# SelectKBest
X_skb = SelectKBest(f_classif, k=15).fit_transform(X_sc, y)
skb = cross_val_score(LogisticRegression(max_iter=1000), X_skb, y, cv=5).mean()
# RFECV
rfecv = RFECV(LogisticRegression(max_iter=1000), cv=5, n_jobs=-1).fit(X_sc, y)
rfe_score = rfecv.cv_results_['mean_test_score'].max()
print(f'All features: {base:.4f}')
print(f'SelectKBest(k=15): {skb:.4f}')
print(f'RFECV: {rfe_score:.4f} ({rfecv.n_features_} features)')Hvornår RFECV ikke er det bedste valg
RFECV er beregningsmæssigt dyr og har begrænsninger. Den garanterer ikke den globalt optimale delmængde af egenskaber – grådig eliminering bagfra kan sidde fast i lokale optima. Den er upraktisk for datasæt med tusindvis af egenskaber, medmindre step er stor, eller der bruges en hurtig estimator. For meget højdimensionelle, sparsomme data (NLP, genomik) er L1-regularisering (Lasso, LinearSVC med L1) mere effektiv, fordi den matematisk sætter koefficienter til nul uden gentagne tilpasninger. RFECV fungerer bedst på datasæt med mellemstor dimension (10-200 egenskaber), hvor gentagelserne er overkommelige.
Udvælgelse af egenskaber i den samlede ML-arbejdsgang
Udvælgelse af egenskaber ligger mellem forbehandling og modellering i arbejdsgangen. Den anbefalede samlede arbejdsgang er: (1) Rens og kod rådata; (2) anvend VarianceThreshold; (3) anvend RFECV eller SelectKBest inde i en Pipeline; (4) træn og evaluer med krydsvalidering; (5) undersøg efter udvælgelsen, hvilke egenskaber der blev beholdt, og kontrollér dem ved hjælp af domæneviden. Udvalgte egenskaber, som domæneeksperter ikke kan forklare, bør undersøges for datalækage – nogle gange indeholder en egenskab fremtidig information, som kunstigt øger vigtighedsscorerne.
Kontrollér de udvalgte egenskaber sammen med domæneeksperter
Når RFECV har identificeret det optimale udsnit af egenskaber, skal du altid verificere udvælgelsen med interessenter eller domæneeksperter. Præsenter listen over de valgte egenskaber, og spørg: »Giver det intuitivt mening, at disse egenskaber forudsiger målet?« Hvis en egenskab som »post-id« eller »tidspunkt for måling« optræder blandt de vigtigste egenskaber, er det næsten helt sikkert et resultat af datalækage. Hvis en åbenlyst vigtig egenskab derimod blev fjernet, f.eks. »alder« i en model til forudsigelse af dødelighed, skal du undersøge hvorfor — den kan være korreleret med en anden valgt egenskab, eller der kan være et problem med datakvaliteten.
Hurtigt tjek
Test din forståelse af rekursiv eliminering af egenskaber fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært, at RFE iterativt fjerner den mindst vigtige egenskab, vurderet af selve modellen, og dermed tager højde for samspil mellem egenskaber, at RFECV udvider RFE ved automatisk at finde det optimale antal egenskaber ved hjælp af krydsvalidering, og at parameteren step styrer, hvor mange egenskaber der fjernes pr. runde, hvilket er et kompromis mellem præcision og hastighed. Du har nu gennemført kurset i Feature Engineering og er klar til at udforske klyngedannelse og uden opsyn-læring.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Rekursiv featureeliminering med krydsvalidering” gratis?
Ja — hele teksten til “Rekursiv featureeliminering med krydsvalidering” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Rekursiv featureeliminering med krydsvalidering”?
De lærende bruger RFECV til at lade modellen selv fravælge de mindst nyttige features, samtidig med at krydsvalideringsløkken bevares for at forhindre datalæk. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.
Hvor lang tid tager lektionen “Rekursiv featureeliminering med krydsvalidering”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Oprettelse af nye features: Logtransformationer, binning og interaktioner
- Udtræk af features fra dato og tid
- Featureudvælgelse: VarianceThreshold og SelectKBest
- Rekursiv featureeliminering med krydsvalidering