Trebaserte modeller: beslutningstrær og random forests
Bygg og finjuster modeller basert på beslutningstrær og ensemble-skog.
Trebaserte modeller: beslutningstrær og random forests er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 3 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 Python Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Python Academy inneholder totalt 4 leksjoner.
Begreper for beslutningstrær
Et beslutningstre deler data inn i delmengder ved å stille en rekke binære spørsmål. Hver intern node er en feature-terskel, og hvert blad er en prediksjon.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print("Depth:", model.get_depth())
print("Leaves:", model.get_n_leaves())DecisionTreeClassifier
Viktige hyperparametere er max_depth, min_samples_split og min_samples_leaf. Dypere trær overtilpasser, mens grunnere trær undertilpasser.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = DecisionTreeClassifier(max_depth=5, min_samples_leaf=5)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))DecisionTreeRegressor
Beslutningstrær kan også håndtere regresjon ved å predikere den gjennomsnittlige målverdien i hvert blad.
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
X, y = make_regression(noise=15, random_state=0)
model = DecisionTreeRegressor(max_depth=4).fit(X, y)
print("RMSE:", mean_squared_error(y, model.predict(X))**0.5)Feature-viktighet
model.feature_importances_ angir den relative viktigheten til hver feature, basert på reduksjonen i urenhet.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
model = DecisionTreeClassifier().fit(X, y)
for name, imp in sorted(zip(feature_names, model.feature_importances_), key=lambda x: -x[1]):
print(f"{name}: {imp:.3f}")Oversikt over Random Forest
En Random Forest trener mange lite korrelerte beslutningstrær på bootstrap-utvalg og beregner gjennomsnittet av prediksjonene deres – noe som reduserer variansen uten å øke skjevheten.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = RandomForestClassifier(n_estimators=100, random_state=0)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))RandomForestRegressor
Random forests fungerer like godt for regresjon.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import r2_score
X, y = make_regression(noise=10, random_state=0)
model = RandomForestRegressor(n_estimators=100, random_state=0).fit(X, y)
print("R²:", r2_score(y, model.predict(X)))Out-of-Bag-skår
Sett oob_score=True for å få en gratis valideringsskår ved hjelp av utvalg som ikke var med i bootstrap-utvalget til hvert tre (det er ikke nødvendig med et separat testsett).
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(random_state=0)
model = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=0).fit(X, y)
print("OOB score:", model.oob_score_)Gradient-boosting
Gradient-boosting (GBM) trener trær sekvensielt, der hvert tre korrigerer feilene fra det forrige. Metoden er ofte mer nøyaktig enn Random Forest, men tar lengre tid å trene.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = GradientBoostingClassifier(n_estimators=100).fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))XGBoost / LightGBM
XGBoost og LightGBM er optimaliserte biblioteker for gradient-boosting – raskere, mer skalerbare og ofte mer nøyaktige enn sklearns GBM.
# pip install xgboost lightgbm
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
xgb = XGBClassifier(n_estimators=100, eval_metric="logloss").fit(X_tr, y_tr)
print("XGB acc:", xgb.score(X_te, y_te))Justering av n_estimators
Flere trær i en Random Forest reduserer variansen (opp til et visst punkt) uten å føre til overtilpasning. Bruk en valideringskurve for å finne det optimale antallet.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(random_state=0)
for n in [10, 50, 100, 200]:
scores = cross_val_score(RandomForestClassifier(n_estimators=n, random_state=0), X, y, cv=5)
print(f"n={n}: {scores.mean():.3f}")Visualisering av et beslutningstre
Bruk sklearn.tree.plot_tree eller export_text for å undersøke hva treet har lært.
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=2).fit(X, y)
print(export_text(model, feature_names=load_iris().feature_names.tolist()))Kort kontroll
Hvordan reduserer en Random Forest overtilpasning sammenlignet med et enkelt beslutningstre?
Oppsummering
Beslutningstrær deler data etter feature-terskler og predikerer med verdier fra bladene. Juster max_depth for å kontrollere overtilpasning. Random Forest beregner gjennomsnittet av mange trær for å redusere variansen. Gradient-boosting trener trær sekvensielt for høy nøyaktighet. I produksjon bør De foretrekke XGBoost eller LightGBM.
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
- 76
- Leksjoner
- 320
Ofte stilte spørsmål
Er leksjonen «Trebaserte modeller: beslutningstrær og random forests» gratis?
Ja – hele teksten i «Trebaserte modeller: beslutningstrær og random forests» 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 Python Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Python Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Trebaserte modeller: beslutningstrær og random forests»?
Bygg og finjuster modeller basert på beslutningstrær og ensemble-skog. Du øver på Python 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 Python Academy?
Ingen tidligere erfaring er nødvendig. Python 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 3 av 4.
Hvor lang tid tar leksjonen «Trebaserte modeller: beslutningstrær og random forests»?
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 Python Academy-leksjonen?
Ja. Alle Python 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
- scikit-learn-API-et: fit, transform, predict
- Lineære modeller: regresjon og klassifisering
- Trebaserte modeller: beslutningstrær og random forests
- Modelevaluering og kryssvalidering