Gradient Boosting - XGBoost, LightGBM, CatBoost

W lekcji o scikit-learn zbudowałeś las losowy: sto drzew, sto tropicieli, każdy dostaje własną próbkę okazów i własny zestaw pomiarów, a na koniec wszyscy głosują. Pomysł działa świetnie, dopóki tropiciele mylą się w różnych miejscach - wtedy pomyłki się znoszą i większość ma rację.

Ale jest taki kwadrat sawanny, na którym cały las się wykłada. Młode hieny bywają dokładnie tak ciężkie jak wychudzona lwica, mają podobny obwód łapy i chodzą tym samym korytarzem. Sto niezależnych tropicieli, z których żaden nigdy nie rozmawiał z pozostałymi, popełni tam sto razy ten sam błąd. Głosowanie nie pomoże, bo większość myli się razem. I nie ma w lesie nikogo, kto by po naradzie powiedział: "spójrzcie, dwadzieścia okazów wciąż wpisujemy do złej rubryki, zajmijmy się nimi".

Brakuje Ci mechanizmu, który po każdym tropicielu bierze listę jego pomyłek i wysyła następnego specjalnie do tych pomyłek. Nie kolejnego niezależnego głosu, tylko poprawki tego, czego poprzednik nie umiał. Ten mechanizm nazywa się gradient boosting i to on stoi za większością zwycięskich rozwiązań w konkursach na danych tabelarycznych - takich jak Twój notes terenowy, gdzie każdy wiersz to jedno zwierzę, a każda kolumna jeden pomiar.

Kolejka zamiast narady

Zapamiętaj jedno zdanie, bo jest definicją całej techniki: gradient boosting łączy słabe modele sekwencyjnie, a każdy kolejny poprawia błędy poprzedniego.

Rozłóżmy je na trzy słowa. Słaby model to model ledwie lepszy od zgadywania - w praktyce bardzo płytkie drzewo decyzyjne, czasem dosłownie jedno pytanie i dwie odpowiedzi. Taki kikut sam z siebie jest bezużyteczny, ale za to szybki i trudno mu się przeuczyć. Sekwencyjnie znaczy jeden po drugim, w kolejce, a nie równolegle: drugi model nie może powstać, zanim pierwszy nie skończy pracy, bo dopiero wtedy wiadomo, co poszło źle. I wreszcie poprawia błędy poprzedniego - kolejny model nie uczy się na oryginalnych odpowiedziach, tylko na tym, o ile poprzednik się pomylił.

Ta pomyłka ma swoją nazwę: reszta (po angielsku residual), czyli prawdziwa wartość minus to, co model przewidział. Nazwa "gradient" bierze się stąd, że reszta jest matematycznie kierunkiem, w którym błąd spada najszybciej - kolejne drzewo idzie więc dokładnie tam, gdzie najbardziej się opłaca. Na szczęście do korzystania z boostingu ta matematyka nie jest potrzebna. Potrzebna jest intuicja kolejki, a tę najlepiej zbudować własnymi rękami.

Boosting na palcach: dwa kikuty i lista pomyłek

Zrobimy boosting ręcznie, na sześciu lwach o znanym wieku i znanej wadze, żebyś zobaczył mechanizm bez żadnej biblioteki poza tą, którą już znasz. Użyjemy

DecisionTreeRegressor

DecisionTreeClassifier

max_depth=1

fit

predict

Pierwszy tropiciel dostaje surowe dane: wiek w latach i wagę w kilogramach. Zaraz zobaczysz, co przewidział i jak bardzo się rozminął z prawdą.

1import numpy as np
2from sklearn.tree import DecisionTreeRegressor
3
4wiek = np.array([[1], [2], [3], [4], [5], [6]])
5waga_kg = np.array([40.0, 70.0, 100.0, 150.0, 170.0, 190.0])
6
7kikut_1 = DecisionTreeRegressor(max_depth=1)
8kikut_1.fit(wiek, waga_kg)
9
10przewidziane = kikut_1.predict(wiek)
11reszty = waga_kg - przewidziane
12
13print(przewidziane)                    # [ 70.  70.  70. 170. 170. 170.]
14print(reszty)                          # [-30.   0.  30. -20.   0.  20.]
15print(np.abs(reszty).sum())            # 100.0

Jedno pytanie, które zadał kikut, brzmiało "czy lew ma mniej niż trzy i pół roku". Wszystkim młodym przypisał 70 kg, wszystkim starszym 170 kg - i to naprawdę wszystko, co potrafi model o głębokości jeden. Ciekawa jest dopiero druga linia. Rocznemu lwu dołożył 30 kg za dużo, trzylatka zaniżył o 30 kg, a czterolatka o 20 kg. Suma bezwzględnych pomyłek wynosi 100 kg i to jest nasz punkt odniesienia. Zwróć uwagę, że tablica

waga_kg

Teraz najważniejszy ruch w całej lekcji. Drugi kikut dostaje te same wieki, ale w miejsce wag dostaje listę pomyłek pierwszego. Nie uczy się, ile lew waży. Uczy się, gdzie poprzednik chybił i w którą stronę.

1kikut_2 = DecisionTreeRegressor(max_depth=1)
2kikut_2.fit(wiek, reszty)
3
4poprawka = kikut_2.predict(wiek)
5razem = przewidziane + poprawka
6
7print(poprawka)                        # [-30.   6.   6.   6.   6.   6.]
8print(razem)                           # [ 40.  76.  76. 176. 176. 176.]
9print(np.abs(waga_kg - razem).sum())      # 76.0

Drugi kikut zauważył, że jeden okaz odstaje od reszty bardziej niż wszystkie inne, i zadał pytanie "czy to roczniak". Roczniakowi odejmuje 30 kg, każdemu innemu dokłada 6 kg. Po zsumowaniu obu przewidywań łączny błąd spadł ze 100 kg do 76 kg - a przecież dołożyliśmy tylko jedno dodatkowe pytanie.

Teraz najcenniejsze zdanie tej sekcji: pierwszy kikut nie został zmieniony ani przetrenowany. Nadal przewiduje 70 i 170, tak samo jak przed chwilą. Nie zmieniły się też

wiek

waga_kg

learning_rate

Czym gradient boosting nie jest

Nazwa brzmi tajemniczo, więc krąży wokół niej kilka nieporozumień. Rozprawmy się z nimi teraz, zanim wejdziemy w kod.

To nie jest rodzaj sieci neuronowej. W boostingu nie ma ani jednego neuronu, warstwy ani wagi połączenia, nie ma też propagacji wstecznej. Są drzewa decyzyjne, czyli łańcuchy pytań tak-nie, ustawione w szereg. Sieci neuronowe poznasz w następnej lekcji, przy PyTorch, i zobaczysz, że to zupełnie inna konstrukcja - a dla danych tabelarycznych zwykle słabsza od boostingu.

To nie jest metoda losowego wybierania cech. Losowanie cech i próbek to sztuczka z lasu losowego: tam każde drzewo dostaje inny wycinek danych właśnie po to, żeby drzewa były od siebie niezależne. Boosting też ma parametry

subsample

colsample_bytree

To wreszcie nie jest algorytm klasteryzacji. Klasteryzacja to uczenie nienadzorowane: nie ma żadnego

y

Trzy biblioteki, jeden pomysł

Ten sam pomysł zrealizowały niezależnie trzy zespoły i tak powstały trzy biblioteki, o których mówi ta lekcja. XGBoost to najstarsza i najbardziej rozpoznawalna, domyślny wybór na start. LightGBM od Microsoftu została napisana pod kątem szybkości na dużych zbiorach. CatBoost od Yandexu specjalizuje się w kolumnach tekstowych, czyli kategorycznych. Wszystkie trzy mówią czasownikami scikit-learn, które znasz -

fit

predict

score

Żadna nie wchodzi w skład scikit-learn, więc trzeba je doinstalować. Jedno polecenie w terminalu załatwia wszystkie trzy naraz.

1pip install xgboost lightgbm catboost

Instalacja pobiera skompilowane paczki, więc trwa chwilę i nie wymaga kompilatora. Zwróć uwagę, że nazwy pakietów do instalacji nie zawsze pokrywają się z nazwami do importu: pakiet

lightgbm

lgb

catboost

CatBoostClassifier

libomp

brew install libomp

Notes terenowy, na którym będziemy pracować

Potrzebujemy danych. Zbudujemy je sami, korzystając z generatora liczb losowych NumPy, który znasz z modułu o obliczeniach numerycznych:

np.random.default_rng(42)

normal

pd.concat

np.repeat

Jedna kolumna jest tu wstawiona przewrotnie.

godzina_obserwacji

1import numpy as np
2import pandas as pd
3
4rng = np.random.default_rng(42)
5
6def stado(n, waga, predkosc, ogon, ugryzienie):
7    return pd.DataFrame({
8        "waga": rng.normal(waga, waga * 0.30, n),
9        "predkosc": rng.normal(predkosc, predkosc * 0.25, n),
10        "dlugosc_ogona": rng.normal(ogon, ogon * 0.30, n),
11        "sila_ugryzienia": rng.normal(ugryzienie, ugryzienie * 0.35, n),
12        "godzina_obserwacji": rng.uniform(5, 19, n),
13    })
14
15X = pd.concat([
16    stado(200, 190, 58, 85, 650),     # lew
17    stado(200, 55, 110, 75, 475),     # gepard
18    stado(200, 60, 65, 30, 1100),     # hiena
19], ignore_index=True)
20
21y = np.repeat([0, 1, 2], 200)         # 0 = lew, 1 = gepard, 2 = hiena
22
23print(X.shape, y.shape)               # (600, 5) (600,)

Mamy sześćset okazów opisanych pięcioma liczbami i sześćset etykiet - kształty potwierdza

shape

X

y

XGBoost - cztery kroki, zawsze w tej samej kolejności

Praca z XGBoost ma cztery kroki i ich kolejność nie jest kwestią gustu.

Krok pierwszy: import. Nie ma z czego zbudować modelu, dopóki biblioteka nie jest wczytana. Krok drugi: hiperparametry, czyli liczby opisujące, jak model ma wyglądać - wpisujesz je do konstruktora w chwili tworzenia obiektu, więc musisz je znać wcześniej. Krok trzeci: trening metodą

fit

fit

Zacznijmy od kroku pierwszego. Import ma cztery kawałki: słowo kluczowe

import

xgboost

as

xgb

train_test_split

test_size=0.2

random_state=42

stratify=y

1import xgboost as xgb
2from sklearn.model_selection import train_test_split
3
4X_train, X_test, y_train, y_test = train_test_split(
5    X, y, test_size=0.2, random_state=42, stratify=y
6)
7
8print(X_train.shape, X_test.shape)    # (480, 5) (120, 5)

Czterysta osiemdziesiąt zwierząt idzie na trening, sto dwadzieścia zostaje w zamknięciu do egzaminu. Zwróć uwagę, że

train_test_split

X

Krok drugi to hiperparametry. Klasa

XGBClassifier

n_estimators

max_depth

learning_rate

subsample=0.8

colsample_bytree=0.8

random_state=42

1model = xgb.XGBClassifier(
2    n_estimators=100,        # dlugosc kolejki drzew
3    max_depth=6,             # ile pytan moze zadac jedno drzewo
4    learning_rate=0.1,       # jak mocno wchodzi kazda poprawka
5    subsample=0.8,           # procent okazow na drzewo
6    colsample_bytree=0.8,    # procent kolumn na drzewo
7    random_state=42,
8)
9
10print(model.n_estimators, model.max_depth)    # 100 6

Model istnieje, ale nie widział jeszcze ani jednego zwierzęcia - konstruktor zapisał wyłącznie ustawienia. Możesz je odczytać jako zwykłe atrybuty obiektu, co właśnie zrobiliśmy, i to jest cała zawartość modelu na tym etapie. Gdybyś teraz wywołał

predict

Krok trzeci i najkrótszy: trening.

fit

score

predict

1model.fit(X_train, y_train)
2
3print(f"Trafnosc: {model.score(X_test, y_test):.2%}")
4print(model.predict(X_test)[:8])

Trafność wypadnie w okolicach 97 procent - nie podaję dokładnej liczby, bo zależy ona od wersji biblioteki, więc uruchom kod i sprawdź u siebie. Ważniejsze jest to, czego

fit

model

X_train

y_train

fit

Kiedy przestać dokładać drzewa

Sto drzew wpisaliśmy z palca i nikt nie zagwarantował, że akurat tyle jest potrzebne. Przy zbyt krótkiej kolejce model nie zdąży się nauczyć, przy zbyt długiej zacznie się uczyć szumu z danych treningowych. Rozwiązaniem jest early stopping: ustawiasz kolejkę z dużym zapasem, a XGBoost po każdym drzewie sprawdza wynik na zbiorze walidacyjnym i przerywa, gdy przez zadaną liczbę rund nic się nie poprawia. Tę liczbę podaje parametr

early_stopping_rounds

fit

Potrzebny jest zbiór, na którym model będzie się kontrolował, i tu uwaga na pułapkę: nie może to być zbiór testowy. Gdyby XGBoost wybierał liczbę drzew, patrząc na egzamin, ten egzamin przestałby być uczciwy - model dostroiłby się do odpowiedzi, które ma potem odgadnąć. Dlatego odcinamy kawałek danych treningowych na osobny zbiór walidacyjny. Zbiór walidacyjny przekazujemy do

fit

eval_set

verbose=False

best_iteration

1X_fit, X_val, y_fit, y_val = train_test_split(
2    X_train, y_train, test_size=0.2, random_state=42, stratify=y_train
3)
4
5model_es = xgb.XGBClassifier(
6    n_estimators=500,
7    max_depth=6,
8    learning_rate=0.1,
9    early_stopping_rounds=10,
10    random_state=42,
11)
12model_es.fit(X_fit, y_fit, eval_set=[(X_val, y_val)], verbose=False)
13
14print("Najlepsze drzewo:", model_es.best_iteration)
15print(f"Trafnosc: {model_es.score(X_test, y_test):.2%}")

Zamówiliśmy pięćset drzew, a model zatrzymał się dużo wcześniej i to bez straty na trafności - dokładny numer zależy od wersji, więc znowu odsyłam Cię do własnego uruchomienia. Zwróć uwagę na jedną rzecz, która się nie zmieniła: zbiór testowy nie brał udziału w niczym. Nie widział go ani

fit

score

X_fit

X_train

Które pomiary naprawdę pracują

Krok czwarty rytuału. Model wytrenowany, więc można wreszcie zapytać, na czym oparł decyzje. Atrybut

feature_importances_

X_train

zip

1for nazwa, waznosc in zip(X_train.columns, model.feature_importances_):
2    print(f"{nazwa:>20}: {waznosc:.3f}")

Na samym dole listy wyląduje

godzina_obserwacji

Listę liczb łatwiej porównać wzrokiem niż w druku, dlatego XGBoost ma własną funkcję rysującą. Wywołanie ma sześć kawałków: skrót biblioteki

xgb

plot_importance

model

plt.show

1import matplotlib.pyplot as plt
2
3xgb.plot_importance(model)
4plt.show()

Dostaniesz poziomy wykres słupkowy z najważniejszą cechą na górze. Jeżeli cech masz kilkadziesiąt, dorzuć argument

max_num_features

plot_importance

feature_importances_

LightGBM - ten sam pomysł, szybsza maszyna

XGBoost radzi sobie świetnie, dopóki notes mieści się w pamięci. Gdy ekspedycja urośnie do milionów wierszy - a tak wygląda praca z odczytami czujników albo klatkami z setek fotopułapek - zaczyna doskwierać czas treningu, zwłaszcza że przy strojeniu trenujesz model dziesiątki razy. Wtedy sięga się po LightGBM, która na bardzo dużych zbiorach jest zazwyczaj szybsza od XGBoost.

Skąd ta przewaga? Z dwóch decyzji projektowych. Po pierwsze, LightGBM zamienia ciągłe pomiary na kubełki histogramu, więc zamiast rozważać każdą możliwą wartość progu, rozważa kilkaset kubełków - i robi to raz, a nie przy każdym drzewie. Po drugie, rozrasta drzewo liściowo: zamiast równo dobudowywać cały poziom, wybiera ten liść, który najbardziej zmniejszy błąd, i rozwija tylko jego. Dzięki temu przy tym samym budżecie obliczeń zbija błąd mocniej.

Dwie rzeczy trzeba tu powiedzieć wprost, bo łatwo o fałszywy wniosek. Nie jest prawdą, że obie biblioteki są równie szybkie - na dużych zbiorach różnica bywa kilkukrotna i jest łatwo mierzalna. Nie jest też prawdą, że któraś z nich nie radzi sobie z dużymi danymi: obie powstały właśnie do dużych danych i obie potrafią pracować na milionach wierszy. Rzecz w tym, że na bardzo dużych zbiorach LightGBM zwykle dochodzi do celu wcześniej. Nie próbuj tego zmierzyć na naszych sześciuset zwierzętach - przy takim rozmiarze dominują koszty startowe i stoper pokaże Ci przypadkowego zwycięzcę. Przewaga LightGBM ujawnia się dopiero przy setkach tysięcy i milionach wierszy.

Klasa nazywa się

LGBMClassifier

num_leaves

max_depth

min_child_samples

verbose=-1

1import lightgbm as lgb
2
3model_lgb = lgb.LGBMClassifier(
4    n_estimators=100,
5    max_depth=6,
6    learning_rate=0.1,
7    num_leaves=31,          # maksymalna liczba lisci w drzewie
8    min_child_samples=20,   # min. okazow potrzebnych na lisc
9    random_state=42,
10    verbose=-1,
11)
12model_lgb.fit(X_train, y_train)
13
14print(f"LightGBM: {model_lgb.score(X_test, y_test):.2%}")

Wynik będzie bardzo zbliżony do XGBoost i tak ma być - to ten sam algorytm, inaczej zaimplementowany. Popatrz na kod jeszcze raz i zobacz, co się nie zmieniło:

fit

X_train

y_train

score

n_estimators

max_depth

learning_rate

plot_importance

lgb

CatBoost - gdy w notesie są słowa

Zarówno XGBoost, jak i LightGBM czytają wyłącznie liczby. Tymczasem prawdziwy notes terenowy jest pełen słów: siedlisko to "sawanna", "busz" albo "rzeka", dieta to "mieso" albo "padlina". Dotąd radziłeś sobie z tym kodowaniem -

OneHotEncoder

CatBoost rozwiązuje ten problem inaczej: przyjmuje kolumny tekstowe wprost i sam zamienia je na liczby, wyliczając dla każdej kategorii statystykę z etykiet - i robi to w sposób odporny na podglądanie odpowiedzi. Dlatego jest domyślnym wyborem, gdy w danych dominują kategorie.

Dołóżmy więc do naszego notesu dwie kolumny tekstowe. Siedlisko w siedemdziesięciu procentach przypadków będzie zgadzać się z gatunkiem, a w pozostałych wypadnie losowo - taki notes jest bliższy prawdy niż idealny. Dieta rozdzieli hieny, bo to one żywią się padliną. Do wyboru między dwiema tablicami służy

np.where

1rng_kat = np.random.default_rng(7)
2teren = np.array(["sawanna", "busz", "rzeka"])
3
4zgodne = rng_kat.random(len(y)) < 0.7
5losowe = rng_kat.integers(0, 3, len(y))
6
7X_kat = X.copy()
8X_kat["habitat"] = teren[np.where(zgodne, y, losowe)]
9X_kat["diet"] = np.where(y == 2, "padlina", "mieso")
10
11print(X_kat[["habitat", "diet"]].head(3))

Ramka ma teraz siedem kolumn: pięć liczbowych i dwie tekstowe. Ważne, co się nie zmieniło -

X.copy()

X

copy

Teraz sam model. Klasa

CatBoostClassifier

iterations

n_estimators

depth

max_depth

cat_features

X_kat

X

verbose=False

random_seed

random_state

1from catboost import CatBoostClassifier
2
3Xk_train, Xk_test, yk_train, yk_test = train_test_split(
4    X_kat, y, test_size=0.2, random_state=42, stratify=y
5)
6
7model_cat = CatBoostClassifier(
8    iterations=100,
9    depth=6,
10    learning_rate=0.1,
11    cat_features=["habitat", "diet"],
12    verbose=False,
13    random_seed=42,
14)
15model_cat.fit(Xk_train, yk_train)
16
17print(f"CatBoost: {model_cat.score(Xk_test, yk_test):.2%}")

Model wytrenował się na kolumnach tekstowych bez jednej linijki kodowania z naszej strony - i to jest cała obietnica CatBoost. Zauważ, że podział zrobiliśmy z tym samym

random_state=42

stratify

Ważność cech CatBoost udostępnia metodą, a nie atrybutem - nazywa się

get_feature_importance

1for nazwa, waznosc in zip(Xk_train.columns, model_cat.get_feature_importance()):
2    print(f"{nazwa:>20}: {waznosc:.2f}")

Na liście zobaczysz obok siebie kolumny liczbowe i tekstowe, wycenione w tej samej walucie -

habitat

diet

get_feature_importance()

feature_importances_

Strojenie hiperparametrów - kto to ma wszystko przeklikać

Wróćmy do liczb, które wpisywaliśmy z palca. Dlaczego

max_depth

learning_rate

Od tego jest GridSearchCV z modułu

sklearn.model_selection

Działa tak:

param_grid

cv=3

scoring="accuracy"

n_jobs=-1

best_params_

best_score_

best_estimator_

1from sklearn.model_selection import GridSearchCV
2
3param_grid = {
4    "max_depth": [3, 6],
5    "learning_rate": [0.05, 0.1, 0.3],
6    "n_estimators": [50, 100],
7}
8
9grid = GridSearchCV(
10    xgb.XGBClassifier(random_state=42),
11    param_grid,
12    cv=3,
13    scoring="accuracy",
14    n_jobs=-1,
15)
16grid.fit(X_train, y_train)
17
18print(len(grid.cv_results_["params"]))    # 12
19print(grid.best_params_)
20print(f"Najlepszy wynik: {grid.best_score_:.2%}")
21
22best_model = grid.best_estimator_

Dwanaście kombinacji, bo dwa razy trzy razy dwa - i to jest liczba, którą warto policzyć w głowie przed uruchomieniem. Przy trzech foldach oznacza ona trzydzieści sześć treningów. Gdybyś dołożył czwarty parametr z czterema wartościami i podniósł

cv

GridSearchCV

fit

grid

best_estimator_

Skoro siatka rośnie tak szybko, jest alternatywa: zamiast sprawdzać wszystkie kombinacje, wylosuj ich ustaloną liczbę. Robi to

RandomizedSearchCV

scipy.stats

randint(3, 10)

uniform

uniform(0.01, 0.29)

n_iter

1from sklearn.model_selection import RandomizedSearchCV
2from scipy.stats import randint, uniform
3
4param_dist = {
5    "max_depth": randint(3, 10),
6    "learning_rate": uniform(0.01, 0.29),
7    "n_estimators": randint(50, 300),
8}
9
10random_search = RandomizedSearchCV(
11    xgb.XGBClassifier(random_state=42),
12    param_dist,
13    n_iter=20,
14    cv=3,
15    random_state=42,
16    n_jobs=-1,
17)
18random_search.fit(X_train, y_train)
19
20print(random_search.best_params_)

Dwadzieścia losowań zamiast pełnego przeglądu, a wynik zwykle nie odbiega od najlepszego z siatki. Nie podaję znalezionych wartości, bo zależą od losowania i wersji biblioteki - i to jest tu ważniejsza lekcja niż konkretne liczby: przy losowym przeszukiwaniu

random_state

Moja rekomendacja, @name, jest jednoznaczna: zaczynaj od

RandomizedSearchCV

GridSearchCV

Gdy i to przestanie wystarczać, sięgniesz po bibliotekę Optuna. Różni się tym, że nie losuje na ślepo: pamięta wyniki poprzednich prób i kolejne kombinacje dobiera tam, gdzie spodziewa się poprawy. Definiujesz w niej funkcję celu, która dla zadanego zestawu parametrów zwraca ocenę modelu, a Optuna wywołuje ją setki razy, sama zawężając poszukiwania. To narzędzie na później - najpierw opanuj dwa powyższe, bo w dziewięciu przypadkach na dziesięć wystarczą.

Zapamiętaj z tej lekcji jedno, @name: las losowy to narada tropicieli, którzy się nawzajem nie słuchają, a boosting to karawana, w której każdy kolejny idzie tropem pomyłek poprzednika - i dlatego dochodzi dalej, choć każdy z osobna widzi mniej.