Rekursiv egenskapseliminering med kryssvalidering
Deltakere vil bruke RFECV til å la modellen selv stemme bort de minst nyttige egenskapene, samtidig som kryssvalideringsløkken beholdes for å forhindre lekkasje.
Rekursiv egenskapseliminering med kryssvalidering er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 4 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.
Begrensninger ved univariat utvalg
Univariate metoder for utvalg av egenskaper, som SelectKBest, evaluerer hver egenskap uavhengig. De overser viktige tilfeller: en egenskap som er ubrukelig alene, men svært verdifull i kombinasjon med en annen, eller to egenskaper som hver for seg er sterke, men svært redundante i kombinasjon. Recursive Feature Elimination (RFE) overvinner dette ved å bruke selve modellen til å vurdere egenskapsviktighet: Den tilpasser modellen med alle egenskapene, fjerner den minst viktige, tilpasser modellen på nytt, fjerner igjen og gjentar prosessen. Dette fanger opp hvordan egenskaper samspiller i modellen.
Slik fungerer RFE
RFE fungerer slik: (1) tren modellen med alle egenskapene; (2) ranger egenskapene etter viktighet (koeffisientenes størrelse for lineære modeller, feature_importances_ for trær); (3) fjern egenskapen med lavest rangering; (4) gjenta til ønsket antall egenskaper gjenstår. Ved hvert trinn beregnes rangeringen på nytt ved hjelp av modellen som er tilpasset de gjenværende egenskapene. Det betyr at egenskaper som virker svake når redundante konkurrenter er til stede, kan bli viktige når disse konkurrentene 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: velge antall egenskaper automatisk
RFECV (Recursive Feature Elimination with Cross-Validation) utvider RFE ved også å finne det optimale antallet egenskaper som skal beholdes. Den utfører RFE, samtidig som den bruker kryssvalidering ved hvert trinn for å skåre delmengden, og velger deretter antallet egenskaper som maksimerer CV-skåren. Dermed slipper De å angi n_features_to_select manuelt, og lekkasje under utvalget unngås fordi CV-sløyfen holder testfolden isolert.
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 støtte-masken
Etter tilpasningen er rfecv.support_ en boolsk matrise som angir hvilke av de opprinnelige egenskapene som ble valgt. rfecv.ranking_ angir elimineringsrangeringen (1 = valgt). De kan bruke rfecv.transform(X) til å bruke utvalget på nye data, slik at bare kolonnene som overlevde elimineringen, beholdes. Dette gjør RFECV til en direkte erstatning for SelectKBest i Pipelines.
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)Bruke RFE med trebaserte modeller
RFECV fungerer med alle modeller som eksponerer feature_importances_ (trebaserte modeller) eller coef_ (lineære modeller). Når RandomForestClassifier brukes som estimator, blir RFECV modellagnostisk på en kraftfull måte: Skogens egen vurdering av egenskapsviktighet styrer elimineringen. Dette er spesielt nyttig når den endelige modellen er en treensemblemodell, og De ønsker at utvalget av egenskaper skal samsvare med modellens 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: hindre lekkasje
En subtil risiko for lekkasje med RFECV oppstår når De bruker den med en lineær modell som krever skalering: De må skalere inne i kryssvalideringssløyfen. Hvis De skalerer hele datasettet før RFECV, ser skaleringen CV-testfolden under tilpasningen, slik at statistikk lekker inn. Den riktige fremgangsmåten er å plassere en StandardScaler før estimatoren i RFECVs interne estimator – men RFECV støtter ikke Pipeline-estimatorer direkte som grunпestimator. Et alternativ er å bruke et skaleringstrinn før RFECV, basert bare på treningsdataene, implementert i en egendefinert ytre Pipeline.
Step-parameteren: raskere, men grovere
Som standard eliminerer RFE én egenskap per runde, noe som krever N modelltilpasninger for N egenskaper. Hvis step settes til et større heltall eller en brøk (for eksempel eliminerer step=0.1 10 % av de gjenværende egenskapene per runde), reduseres antallet runder. Dette er avgjørende for data med mange dimensjoner: Med 1 000 egenskaper og step=1 krever RFE 1 000 modelltilpasninger per CV-fold. Med step=0.1 er omtrent 23 runder tilstrekkelig. Avveiningen er en grovere eliminering – en gruppe på 100 egenskaper fjernes samlet i stedet for én og én.
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_}')Sammenligne RFECV med SelectKBest
RFECV og SelectKBest dekker ulike behov. SelectKBest er rask, modellagnostisk og baserer seg på univariate korrelasjoner – den er et godt første trinn for store egenskapssett. RFECV er langsommere, men tar hensyn til interaksjoner mellom egenskaper (hvordan egenskapene virker sammen i modellen) og velger K automatisk. I praksis kan De bruke SelectKBest til å redusere antallet fra 1 000 til 100 egenskaper raskt, og deretter RFECV til å finne den optimale delmengden blant de 100. Å kombinere begge er raskere enn å bruke RFECV alene på data med mange dimensjoner.
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)')Når RFECV ikke er det beste valget
RFECV er beregningskrevende og har flere begrensninger. Metoden garanterer ikke en globalt optimal delmengde av egenskaper – grådig baklengs eliminering kan sette seg fast i lokale optima. Den er upraktisk for datasett med tusenvis av egenskaper, med mindre step er stor eller en rask estimator brukes. For svært høytdimensjonale, sparsomme data (NLP, genomikk) er L1-regularisering (Lasso, LinearSVC med L1) mer effektiv, fordi den setter koeffisienter til null matematisk uten gjentatte tilpasninger. RFECV fungerer best på datasett med middels mange dimensjoner (10–200 egenskaper), der iterasjon er gjennomførbart.
Utvalg av egenskaper i den fullstendige ML-arbeidsflyten
Utvalg av egenskaper ligger mellom forbehandling og modellering i pipelinen. Den anbefalte fullstendige arbeidsflyten er: (1) rens og kod rådata; (2) bruk VarianceThreshold; (3) bruk RFECV eller SelectKBest i en Pipeline; (4) tren og evaluer med kryssvalidering; (5) inspiser hvilke egenskaper som ble beholdt etter utvalget, og kontroller dem mot fagkunnskap. Utvalgte egenskaper som fageksperter ikke kan forklare, bør undersøkes for datalekkasje – noen ganger inneholder en egenskap informasjon om fremtiden som kunstig øker viktighetsskårene.
Verifisere valgte egenskaper med fageksperter
Etter at RFECV har identifisert den optimale delmengden av egenskaper, bør De alltid kontrollere utvalget med interessenter eller domeneeksperter. Presenter listen over valgte egenskaper og spør: «Gir det intuitivt mening at disse egenskapene predikerer målet?» Hvis en egenskap som «record ID» eller «timestamp of measurement» finnes blant de viktigste egenskapene, er det nesten helt sikkert et resultat av datalekkasjer. Hvis en åpenbart viktig egenskap (for eksempel «age» i en dødelighetsmodell) derimot ble fjernet, bør De undersøke hvorfor — den kan være korrelert med en annen valgt egenskap, eller det kan være et problem med datakvaliteten.
Hurtigsjekk
Test forståelsen Deres av rekursiv eliminering av egenskaper fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at: RFE iterativt fjerner den minst viktige egenskapen, slik modellen selv vurderer den, og fanger opp samspill mellom egenskaper, RFECV utvider RFE ved automatisk å finne det optimale antallet egenskaper ved hjelp av kryssvalidering, og step-parameteren styrer hvor mange egenskaper som fjernes per runde, og innebærer en avveining mellom presisjon og hastighet. De har nå fullført kurset i feature engineering og er klare til å utforske klynging og uovervåket læring.
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 «Rekursiv egenskapseliminering med kryssvalidering» gratis?
Ja – hele teksten i «Rekursiv egenskapseliminering med kryssvalidering» 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 «Rekursiv egenskapseliminering med kryssvalidering»?
Deltakere vil bruke RFECV til å la modellen selv stemme bort de minst nyttige egenskapene, samtidig som kryssvalideringsløkken beholdes for å forhindre lekkasje. 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 4 av 4.
Hvor lang tid tar leksjonen «Rekursiv egenskapseliminering med kryssvalidering»?
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
- Opprette nye egenskaper: Log-transformasjoner, kategorisering og interaksjoner
- Uthenting av egenskaper fra dato og klokkeslett
- Egenskapsutvelgelse: Variansgrense og SelectKBest
- Rekursiv egenskapseliminering med kryssvalidering