Rekursiv eliminering av egenskaper med korsvalidering
Ni kommer att använda RFECV för att låta modellen själv rösta bort de minst användbara egenskaperna, samtidigt som korsvalideringsloopen bevaras för att förhindra läckage.
Rekursiv eliminering av egenskaper med korsvalidering är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Begränsningar med univariat urval
Univariata metoder för featureurval, som SelectKBest, utvärderar varje feature individuellt. De missar viktiga fall: en feature som är oanvändbar på egen hand men mycket värdefull i kombination med en annan, eller två features som var och en är starka men mycket redundanta tillsammans. Recursive Feature Elimination (RFE) övervinner detta genom att använda själva modellen för att bedöma featurebetydelse: den tränar modellen med alla features, tar bort den minst betydelsefulla, tränar om modellen, tar bort nästa och fortsätter så. På detta sätt fångas hur features samverkar i modellen.
Så fungerar RFE
RFE fungerar på följande sätt: (1) träna modellen med alla features; (2) rangordna features efter betydelse (koefficienternas storlek för linjära modeller, feature_importances_ för träd); (3) ta bort den lägst rankade featuren; (4) upprepa tills önskat antal features återstår. Vid varje steg beräknas rangordningen på nytt med modellen som tränats på de återstående features. Det innebär att features som verkar svaga när redundanta konkurrenter finns kvar kan bli viktiga när konkurrenterna har tagits bort.
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älj antal features automatiskt
RFECV (Recursive Feature Elimination with Cross-Validation) utökar RFE genom att även fastställa det optimala antalet features att behålla. RFE utförs samtidigt som korsvalidering används vid varje steg för att poängsätta delmängden. Därefter väljs det antal features som maximerar CV-poängen. Det eliminerar behovet av att manuellt ange n_features_to_select och förhindrar informationsläckage under urvalet, eftersom CV-slingan håller testfolden isolerad.
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 och support-masken
Efter träningen är rfecv.support_ en boolesk array som anger vilka ursprungliga features som valdes ut. rfecv.ranking_ anger elimineringsrankningen (1 = vald). Ni kan använda rfecv.transform(X) för att tillämpa urvalet på nya data och behålla endast de kolumner som överlevde elimineringen. Det gör RFECV till en direkt ersättning för SelectKBest inuti 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)Använda RFE med träd-baserade modeller
RFECV fungerar med alla modeller som tillhandahåller feature_importances_ (trädmodeller) eller coef_ (linjära modeller). Om Ni använder en RandomForestClassifier som estimator blir RFECV på ett kraftfullt sätt modelloberoende: skogens egen bedömning av featurebetydelse styr elimineringen. Detta är särskilt användbart när den slutliga modellen är en trädensemble och Ni vill att featureurvalet ska överensstämma med modellens interna rangordning.
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: förhindra informationsläckage
Det finns en subtil risk för informationsläckage med RFECV: när Ni använder det med en linjär modell som kräver skalning måste Ni skala inuti korsvalideringsslingan. Om Ni skalar hela datasetet före RFECV ser skalaren CV-testfolden under träningen, vilket läcker statistik. Det korrekta tillvägagångssättet är att placera en StandardScaler före estimatern inuti RFECV:s interna estimator – men RFECV stöder inte Pipeline-estimatorer direkt som basestimator. Ett alternativ är att använda ett skalningssteg före RFECV, enbart på träningsdata, implementerat i en anpassad yttre Pipeline.
Stegparametern: snabbare men grövre
Som standard eliminerar RFE en feature per omgång, vilket kräver N modellträningar för N features. Om step sätts till ett större heltal eller en andel (exempelvis eliminerar step=0.1 10 % av de återstående features per omgång) minskar antalet omgångar. Detta är avgörande för högdimensionella data: med 1 000 features kräver RFE med step=1 1 000 modellträningar per CV-fold. Med step=0.1 räcker ungefär 23 omgångar. Nackdelen är en grövre eliminering – en grupp på 100 features tas bort tillsammans i stället för en i taget.
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_}')Jämförelse mellan RFECV och SelectKBest
RFECV och SelectKBest fyller olika behov. SelectKBest är snabbt, modelloberoende och arbetar med univariata korrelationer – det är ett bra första steg för stora featureuppsättningar. RFECV är långsammare men tar hänsyn till featureinteraktioner (hur features fungerar tillsammans i modellen) och väljer automatiskt K. I praktiken kan Ni använda SelectKBest för att snabbt minska antalet från 1 000 till 100 features och därefter RFECV för att förfina urvalet från 100 till den optimala delmängden. Att kombinera båda är snabbare än att använda enbart RFECV för högdimensionella data.
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 inte är det bästa valet
RFECV är beräkningskrävande och har flera begränsningar. Det garanterar inte en globalt optimal featuredelmängd – girig bakåteliminering kan fastna i lokala optimum. Det är opraktiskt för dataset med tusentals features om inte step är stort eller en snabb estimator används. För mycket högdimensionella glesa data (NLP, genomik) är L1-regularisering (Lasso, LinearSVC med L1) effektivare, eftersom den matematiskt sätter koefficienter till noll utan upprepad omträning. RFECV fungerar bäst på dataset med medelhög dimensionalitet (10–200 features), där iteration är genomförbar.
Featureurval i hela ML-arbetsflödet
Featureurval placeras mellan förbehandling och modellering i pipelinen. Det rekommenderade fullständiga arbetsflödet är: (1) rensa och koda rådata; (2) tillämpa VarianceThreshold; (3) tillämpa RFECV eller SelectKBest inuti en Pipeline; (4) träna och utvärdera med korsvalidering; (5) efter urvalet undersöka vilka features som behölls och verifiera dem med domänkunskap. Valda features som domänexperter inte kan förklara bör undersökas med avseende på informationsläckage – ibland kodar en feature framtida information som artificiellt höjer betydelsepoängen.
Verifiera valda features med domänexperter
När RFECV har identifierat den optimala delmängden av funktioner bör ni alltid verifiera urvalet med intressenter eller domänexperter. Presentera listan över valda funktioner och fråga: ”Är det intuitivt rimligt att dessa funktioner förutsäger målet?” Om en funktion som ”post-ID” eller ”tidpunkt för mätningen” finns bland de viktigaste funktionerna är det nästan säkert en artefakt av dataläckage. Omvänt bör ni undersöka varför en uppenbart viktig funktion (till exempel ”ålder” i en mortalitetsmodell) togs bort — den kan vara korrelerad med en annan vald funktion, eller så kan det finnas ett problem med datakvaliteten.
Snabbtest
Testa era kunskaper om rekursiv eliminering av funktioner från den här lektionen.
Sammanfattning av lektionen
I den här lektionen lärde ni er att: RFE iterativt tar bort den minst viktiga funktionen enligt modellen själv och fångar upp samspel mellan funktioner, RFECV utökar RFE genom att automatiskt hitta det optimala antalet funktioner med hjälp av korsvalidering, och parametern step styr hur många funktioner som tas bort per omgång och innebär en avvägning mellan precision och hastighet. Ni har nu slutfört kursen i Feature Engineering och är redo att utforska klustring och oövervakad inlärning.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Rekursiv eliminering av egenskaper med korsvalidering” gratis?
Ja – hela texten till ”Rekursiv eliminering av egenskaper med korsvalidering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Rekursiv eliminering av egenskaper med korsvalidering”?
Ni kommer att använda RFECV för att låta modellen själv rösta bort de minst användbara egenskaperna, samtidigt som korsvalideringsloopen bevaras för att förhindra läckage. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Rekursiv eliminering av egenskaper med korsvalidering”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Skapa nya egenskaper: Logaritmtransformer, intervallindelning och interaktioner
- Extrahera egenskaper från datum och tid
- Egenskapsurval: Variansgräns och SelectKBest
- Rekursiv eliminering av egenskaper med korsvalidering