Który algorytm bierze koronę: Light GBM vs XGBOOST?

1. co to jest Light GBM?

Light GBM może być szybkim, rozproszonym, wysokowydajnym, wspomaganym gradientem ramowym algorytmem drzewa decyzyjnego, używanym do tworzenia rankingu, klasyfikacji i wielu innych zadań uczenia maszynowego.

Ponieważ jest to wspierany algorytm drzewa decyzyjnego, rozdziela on liść drzewa z najprostszym dopasowaniem, podczas gdy inne algorytmy zwiększające głębokość drzewa rozdzielają go mądrze lub poziomo zamiast liścia. Tak więc w przypadku uprawy na równorzędnym liściu w Light GBM, algorytm oparty na liściach może zredukować więcej strat niż algorytm oparty na poziomie i w ten sposób prowadzi do znacznie większej dokładności, która rzadko może być osiągnięta przez którykolwiek z dominujących algorytmów wzmacniających. Ponadto, jest to zaskakująco szybko, stąd słowo “Światło”.

Przed może być schematyczne przedstawienie przez producentów słonecznego GBM, aby wyjaśnić różnicę wyraźnie.

2. Zalety sunshine GBM

Większa szybkość treningu i lepsza wydajność: Lekki GBM wykorzystuje algorytm oparty na histogramach, tzn. wciąga wartości cech ciągłych do dyskretnych pojemników, które mocują procedurę treningową.

Mniejsze zużycie pamięci: Zastępuje wartości ciągłe w dyskretnych pojemnikach, które kończą się mniejszym zużyciem pamięci.

Większa dokładność niż w przypadku innego algorytmu wzmacniającego: Tworzy on o wiele bardziej złożone drzewa poprzez zastosowanie podejścia opartego na podziale na liście zamiast podejścia opartego na poziomie, które polega na tym, że głównym celem jest osiągnięcie większej dokładności. Czasami jednak może powodować overfitting, którego można uniknąć poprzez ustawienie parametru max_depth.

Zgodność z dużymi zbiorami danych: jest w stanie osiągać równie dobre wyniki z dużymi zbiorami danych przy dużej redukcji czasu szkolenia w porównaniu z XGBOOST.

Obsługiwane jest uczenie równoległe.

Instalacja Light GBM

Dla Windows

Korzystanie z Visual Studio (lub MSBuild)

-Instaluj git dla okien, cmake i MS Build (Nie potrzebujesz MSbuild, jeśli już zainstalowałeś Visual Studio).

-Wykonaj następującą komendę:

klon git –recursive https://github.com/Microsoft/LightGBM

cd LightGBM

konstrukcja mkdir

budowa płyty

cmake -DCMAKE_GENERATOR_PLATFORM=x64 …

cmake –build . –target ALL_BUILD –config Release

exe i dll będą w folderze LightGBM/Release.

Użycie MinGW64

-Git do okien, cmake i MinGW64.

-Obróć się zgodnie z rozkazem:

git clone –recursive https://github.com/Microsoft/LightGBM

cd LightGBM

konstrukcja mkdir

budowa płyty

cmake -G “MinGW Makefiles” …

mingw32-make.exe -j4

exe i dll będą w folderze LightGBM/.

Dla Linuksa

Lekki GBM wykorzystuje cmake do tworzenia . Biegnij dalej:

git clone –recursive https://github.com/Microsoft/LightGBM

cd LightGBM

konstrukcja mkdir

budowa płyty

cmake …

make -j4

Dla systemu OSX

LightGBM zależy od OpenMP przy kompilacji, który nie jest obsługiwany przez Apple Clang.Proszę użyć gcc/g++.

-Run po:

broww install cmake

piwowar zainstaluj gcc – bez multifilibu

git clone –recursive https://github.com/Microsoft/LightGBM

cd LightGBM

konstrukcja mkdir

budowa płyty

cmake …

make -j4

Teraz, zanim zanurkujemy w głowę do budowania naszego modelu GBM Dawn, pozwól nam sprawdzić kilka parametrów słonecznego GBM, aby mieć zrozumienie dla jego podstawowych procedur.

4. Ważne parametry Sunshine GBM

zadanie : wartość domyślna = pociąg ; opcje = pociąg , przewidywanie ; Określa zadanie, które chcemy wykonać, a które jest albo pociągiem albo przewidywaniem.

aplikacja: default=regresja, type=enum, options= options :

regresja : wykonaj zadanie regresji

binarne: Klasyfikacja binarna

Multiklasa: Klasyfikacja wieloklasowa

lambdarank : aplikacja lambdarank

data: type=string; training data , LightGBM będzie szkolić z tych danych

num_iterations: liczba iteracji pobudzających do wykonania ; default=100; type=int

num_leaves : liczba liści w jednym drzewie ; wartość domyślna = 31 ; typ =int

device : default= cpu ; options = gpu,cpu. Urządzenie, na którym chcielibyśmy trenować nasz model. Wybierz GPU dla szybszego treningu.

max_depth: Podaj maksymalną głębokość do której drzewo będzie rosło. Parametr ten jest wykorzystywany do wpływu na overfitting.

min_data_in_leaf: Min. ilość wiedzy w jednym liściu.

feature_fraction: domyślnie=1 ; określa ułamek cech, które mają być pobierane dla każdej iteracji.

bagging_fraction: domyślnie=1 ; określa ułamek wiedzy, który ma być użyty przy każdej iteracji i zazwyczaj nie przyspiesza treningu i nie pozwala uniknąć overfitu.

min_gain_to_split: domyślnie=.1 ; min. zysk do wykonania podziału

max_bin : maksymalna liczba pojemników do wiaderka wartości cech.

min_data_in_bin : min ilość wiedzy w jednym pojemniku

num_threads: default=OpenMP_default, type=int ;Number of threads for Light GBM.

label : type=string ;specify the label column

categorical_feature : type=string ; określ cechy specyficzne, które chcielibyśmy wykorzystać do szkolenia naszego modelu

num_class: default=1 ; type=int ; używane tylko do klasyfikacji wieloklasowej

Ponadto, poddaj się temu tekstowi wyjaśniającemu strojenie parametrów w XGBOOST intymnie .

5. LightGBM vs XGBoost

Porównajmy więc teraz LightGBM z XGBoost poprzez zastosowanie obu tych algorytmów do zbioru danych, a następnie porównanie wydajności.

Tutaj wykorzystujemy zbiór danych, który zawiera wiedzę o osobach z różnych krajów. Naszym celem jest przewidzenie, czy dana osoba robi 50k rocznie na podstawie dostępnych przeciwnych informacji. Zbiór danych składa się z 32561 obserwacji i 14 cech opisujących poszczególne osoby.

Tutaj znajduje się link do zbioru danych: http://archive.ics.uci.edu/ml/datasets/Adult.

Przejdź przez zbiór danych, aby mieć właściwą intuicję na temat zmiennych prognostycznych, a następnie po prostu zrozumiesz kod b#importowania standardowych bibliotek

importować zdrętwiały jak np.

import pand jako pd

z pandas import Series, DataFrame

#import lightgbm i xgboost

import lightgbm jako lgb

import xgboost jako xgb

#load our training dataset ‘adult.csv’ with name ‘data’ using pandas

data=pd.read_csv(‘adult.csv’,header=None)

#Przypisanie nazw do kolumn

data.columns=[“age”, “workclass”, “fnlwgt”, “education”, “education-num”, “marital_Status”, “occupation”, “relationship”, “race”, “sex”, “capital_gain”, “capital_loss”, “hours_per_week”, “native_country”, “Income”].

#glimpse of the dataset

data.head()

# Label Encoding our target variable

od sklearn.preprocessing import LabelEncoder, OneHotEncoder

l=LabelEncoder()

l.fit(dane.Przychody)

l.class_

data.Income=Seria(l.transform(data.Income))  #oznaczenie kodujące naszą zmienną docelową

data.Income.value_counts()

#One Hot Encoding of the Categorical features

one_hot_workclass=pd.get_dummies(data.workclass)

one_hot_education=pd.get_dummies(data.education)

one_hot_marital_Status=pd.get_dummies(data.marital_Status)

one_hot_occupation=pd.get_dummies(data.occupation)

one_hot_relationship=pd.get_dummies(data.relationship)

one_hot_race=pd.get_dummies(data.race)

one_hot_sex=pd.get_dummies(data.sex)

one_hot_native_country=pd.get_dummies(data.native_country)

#usuwanie cech kategorycznych

data.drop([“workclass”, “education”, “marital_Status”, “occupation”, “relationship”, “race”, “sex”, “native_country”], axis=1, inplace=True)

#Merging one hot encoded features with our dataset ‘data’

data=pd.concat([data,one_hot_workclass,one_hot_education,one_hot_marital_Status,one_hot_occupation,one_hot_relationship,one_hot_race,one_hot_sex,one_hot_native_country],axis=1)

#usuwanie kolumn dulpitowych

_, i = np.unique(data.columns, return_index=True)

data=data.iloc[:, i]

#Tutaj nasza zmienna docelowa to “Dochód” o wartości 1 lub 0.

#Rozdzielenie naszych danych na cechy zestawu danych x i naszego zestawu danych docelowych y

x=data.drop(“Dochód”, oś=1)

y=dane.Dochód

#Imputując brakujące wartości w naszej zmiennej docelowej

y.fillna(y.mode()[0],inplace=True)

#Teraz dzielimy nasz zestaw danych na testowe i pociągowe

z sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=.3)

#Applying xgboost(x,y,test_size=.3)

#Dane są przechowywane w obiekcie DMatrix

#oznaczenie jest używane do zdefiniowania naszej zmiennej wynikowej

dtrain=xgb.DMatrix(x_train,label=y_train)

dtest=xgb.DMatrix(x_test)

#ustalanie parametrów dla xgboost

parameters={‘max_depth’:7, ‘eta’:1, ‘silent’:1, ‘objective’:’binary:logistic’,’eval_metric’:’auc’,’learning_rate’:.05}

#Szkolenie naszego modelu

num_round=50

od datetime import datetime

start = datetime.now()

xg=xgb.train(parametry,dtrain,num_round)

Stop = datetime.now()

#Czas wykonania modelu

execution_time_xgb = stop-start

egzekucja_time_xgb

#datetime.timedelta( , , ) reprezentacja => (dni , sekundy , mikrosekundy)

#now predicting our model on test set

ypred=xg.predict(dtest)

ypred

#Zamieniając prawdopodobieństwa na 1 lub 0

dla i w zakresie (0,9769):

if ypred[i]>=.5: # setting threshold to .5

ypred[i]=1: jeśli ypred[i]>=.5: # ustawienie progu na .5

Inaczej:

ypred[i]=0

# obliczając dokładność naszego modelu

z sklearn.metrics import accuracy_score

accuracy_xgb = accuracy_score(y_test,ypred)

dokładność_xgb

# Light GBM

train_data=lgb.Dataset(x_train,label=y_train)

#ustalanie parametrów dla lightgbm

param = {“num_leaves”:150, “objective”: “binary”, “max_depth”:7, “learning_rate”:.05, “max_bin”:200}

param[“metric”] = [“auc”, “binary_logloss”]

#Tutaj ustawiliśmy max_depth w xgb i LightGBM na 7, aby mieć uczciwe porównanie między nimi.

#Trening naszego modelu przy użyciu light gbm

num_round=50

start=datetime.now()

lgbm=lgb.train(param,train_data,num_round)

stop=datetime.now()

#Czas wykonania modelu

execution_time_lgbm = stop-start

egzekucja_time_lgbm

#przewidywanie na zestawie testowym

ypred2=lgbm.predict(x_test)

ypred2[0:5] # pokazując pierwsze 5 przewidywań

#zamieniając prawdopodobieństwa na 0 lub 1

dla i w zakresie (0,9769):

jeśli ypred2[i]>=.5: # ustawienie progu na .5

ypred2[i]=1: jeśli ypred2[i]>=.5: # ustawienie progu na .5

Inaczej:

ypred2[i]=0

#okładność obliczeniowa

accuracy_lgbm = accuracy_score(ypred2,y_test)

dokładność_lgbm

y_test.value_counts()

z sklearn.metrics import roc_auc_score

#calc_auc_score for xgboost

auc_xgb = roc_auc_score(y_test,ypred)

auc_xgb

#c_auc_score for light gbm.

auc_lgbm = roc_auc_score(y_test,ypred2)

auc_lgbm comparison_dict = {‘accuracy score’:(accuracy_lgbm,accuracy_xgb),’auc score’:(auc_lgbm,auc_xgb),’execution time’:(execution_time_lgbm,execution_time_xgb)}

#Creating a dataframe ‘comparison_df’ for comparing the performance of Lightgbm and xgb.

comparison_df = DataFrame(comparison_dict)

comparison_df.index= [“LightGBM”, “xgboost”]

porównanie_poprawnie.

Porównanie wydajności

https://cdn.analyticsvidhya.com/wp-content/uploads/2017/06/11200955/result.png

Nastąpił tylko niewielki wzrost dokładności i wyniku auc poprzez zastosowanie Light GBM ponad XGBOOST, ale jest duża różnica w czasie wykonywania procedury treningowej. Light GBM jest prawie 7 razy szybszy niż XGBOOST i może być znacznie lepszym podejściem przy obsłudze dużych zbiorów danych.

Wydaje się, że jest to ogromna zaleta w przypadku wykonywania na dużych zbiorach danych w ograniczonym czasie zawodów.

6. Tuning Parametry słonecznego GBM

Lekki GBM stosuje rozłupywanie skrzydłowe na głębokość rozłupywania, co pozwala na znacznie szybsze jego zbieganie się, ale również powoduje jego przepełnienie. Tak więc tutaj może być szybki przewodnik, aby dostosować parametry w Light GBM.

Dla najlepszego dopasowania

num_leaves : Ten parametr jest stosowany do wyświetlania w wierszu ilości liści, które mają zostać utworzone podczas drzewa. Teoretycznie relacja między num_liśćmi a max_głębokością wynosi num_liść= 2^(max_głębokość). Jednakże, często nie jest to uczciwe oszacowanie tylko w przypadku słonecznego GBM, ponieważ rozszczepianie liści odbywa się mądrze, a nie na głębokość. Dlatego też zestaw num_leaves musi być mniejszy niż 2^(max_depth), w przeciwnym razie będzie powodował overfitting. Lekkie GBM nie ma bezpośredniego związku pomiędzy num_leaves i max_depth i dlatego te 2 nie mogą być połączone ze sobą.

min_data_in_leaf : jest to również jeden z ważnych parametrów w obsłudze overfittingów. Ustawienie jego mniejszej wartości może spowodować overfitting i dlatego musi być odpowiednio ustawione. Jego wartość powinna wynosić od setek do tysięcy ogromnych zbiorów danych.

max_depth: Określa maksymalną głębokość lub poziom, do którego drzewo może rosnąć.

Dla większej prędkości

bagging_fraction : jest stosowany do wykonywania baggingów dla szybszych wyników

feature_fraction : Ustawienie ułamka cech, które mają być używane przy każdej iteracji

max_bin : Mniejsza wartość max_bin może zaoszczędzić dużo czasu, ponieważ pobiera wartości cech w dyskretnych pojemnikach, co jest niedrogie obliczeniowo.

Dla lepszej dokładności

Używaj większych danych szkoleniowych

num_leaves : Ustawienie go na wysoką wartość daje głębsze drzewa z większą dokładnością, ale powoduje overfitting. Dlatego jego wyższa wartość nie jest preferowana.

max_bin : Ustawienie go na wysoką wartość ma podobny efekt jak zwiększenie wartości num_leaves, a także spowolnienie naszej procedury treningowej.