Welk algoritme neemt de kroon: Licht GBM vs XGBOOST?

1. wat is Light GBM?

Light GBM kan een snelle, gedistribueerde, krachtige gradiëntverhogende raamwerk ondersteund beslissingsboomalgoritme zijn, dat wordt gebruikt voor rangschikking, classificatie en veel andere machinale leertaken.

Aangezien het ondersteunde beslissingsboomalgoritmen zijn, splitst het de boombladeren met de eenvoudigste pasvorm, terwijl andere boostingalgoritmen de boombladeren in de diepte of in de hoogte splitsen in plaats van in de bladeren. Dus bij het groeien op een equivalent blad in Light GBM, kan het algoritme voor bladeren meer verlies verminderen dan het algoritme voor niveauverschillen en leidt het dus tot een veel betere nauwkeurigheid die zelden kan worden bereikt door een van de heersende boostingalgoritmen. Ook is het verrassend genoeg in een mum van tijd, vandaar het woord ‘Light’.

Voorafgaand kan een schematische weergave door de fabrikanten van de zonneschijn GBM om het verschil duidelijk te maken.

2. 2. Voordelen van de zonneschijn GBM

Snellere trainingssnelheid en betere efficiëntie: Light GBM gebruikt een algoritme op basis van histogrammen, d.w.z. het emmert continue functiewaarden in discrete bakken die de trainingsprocedure vastzetten.

Minder geheugengebruik: Vervangt continue waarden in discrete bakken die eindigen in een lager geheugengebruik.

Betere nauwkeurigheid dan het andere booster-algoritme: Het produceert veel complexere bomen door het volgen van een bladgewijze aanpak in plaats van een niveaugewijze aanpak, waarbij de belangrijkste gedachte is dat er een hogere nauwkeurigheid moet worden bereikt. Het kan echter soms leiden tot overfitting, wat kan worden vermeden door het instellen van de max_depth parameter.

Compatibiliteit met grote datasets: het is in staat om net zo goed te presteren met grote datasets met een grote vermindering van de trainingstijd in vergelijking met XGBOOST.

Parallel leren wordt ondersteund.

Installeren van lichte GBM

Voor Windows

Gebruik van Visual Studio (of MSBuild)

-Installeer git voor windows, cmake en MS Build (U hebt de MSbuild niet nodig als u Visual Studio al installeert).

-Run volgend commando:

Git kloon -rekritisch https://github.com/Microsoft/LightGBM

cd LightGBM

mkdirbouw

cd-bouw

cmake -DCMAKE_GENERATOR_PLATFORM=x64 …

cmake -bouw . –target ALL_BUILD –configureer Vrijgave

De exe en dll gaan in de LightGBM/Release map staan.

Gebruik van MinGW64

-Installeer git voor ramen, cmake en MinGW64.

-Run volgend commando:

Git kloon -rekritisch https://github.com/Microsoft/LightGBM

cd LightGBM

mkdirbouw

cd-bouw

cmake -G “MinGW Makefiles” …

mingw32-make.exe -j4

De exe en dll gaan in de LightGBM/-map staan.

Voor Linux

Light GBM gebruikt cmake om . Loop achter elkaar aan:

Git kloon –recursief https://github.com/Microsoft/LightGBM

cd LightGBM

mkdirbouw

cd-bouw

cmake…

maken -j4

Voor OSX

LightGBM is afhankelijk van OpenMP voor het compileren, wat niet wordt ondersteund door Apple Clang. Gebruik in plaats daarvan gcc/g++.

-Run volgende:

brouwsel installeer cmake

zet gcc -zonder-multilibreren – op de markt brengen

Git kloon –recursief https://github.com/Microsoft/LightGBM

cd LightGBM

mkdirbouw

cd-bouw

cmake…

maken -j4

Nu voordat we duiken hoofd eerst in het bouwen van onze dageraad GBM model, laat ons om te controleren of een aantal van de parameters van de zon GBM om een begrip van de onderliggende procedures te bezitten.

4. 4. Belangrijke parameters van zonneschijn GBM

taak : standaardwaarde = trein ; opties = trein , voorspelling ; Specificeert de taak die we willen uitvoeren die ofwel trein ofwel voorspelling is.

toepassing: standaard=regressie, type=enum, opties= opties :

regressie : uitvoeren van regressietaak

binair: Binaire indeling

multiclass: Multiclassificatie

lambdarank : lambdarank toepassing

gegevens: type=string; trainingsgegevens , LightGBM traint op basis van deze gegevens

num_iteraties: aantal uit te voeren boost iteraties; standaard=100; type=int

num_leaves : aantal bladeren in een boom ; standaard = 31 ; type =int

apparaat : standaard= cpu ; opties = gpu,cpu. Apparaat waarop we ons model willen coachen. Kies GPU voor een snellere training.

max_diepte: Geef de maximale diepte op tot welke boom zal groeien. Deze parameter wordt gebruikt om overfitting te beïnvloeden.

min_data_in_blad: Min. aantal kennis in één blad.

feature_fraction: standaard=1 ; specificeert de fractie van de te nemen kenmerken voor elke iteratie.

bagging_fraction: default=1 ; specificeert de fractie van de kennis die gebruikt moet worden voor elke iteratie en is meestal niet bedoeld om de training te versnellen en overfitting te voorkomen.

min_gain_to_split: standaard=.1 ; min gain voor het uitvoeren van de splitsing

max_bin : maximum aantal bakken om de functiewaarden te emmeren.

min_data_in_bin : min aantal kennis in één bak

num_threads: default=OpenMP_default, type=int ;Aantal threads voor Light GBM.

label : type=string ; geef de labelkolom op

categorical_feature : type=string ; specificeer de specifieke kenmerken die we willen gebruiken voor het trainen van ons model

num_class: standaard=1 ; type=int ; alleen gebruikt voor multiklasse-indeling

Onderga ook deze tekst die de parameterafstemming in XGBOOST intiem uitlegt.

5. 5. LightGBM vs XGBoost

Laten we nu dus LightGBM met XGBoost vergelijken door beide algoritmes toe te passen op een dataset en vervolgens de prestaties te vergelijken.

Hier gebruiken we een dataset die de kennis over personen uit verschillende landen bevat. Ons doel is om te voorspellen of een individu 50k per jaar maakt op basis van de tegengestelde informatie die beschikbaar is. De dataset bestaat uit 32561 observaties en 14 kenmerken die individuen beschrijven.

Hier is dat de link naar de dataset: http://archive.ics.uci.edu/ml/datasets/Adult.

Ga door de dataset om een juiste intuïtie te hebben over voorspellende variabelen dan dat je eenvoudigweg de code b#importeren van standaard bibliotheken zou kunnen begrijpen.

importnummer als np

importpanda’s als pd

van pandas import Series, DataFrame

#import lightgbm en xgboost

import lightgbm als lgb

importeren xgboost als xgb

# het laden van onze trainingsdataset ‘adult.csv’ met naam ‘data’ met behulp van panda’s

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

#Namen toekennen aan de kolommen

data.columns=[‘leeftijd’,’arbeidersklasse’,’fnlwgt’,’onderwijs’,’onderwijsnummer’,’burgerlijke staat’,’beroep’,’relatie’,’ras’,’geslacht’, ‘kapitaalwinst’, ‘kapitaalverlies’, ‘uren_per_week’, ‘autochtoon_land’,’inkomen’].

#glimpse van de dataset

data.head()

# Label Codering van onze doelvariabele

van sklearn.preprocessing import LabelEncoder,OneHotEncoder

l=LabelEncoder()

l.fit(data.Income)

l.classes_

data.Income=Serie(l.transform(data.Income))  #label dat onze doelvariabele codeert

data.Income.value_counts()

#Een Hot Encoding van de Categorische kenmerken

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)

# het verwijderen van categorische kenmerken

data.drop([‘arbeidersklasse’,’onderwijs’,’echtelijke staat’,’beroep’, ‘relatie’, ‘ras’, ‘geslacht’, ‘geboorteland’],as=1,in plaats daarvan=waar)

#Het samenvoegen van een hete gecodeerde functie met onze dataset ‘data’…

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

# verwijder dulpicaatkolommen

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

data=data.iloc[:, i]

#Hierbij is onze doelvariabele ‘Inkomen’ met waarden als 1 of 0.

#Separeren van onze gegevens in kenmerken dataset x en onze doel dataset y

x=data.drop(‘Inkomen’,as=1)

y=data.Income

#Het invoeren van ontbrekende waarden in onze doelvariabele

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

#Nu het splitsen van onze dataset in test en trein

van sklearn.model_selection importeren trein_test_split

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

#Toepassen xgboost

#De gegevens worden opgeslagen in een DMatrix-object

#label wordt gebruikt om onze uitkomstvariabele te definiëren

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

dtest=xgb.DMatrix(x_test)

#setting parameters voor xgboost

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

#trainen van ons model

num_round=50

uit datetime import datetime

start = datetime.now()

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

stop = datetime.now()

#uitvoeringstijd van het model

uitvoeringstijd_xgb = stop-start

uitvoeringstijd_xgb

#datetime.timedelta( , , ) representatie => (dagen , seconden , microseconden)

# Nu voorspellen we ons model op de testset

ypred=xg.predict(dtest)

ypred

#Kansen omzetten in 1 of 0

voor i in het bereik (0,9769):

als ypred[i]>=.5: # drempel instellen op .5

ypred[i]=1

anders:

ypred[i]=0

#calculerende nauwkeurigheid van ons model

van sklearn.metrics import accuracy_score

accuracy_xgb = accuracy_score(y_test,ypred)

nauwkeurigheid_xgb

# Licht GBM

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

#setting parameters voor lightgbm

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

param[‘metrisch’] = [‘auc’, ‘binair_logverlies’].

#Hierbij hebben we max_diepte in xgb en LightGBM ingesteld op 7 om een eerlijke vergelijking tussen de twee te hebben.

#Trainen van ons model met behulp van licht gbm

num_round=50

start=datetime.now()

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

stop=datetime.now()

#uitvoeringstijd van het model

executie_tijd_lgbm = stop-start

executietijd_lgbm

#voorspellen op testset

ypred2=lgbm.predict(x_test)

ypred2[0:5] # toont de eerste 5 voorspellingen

#kansen omzetten in 0 of 1

voor i in het bereik (0,9769):

als ypred2[i]>=.5: # drempel instellen op .5

ypred2[i]=1

anders:

ypred2[i]=0

#calculerende nauwkeurigheid

accuracy_lgbm = accuracy_score(ypred2,y_test)

nauwkeurigheid_lgbm

y_test.value_counts()

uit sklearn.metrics importeren roc_auc_score

#calculerende roc_auc_score voor xgboost

auc_xgb = roc_auc_score(y_test,ypred)

auc_xgb

#calculerende roc_auc_score voor lichte gbm.

auc_lgbm = roc_auc_score(y_test,ypred2)

auc_lgbm vergelijking_dict = {‘nauwkeurigheidsscore’:(accuracy_lgbm,accuracy_xgb),’auc score’:(auc_lgbm,auc_xgb),’executietijd’:(execution_time_lgbm,execution_time_xgb)}.

#Het creëren van een dataframe ‘vergelijking_df’ voor het vergelijken van de prestaties van Lightgbm en xgb.

comparison_df = Dataframe (comparison_dict)

comparison_df.index= [‘LightGBM’,’xgboost’].

vergelijking_felow goed.

Vergelijking van de prestaties

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

Er is slechts een kleine toename in nauwkeurigheid en auc score door het toepassen van Light GBM over XGBOOST, maar er is een groot verschil binnen de uitvoeringstermijn voor de training. Light GBM is bijna 7 keer sneller dan XGBOOST en kan een veel betere aanpak zijn bij het verwerken van grote datasets.

Dit lijkt een enorm voordeel te zijn als je eenmaal op grote datasets presteert in wedstrijden met beperkte tijd.

6. 6. Afstemparameters van zonneschijn GBM

De lichte GBM maakt gebruik van bladgewijze splitsing over dieptegewijze splitsing waardoor het veel sneller kan convergeren, maar ook overfitting tot gevolg heeft. Hier volgt dus een korte handleiding om de parameters in Light GBM af te stemmen.

Voor de beste pasvorm

num_leaves : Deze parameter wordt gebruikt om de hoeveelheid bladeren die tijdens een boom worden gevormd te bepalen. Theoretisch is de relatie tussen num_leaves en max_depth num_leaves= 2^(max_depth). Dit is echter vaak geen eerlijke schatting in het geval van zonneschijn GBM omdat het splitsen van de bladeren plaatsvindt in plaats van in de diepte. Daarom moet num_leaves set kleiner zijn dan 2^(max_depth) anders gaat het overfitting veroorzaken. Licht GBM heeft geen direct verband tussen num_leaves en max_depth en daarom moeten de 2 niet met elkaar in verband worden gebracht.

min_data_in_blad: het is ook een van de belangrijke parameters bij het omgaan met overfitting. Het instellen van de waarde kleiner kan overfitting veroorzaken en moet dus dienovereenkomstig worden ingesteld. De waarde ervan moet honderden tot duizenden enorme datasets zijn.

max_depth: het specificeert de uiterste diepte of het niveau tot waar de boom kan groeien.

Voor een hogere snelheid

bagging_fraction : wordt gebruikt om bagging uit te voeren voor snellere resultaten

feature_fraction : Stel de fractie van de te gebruiken functies in bij elke iteratie.

max_bin : Een kleinere waarde van max_bin kan veel tijd besparen omdat het de functiewaarden in discrete bakken emmert, wat rekenkundig gezien niet duur is.

Voor een betere nauwkeurigheid

Gebruik grotere trainingsgegevens

num_leaves : Door het op een hoge waarde in te stellen, worden diepere bomen met een grotere nauwkeurigheid geproduceerd, maar ontstaat er een overfitting. Vandaar dat de hogere waarde niet de voorkeur heeft.

max_bin : Het instellen op hoge waarden heeft een soortgelijk effect als het verhogen van de waarde van num_leaves en vertraagt ook onze trainingsprocedure.