Tilfeldig valg av egenskaper: Trikset i Random Forest
De vil konfigurere max_features i RandomForestClassifier, observere hvordan utvalg av egenskaper gjør trærne mindre korrelerte og se testnøyaktigheten øke.
Tilfeldig valg av egenskaper: Trikset i Random Forest 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.
Fra bagging til Random Forests
Et vanlig bagging-ensemble trener hvert tre på et annet bootstrap-utvalg, men alle trærne kan fortsatt bruke alle egenskapene når de velger et splittpunkt. Det betyr at den mest prediktive egenskapen vil dominere i hvert tre, slik at trærne blir svært korrelerte. Når korrelerte modeller gjennomsnittsberegnes, blir variansreduksjonen begrenset. Random Forests legger til ett ekstra grep: ved hvert splittpunkt vurderes bare et tilfeldig delutvalg av egenskaper. Dette reduserer korrelasjonen mellom trærne og forbedrer ensemblets generaliseringsevne betydelig.
Parameteren max_features
I RandomForestClassifier styrer parameteren max_features hvor mange egenskaper som er kandidater ved hvert splittpunkt. Vanlige valg er 'sqrt' (kvadratroten av det totale antallet egenskaper, standardverdien for klassifisering), 'log2' eller et heltall/desimaltall. For regresjon (RandomForestRegressor) er standardverdien 1.0 (alle egenskaper), mens 'sqrt' eller 0.33 er populære alternativer. Lavere verdier skaper mer varierte trær, men hvert enkelt tre blir noe svakere.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
for mf in ['sqrt', 'log2', 0.5, 1.0]:
rf = RandomForestClassifier(n_estimators=100, max_features=mf, random_state=42)
score = cross_val_score(rf, X, y, cv=5).mean()
print(f'max_features={str(mf):6s}: CV accuracy={score:.4f}')Hvorfor delutvalg av egenskaper reduserer korrelasjonen mellom trær
Se for Dem et datasett med én dominerende egenskap som predikerer etiketten langt bedre enn alle andre. Uten delutvalg av egenskaper vil hvert tre i ensemblet dele på denne egenskapen ved roten, slik at trærne blir nesten identiske. Gjennomsnittsberegning av identiske prediksjoner gir den samme prediksjonen – ingen variansreduksjon. Når bare sqrt(p) egenskaper er kandidater ved hver node, mangler den dominerende egenskapen i mange splitt, noe som tvinger trærne til å oppdage alternative prediktive mønstre og bli reelt forskjellige.
Trening av en RandomForestClassifier
Det er enkelt å bruke RandomForestClassifier fra scikit-learn. Man angir antallet trær med n_estimators, styrer treets kompleksitet med max_depth og aktiverer OOB-evaluering med oob_score=True. Modellen trener alle trærne parallelt når n_jobs=-1. Etter tilpasningen gir feature_importances_ et rangert mål på hvilke inndataegenskaper som bidro til prediksjonene på tvers av alle trærne.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
rf = RandomForestClassifier(
n_estimators=200,
max_features='sqrt',
oob_score=True,
n_jobs=-1,
random_state=42
)
rf.fit(X_train, y_train)
print('OOB score:', rf.oob_score_)
print('Test accuracy:', rf.score(X_test, y_test))Egenskapsbetydning fra Random Forest
Random Forests beregner egenskapsbetydning som den gjennomsnittlige reduksjonen i urenhet (Gini eller entropi) som skyldes splitt på den aktuelle egenskapen, vektet etter antallet eksempler som passerer gjennom hver node og beregnet som et gjennomsnitt på tvers av alle trærne. Dette gir en rask, global rangering av prediksjonskraft. Betydningene summerer seg til 1 og er tilgjengelige via rf.feature_importances_. De kan imidlertid være skjeve i favør av egenskaper med mange unike verdier, så betrakt dem som en nyttig heuristikk og ikke som en absolutt fasit.
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X, y = data.data, data.target
feature_names = data.feature_names
rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X, y)
importances = pd.Series(rf.feature_importances_, index=feature_names)
print(importances.sort_values(ascending=False).head(5))Sammenligning av Random Forest og ett enkelt tre
Et enkelt beslutningstre som trenes på hele datasettet, er svært følsomt for støy i treningsdataene – en endring i noen få eksempler kan endre trestrukturen drastisk. En random forest skaper ved å ta gjennomsnittet av hundrevis av slike følsomme trær en prediksjonsflate som er langt jevnere og mer robust. Denne sammenligningen er en av de tydeligste demonstrasjonene på hvordan mangfold i et ensemble gir bedre generalisering.
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
single = DecisionTreeClassifier(random_state=42)
forest = RandomForestClassifier(n_estimators=200, random_state=42)
print('Single tree CV:', np.round(cross_val_score(single, X, y, cv=5), 4))
print('Random forest CV:', np.round(cross_val_score(forest, X, y, cv=5), 4))Kontroll av treets dybde i en forest
Hvert tre i en Random Forest blir vanligvis bygget dypt (lav skjevhet, høy varians). Bagging korrigerer deretter variansen. For svært store datasett kan man likevel begrense max_depth eller min_samples_leaf for å redusere minnebruk og treningstid. Hvis max_depth=None brukes (standardverdien), får trærne vokse til alle bladene er rene. En grunn forest oppfører seg mer som et boosting-ensemble: grunnmodeller med lav varians som har problemer med å fange komplekse grenser. Det optimale punktet avhenger av støynivået i datasettet.
Random Forest for regresjon
RandomForestRegressor følger den samme algoritmen, men beregner gjennomsnittet av de predikerte tallverdiene fra hvert tre i stedet for å stemme over en klasseetikett. Standardverdien for max_features ved regresjon i moderne scikit-learn er 1.0, men det er ofte nyttig å bruke 'sqrt' eller en brøkdel. Regresjonsforests fungerer godt på tabelldata med ikke-lineære samspill og brukes ofte til prediksjon av boligpriser, prognoser for energiforbruk og andre problemer med kontinuerlige målvariabler.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
rfr = RandomForestRegressor(n_estimators=100, max_features='sqrt', n_jobs=-1, random_state=42)
rmse = np.sqrt(-cross_val_score(rfr, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print(f'Random Forest Regression RMSE: {rmse:.4f}')Varians i egenskapsbetydning
Fordi hvert tre ser et annet bootstrap-utvalg og andre delutvalg av egenskaper, kan egenskapsbetydningene som beregnes fra ulike kjøringer eller ulike forests variere. For mer pålitelige estimater av egenskapsbetydning kan man bruke permutasjonsbetydning (sklearn.inspection.permutation_importance), som måler hvor mye modellens nøyaktighet synker når verdiene til en egenskap stokkes tilfeldig. Permutasjonsbetydning fungerer for alle black-box-modeller og lider ikke av skjevheten mot egenskaper med mange unike verdier som urenhetsbaserte betydningsmål har.
from sklearn.inspection import permutation_importance
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import pandas as pd
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
rf = RandomForestClassifier(n_estimators=100, random_state=42).fit(X_train, y_train)
result = permutation_importance(rf, X_test, y_test, n_repeats=10, random_state=42)
print(pd.Series(result.importances_mean, index=load_breast_cancer().feature_names).sort_values(ascending=False).head(5))Justering av hyperparametere for Random Forests
De viktigste hyperparametrene i en Random Forest er n_estimators (flere er vanligvis bedre, frem til ytelsen flater ut), max_features (styrer reduksjonen av korrelasjon), max_depth og min_samples_leaf (styrer avveiningen mellom skjevhet og varians for hvert tre). Et rutenettsøk over max_features og min_samples_leaf er ofte tilstrekkelig, fordi n_estimators kan settes høyt og max_depth=None er en god standardverdi. Bruk OOB-skår for rask, omtrentlig justering før De går videre til full kryssvalidering.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
param_grid = {'max_features': ['sqrt', 'log2', 0.5], 'min_samples_leaf': [1, 3, 5]}
grid = GridSearchCV(RandomForestClassifier(n_estimators=100, random_state=42), param_grid, cv=5)
grid.fit(X, y)
print('Best params:', grid.best_params_)
print('Best CV score:', round(grid.best_score_, 4))Begrensninger ved Random Forests
Random Forests er kraftige, men har flere merkbare begrensninger. De er minnekrevende fordi hvert tre må lagres. Inferens er treg for svært store forests, siden hver prediksjon krever traversering av alle trærne. De er heller ikke best egnet for strukturerte tabelldata med mange irrelevante egenskaper, der gradient boosting ofte gir bedre resultater. Til slutt mangler Random Forests en naturlig mekanisme for å fange sekvensiell eller romlig struktur – for bilder eller tekst utkonkurreres de klart av metoder innen dyp læring.
Kort kontroll
Test forståelsen Deres av konseptene for valg av egenskaper i Random Forest fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært at Random Forests legger til delutvalg av egenskaper i bagging for å redusere korrelasjonen mellom trærne, at max_features styrer antallet egenskaper som er kandidater ved hvert splittpunkt, og at egenskapsbetydninger viser hvilke inndata som driver prediksjonene på tvers av forest-en. Neste tema er out-of-bag-feil som en gratis, innebygd valideringsmekanisme.
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 valg av egenskaper: Trikset i Random Forest» gratis?
Ja – hele teksten i «Tilfeldig valg av egenskaper: Trikset i Random Forest» 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 valg av egenskaper: Trikset i Random Forest»?
De vil konfigurere max_features i RandomForestClassifier, observere hvordan utvalg av egenskaper gjør trærne mindre korrelerte og se testnøyaktigheten øke. 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 valg av egenskaper: Trikset i Random Forest»?
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
- Bootstrap-aggregering (bagging) forklart
- Tilfeldig valg av egenskaper: Trikset i Random Forest
- Out-of-bag-feil: Gratis validering i skogen
- Stemmebaserte ensemblemodeller: Hard og myk avstemning