Lär Er AI med Python · Lektion

Beslutsträd: teori och implementation

Gini-impuritet, informationsvinst, trädets djup och överanpassning – sklearn DecisionTreeClassifier.

Lektion 1 av 413 steg

Beslutsträd: teori och implementation är en gratis lektion i Lär Er AI med Python på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär Er AI med Python, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Vad är ett beslutsträd

Ett beslutsträd delar upp data i grenar baserat på egenskapsvärden och ställer ja- eller nej-frågor tills det når en förutsägelse vid en lövnod.

Varje intern nod testar en egenskap, varje gren motsvarar ett utfall och varje löv tilldelar en klass. Träd är enkla att tolka eftersom Ni kan följa beslutsvägen.

Gini-orenhet

Gini-orenhet mäter hur blandade klasserna är i en nod. En ren nod, där alla observationer tillhör samma klass, har Gini-värdet 0.

Formeln är Gini = 1 - sum(p_i^2), där p_i är andelen av klass i. Trädet väljer de uppdelningar som minskar orenheten mest.

import numpy as np

def gini(labels):
    classes, counts = np.unique(labels, return_counts=True)
    probs = counts / counts.sum()
    return 1 - np.sum(probs ** 2)

print(gini([0, 0, 1, 1]))   # 0.5 (max mix)
print(gini([0, 0, 0, 0]))   # 0.0 (pure)

Informationsvinst och entropi

Ett alternativt kriterium för uppdelning är informationsvinst, som bygger på entropi. Entropi är -sum(p_i * log2(p_i)).

Informationsvinst = entropi(förälder) - viktad entropi(barn). Gini och entropi ger vanligtvis liknande träd; Gini går något snabbare att beräkna.

import numpy as np

def entropy(labels):
    _, counts = np.unique(labels, return_counts=True)
    p = counts / counts.sum()
    return -np.sum(p * np.log2(p))

print(entropy([0, 0, 1, 1]))   # 1.0
print(entropy([0, 0, 0, 1]))   # ~0.81

Träna en DecisionTreeClassifier

Scikit-learn tillhandahåller DecisionTreeClassifier. Ni väljer uppdelningskriterium med parametern criterion (gini eller entropy).

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, random_state=0)

clf = DecisionTreeClassifier(criterion="gini", random_state=0)
clf.fit(Xtr, ytr)
print("Accuracy:", clf.score(Xte, yte))

Överanpassning och max_depth

Ett obegränsat träd växer tills varje löv är rent och memorerar brus. Det här innebär överanpassning.

Parametern max_depth begränsar hur djupt trädet får växa och tvingar det att generalisera. Mindre djup = enklare modell = mindre överanpassning.

from sklearn.tree import DecisionTreeClassifier

shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
deep = DecisionTreeClassifier(max_depth=None, random_state=0)
# shallow generalizes better on unseen data;
# deep often overfits the training set

Andra parametrar för förbeskärning

Utöver max_depth kan Ni styra tillväxten med:

min_samples_split minsta antal observationer för att dela en nod
min_samples_leaf minsta antal observationer i ett löv
max_leaf_nodes gräns för det totala antalet löv

Alla dessa minskar variansen och motverkar överanpassning.

from sklearn.tree import DecisionTreeClassifier

clf = DecisionTreeClassifier(
    max_depth=5,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=0,
)

Visualisera med plot_tree

plot_tree ritar ut hela trädet så att Ni kan läsa varje uppdelning, Gini-värdet och klassfördelningen i varje nod.

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
clf = DecisionTreeClassifier(max_depth=3).fit(X, y)

plt.figure(figsize=(12, 6))
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)
plt.show()

Egenskapernas betydelse

Efter träningen visar feature_importances_ hur mycket varje egenskap minskade orenheten över alla uppdelningar. Värdena summerar till 1.0.

Det här är ett snabbt sätt att rangordna vilka indata som är viktigast för modellen.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

data = load_iris()
clf = DecisionTreeClassifier(max_depth=3).fit(data.data, data.target)

for name, imp in zip(data.feature_names, clf.feature_importances_):
    print(f"{name}: {imp:.3f}")

Kostnadskomplexitetsbeskärning (ccp_alpha)

Efterbeskärning bygger först ett fullständigt träd och beskär sedan svaga grenar. Parametern ccp_alpha styr hur aggressiv beskärningen är: ett högre alfavärde tar bort fler noder.

Använd cost_complexity_pruning_path för att hitta möjliga alfavärden.

from sklearn.tree import DecisionTreeClassifier

base = DecisionTreeClassifier(random_state=0)
path = base.cost_complexity_pruning_path(Xtr, ytr)
alphas = path.ccp_alphas

pruned = DecisionTreeClassifier(ccp_alpha=0.01, random_state=0)
pruned.fit(Xtr, ytr)

Välj det bästa alfavärdet

För att välja ccp_alpha tränar Ni ett träd för varje möjligt alfavärde och jämför träffsäkerheten på valideringsdata. Det bästa alfavärdet balanserar träffsäkerhet och enkelhet.

from sklearn.tree import DecisionTreeClassifier

scores = []
for a in alphas:
    t = DecisionTreeClassifier(ccp_alpha=a, random_state=0)
    t.fit(Xtr, ytr)
    scores.append((a, t.score(Xte, yte)))

best = max(scores, key=lambda s: s[1])
print("Best alpha:", best[0])

Styrkor och svagheter

Fördelar: lättolkade, ingen skalning behövs, hanterar icke-linjära gränser och blandade datatyper.

Nackdelar: hög varians (små förändringar i data kan ändra trädet helt), benägna att överanpassa och använder endast axelparallella uppdelningar. Dessa svagheter motiverar ensemblemetoder som random forest-modeller.

Snabbtest

Testa Er förståelse av begreppen kring beslutsträd.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Sammanfattning: Beslutsträd delar upp data med hjälp av Gini-orenhet eller informationsvinst. Kontrollera överanpassning med förbeskärning (max_depth, min_samples_leaf) eller efterbeskärning (ccp_alpha). Inspektera modeller med plot_tree och feature_importances_. Deras höga varians motiverar ensemblemetoder.

Gratis att börja

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: 53
Lektioner: 225

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Beslutsträd: teori och implementation” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär Er AI med Python, inklusive ”Beslutsträd: teori och implementation”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Vad lär jag mig i ”Beslutsträd: teori och implementation”?

Gini-impuritet, informationsvinst, trädets djup och överanpassning – sklearn DecisionTreeClassifier. Ni övar på Lär Er AI med Python 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 Lär Er AI med Python?

Du behöver inga förkunskaper. Utbildningen i Lär Er AI med Python 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 1 av 4.

Hur lång tid tar lektionen ”Beslutsträd: teori och implementation”?

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 Lär Er AI med Python-lektionen?

Ja. Varje Lär Er AI med Python-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

← Tillbaka till Lär Er AI med Python