0Pricing
Learn AI with Python · Lekcja

Drzewa decyzyjne: teoria i implementacja

Nieczystość Giniego, przyrost informacji, głębokość drzewa i przeuczenie — sklearn DecisionTreeClassifier.

Drzewa decyzyjne: teoria i implementacja to bezpłatna lekcja Learn AI with Python na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn AI with Python, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Czym jest drzewo decyzyjne

Drzewo decyzyjne dzieli dane na gałęzie na podstawie wartości cech, zadając pytania typu tak/nie, aż dotrze do predykcji w węźle liścia.

Każdy węzeł wewnętrzny sprawdza jedną cechę, każda gałąź oznacza wynik, a każdy liść przypisuje klasę. Drzewa są łatwe do interpretacji, ponieważ można prześledzić ścieżkę kolejnych decyzji.

Nieczystość Giniego

Nieczystość Giniego mierzy stopień wymieszania klas w węźle. Czysty węzeł, zawierający obiekty tylko jednej klasy, ma wartość Gini równą 0.

Wzór ma postać Gini = 1 - sum(p_i^2), gdzie p_i oznacza udział obiektów klasy i. Drzewo wybiera podziały, które najbardziej zmniejszają nieczystość.

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)

Przyrost informacji i entropia

Alternatywnym kryterium podziału jest przyrost informacji, oparty na entropii. Entropię oblicza się jako -sum(p_i * log2(p_i)).

Przyrost informacji = entropia rodzica - ważona entropia dzieci. Zarówno Gini, jak i entropia zwykle prowadzą do powstania podobnych drzew; wartość Gini oblicza się nieco szybciej.

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

Trenowanie DecisionTreeClassifier

Biblioteka Scikit-learn udostępnia klasę DecisionTreeClassifier. Kryterium podziału wybiera się za pomocą parametru criterion (gini lub 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))

Przeuczenie i max_depth

Drzewo bez ograniczeń rośnie, aż każdy liść będzie czysty, zapamiętując szum w danych. Prowadzi to do przeuczenia.

Parametr max_depth ogranicza maksymalną głębokość drzewa, zmuszając je do uogólniania. Mniejsza głębokość = prostszy model = mniejsze przeuczenie.

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

Pozostałe parametry wstępnego przycinania

Oprócz max_depth wzrost drzewa można kontrolować za pomocą następujących parametrów:

  • min_samples_split — minimalna liczba próbek wymagana do podziału węzła
  • min_samples_leaf — minimalna liczba próbek w liściu
  • max_leaf_nodes — ograniczenie całkowitej liczby liści

Wszystkie te parametry zmniejszają wariancję i pomagają zapobiegać przeuczeniu.

from sklearn.tree import DecisionTreeClassifier

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

Wizualizacja za pomocą plot_tree

plot_tree rysuje całe drzewo, dzięki czemu można odczytać każdy podział, wartość Gini oraz rozkład klas w każdym węźle.

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()

Ważność cech

Po dopasowaniu modelu atrybut feature_importances_ informuje, w jakim stopniu każda cecha zmniejszyła nieczystość we wszystkich podziałach. Wartości sumują się do 1.0.

To szybki sposób na uszeregowanie danych wejściowych według ich znaczenia dla modelu.

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}")

Przycinanie według złożoności kosztu (ccp_alpha)

Przycinanie po treningu polega na wyhodowaniu pełnego drzewa, a następnie usunięciu słabych gałęzi. Parametr ccp_alpha określa intensywność przycinania: większa wartość alfa usuwa więcej węzłów.

Za pomocą cost_complexity_pruning_path można znaleźć kandydujące wartości alfa.

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)

Wybór najlepszej wartości alfa

Aby wybrać wartość ccp_alpha, należy wytrenować jedno drzewo dla każdej kandydującej wartości alfa i porównać dokładność na zbiorze walidacyjnym. Najlepsza wartość alfa równoważy dokładność i prostotę modelu.

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])

Zalety i wady

Zalety: łatwość interpretacji, brak potrzeby skalowania, obsługa nieliniowych granic i mieszanych typów danych.

Wady: duża wariancja (niewielkie zmiany danych mogą całkowicie zmienić drzewo), podatność na przeuczenie i wyłącznie podziały wyrównane do osi. Te słabości uzasadniają stosowanie metod zespołowych, takich jak lasy losowe.

Szybkie sprawdzenie

Sprawdźmy Państwa zrozumienie pojęć związanych z drzewami decyzyjnymi.

Podsumowanie

Podsumowanie: drzewa decyzyjne dzielą dane za pomocą nieczystości Giniego lub przyrostu informacji. Przeuczeniu można przeciwdziałać za pomocą wstępnego przycinania (max_depth, min_samples_leaf) albo przycinania po treningu (ccp_alpha). Modele można analizować za pomocą plot_tree i feature_importances_. Ich duża wariancja uzasadnia stosowanie metod zespołowych.

Często zadawane pytania

Czy lekcja „Drzewa decyzyjne: teoria i implementacja” jest bezpłatna?

Tak — pełny tekst „Drzewa decyzyjne: teoria i implementacja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn AI with Python, przejdź na CoddyKit PRO. Kurs Learn AI with Python zawiera 4 lekcji w sumie.

Co nauczysz się w „Drzewa decyzyjne: teoria i implementacja”?

Nieczystość Giniego, przyrost informacji, głębokość drzewa i przeuczenie — sklearn DecisionTreeClassifier. Ćwiczysz Learn AI with Python z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn AI with Python?

Nie wymagamy żadnego doświadczenia. Learn AI with Python w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Drzewa decyzyjne: teoria i implementacja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn AI with Python?

Tak. Każda lekcja Learn AI with Python zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Drzewa decyzyjne: teoria i implementacja
  2. Lasy losowe i bagging
  3. Gradient boosting: GBM i XGBoost
  4. LightGBM i CatBoost
← Powrót do Learn AI with Python