Il GBM leggero è una struttura rapida, appropriata, d’elite che aumenta l’inclinazione in funzione del calcolo dell’albero di scelta, utilizzata per il posizionamento, la caratterizzazione e numerose altre assegnazioni AI.

Dato che dipende dai calcoli dell’albero di scelta, la foglia dell’albero viene suddivisa in due parti, mentre altri calcoli di potenziamento dividono la profondità dell’albero in due parti, in modo da ottenere una maggiore profondità o una maggiore profondità rispetto a quella della foglia. Quindi, quando si sviluppa su una foglia simile in Light GBM, il calcolo fogliare può diminuire la sfortuna rispetto al calcolo di livello e, di conseguenza, porta ad una precisione molto migliore, che può essere ottenuta una volta ogni tanto da uno qualsiasi dei calcoli di spinta attuali. Allo stesso modo, è sorprendentemente estremamente veloce, da cui la parola “Luce”.

Prima c’è una rappresentazione diagrammatica dei creatori della Light GBM per chiarire la distinzione, ovviamente.

Le parti con foglia penetranti portano ad un aumento della complessità e possono richiedere un sovraadattamento e tendono ad essere sopraffatte dall’indicazione di un altro parametro max-profondità che determina la profondità a cui avverrà il distacco.

Sotto, vedremo i mezzi per introdurre la Light GBM ed eseguire un modello che la utilizzi. Contrasteremo i risultati con i risultati di XGBOOST dimostrando che si dovrebbe prendere Light GBM in un ‘modo LIGHT’.

Dateci la possibilità di dare un’occhiata a una parte dei benefici della Light GBM.

Punti di interesse di Light GBM

Maggiore velocità di preparazione e maggiore produttività: Il GBM leggero usa il calcolo basato sull’istogramma, cioè mette in contenitori discreti che fissano la strategia di preparazione le stime dei componenti senza sosta.

Ridurre l’uso della memoria: Sostituisce le qualità costanti con i recipienti discreti che portano ad un uso inferiore della memoria.

Precisione preferibile rispetto a qualche altro calcolo di potenziamento: Crea alberi molto più perplessi seguendo un approccio a foglia spezzata rispetto ad un approccio a livello, che è il fattore fondamentale per ottenere una maggiore esattezza. In ogni caso, a volte può portare ad un overfitting, che può essere evitato impostando il parametro max_profondità.

Somiglianza con enormi set di dati: E’ equipaggiato per prestazioni simili con enormi dataset con una diminuzione critica nella preparazione di un tempo in contrasto con XGBOOST.

Apprendimento parallelo sostenuto.

Suppongo che sia più probabile che siate stati amplificati per i benefici della Light GBM. Dateci ora la possibilità di continuare a introdurre la biblioteca nel nostro sistema.

Installazione di GBM leggeri

Per le finestre

Utilizzo di Visual Studio (o MSBuild)

-Installare git per windows, cmake e MS Build (non è necessario MSbuild se si installa già Visual Studio).

-Esegui il comando seguente:

git clone -recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir costruire

cd costruire

cmake -DCMAKE_GENERATOR_PLATFORM=x64 .

cmake – costruire . –target ALL_BUILD –configurare rilascio

L’exe e la dll saranno nella cartella LightGBM/Release.

Utilizzando MinGW64-Install
 git per windows cmake e MinGW64.
-Run seguendo il comando:

git clone -recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir costruire

cd costruire

cmake -G “MinGW Makefiles” …

mingw32-make.exe -j4

L’exe e la dll saranno nella cartella LightGBM/.

Per Linux

La GBM leggera usa cmake per costruire. Eseguire seguendo:

git clone -recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir costruire

cd costruire

cmake …

marca -j4

Per OSX

LightGBM dipende da OpenMP per la compilazione, che non è supportata da Apple Clang.Si prega di utilizzare invece gcc/g++.
-Esegui il seguente:

brew install cmake

brew install gcc –senza-multilib

git clone -recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir costruire

cd costruire

cmake …

marca -j4

Ora, prima di tuffarci a capofitto nella costruzione del nostro primo modello di Light GBM, esaminiamo alcuni dei parametri del Light GBM per avere una comprensione delle sue procedure di base.

Parametri importanti della luce GBM

task : valore predefinito = treno ; opzioni = treno, previsione ; Specifica il compito che vogliamo eseguire che è treno o previsione.

applicazione: default=regressione, type=enum, options= opzioni :

regressione : eseguire il compito di regressione

binario : Classificazione binaria

multiclasse: Classificazione multiclasse

Lambdarank : applicazione lambdarank

dati: type=string; dati di allenamento , LightGBM si allena a partire da questi dati

num_iterations: numero di iterazioni di potenziamento da eseguire ; default=100; type=int

num_leaves : numero di foglie in un albero ; default = 31 ; tipo =int

device : default= cpu ; options = gpu,cpu. Dispositivo su cui vogliamo allenare il nostro modello. Scegliere la GPU per un addestramento più veloce.

max_profondità: Specificare la profondità massima a cui l’albero crescerà. Questo parametro è usato per trattare l’overfitting.

min_dati_in_foglio: Numero minimo di dati in un foglio.

feature_fraction: default=1 ; specifica la frazione di caratteristiche da prendere per ogni iterazione

bagging_fraction: default=1 ; specifica la frazione di dati da utilizzare per ogni iterazione ed è generalmente utilizzata per velocizzare l’addestramento ed evitare l’overfitting.

min_gain_to_split: default=.1 ; guadagno min per eseguire lo splitting

max_bin : numero massimo di bidoni per mettere nel secchio i valori delle caratteristiche.

min_data_in_bin : min numero di dati in un unico contenitore

num_threads: default=OpenMP_default, type=int ;Numero di threads per Light GBM.

label : type=stringa ; specificare la colonna dell’etichetta

categorical_feature : type=string; specificare le caratteristiche categoriche che vogliamo utilizzare per l’addestramento del nostro modello

num_classe: default=1 ; type=int ; utilizzato solo per la classificazione multi-classe

LightGBM contro XGBoost

E ora che ne dite di contrapporre LightGBM e XGBoost applicando sia i calcoli a un set di dati sia guardando la mostra.

Qui stiamo utilizzando un set di dati che contiene i dati di persone di diverse nazioni. Il nostro obiettivo è quello di anticipare se un individuo rende accessibili <=50k o >50k all’anno in loco gli altri dati. Il dataset comprende 32561 percezioni e 14 punti salienti che rappresentano persone.

Ecco il collegamento al dataset: http://archive.ics.uci.edu/ml/datasets/Grown-up.

Sperimentare il set di dati per avere un adeguato istinto sui fattori indicatori in modo da poter comprendere il codice sottostante in modo appropriato.

#importando librerie standard

importare intorpidito come np

importare panda come pd

dalla serie di importazione panda, DataFrame

#importare lightgbm e xgboost

importare lightgbm come lgb

importare xgboost come xgb

#caricare il nostro set di dati di formazione ‘adult.csv’ con il nome ‘dati’ utilizzando panda

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

#Assegnare i nomi alle colonne

data.columns=[‘età’,’classe’ lavorativa’,”lavoro’,’ fnlwgt’,’ educazione’,’ istruzione-num’,’ stato civile’,’ occupazione’,’ relazione’,’ razza’,’ sesso’,’ guadagno’ capitale’,’ perdita’ capitale’,’ ore’ per’ settimana’,’ paese’ di origine’,’ reddito’]

#sguardo al set di dati

dati.testa()

# Etichetta Codifica della nostra variabile di destinazione

da sklearn.preprocessing import LabelEncoder,OneHotEncoder

l=LabelEncoder()

l.fit(dati.Ricavi)

l.classi_

dati.ricavi=Serie(l.trasformate(dati.ricavi))  #etichetta che codifica la nostra variabile target

dati.ricavi.conteggi_valori_dei_dati()

#One Hot Encoding of the Categorical features

one_hot_workclass=pd.get_dummies(data.workclass)

one_hot_education=pd.get_dummies(dati.educazione)

one_hot_marital_Status=pd.get_dummies(data.marital_Status)

one_hot_occupation=pd.get_dummies(dati.occupazione)

one_hot_relationship=pd.get_dummies(dati.relazione)

one_hot_race=pd.get_dummies(dati.gara)

one_hot_sex=pd.get_dummies(dati.sesso)

one_hot_native_country=pd.get_dummies(dati.nativi.del.paese)

#rimozione di caratteristiche categoriche

data.drop([‘classe lavorativa’,’educazione’,’stato_matrimoniale’,’occupazione’,’relazione’,’razza’,’sesso’,’paese_ natale’],axis=1,inplace=True)

#Combinazione di una funzionalità codificata a caldo con i nostri ‘dati’ del nostro set di dati

data=pd.concat([dati,uno_hot_classe_lavorativa,uno_hot_educazione,uno_hot_stato_matrimoniale,uno_hot_occupazione,uno_hot_relazione,uno_hot_ragione,uno_hot_sesso,uno_hot_paese_nativo],axis=1)

#rimozione delle colonne di dulcisio

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

data=data.iloc[:, i]

#Qui la nostra variabile target è “Reddito” con valori come 1 o 0. 

#Separare i nostri dati nel set di dati delle caratteristiche x e nel set di dati di destinazione y

x=data.drop(‘Reddito’,asse=1)

y=dati.ricavi

#Importare i valori mancanti nella nostra variabile target

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

#Ora dividendo il nostro dataset in test e treno

da sklearn.model_selection importazione treno_test_test_split

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

#Applicare xgboost

#I dati sono memorizzati in un oggetto DMatrix

#etichetta viene utilizzata per definire la nostra variabile di risultato

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

dtest=xgb.DMatrix(x_test)

#Impostazione dei parametri per xgboost

parametri={‘max_profondità’:7, ‘eta’:1, ‘silenzioso’:1,’obiettivo’:’binario:logistico’,’eval_metrico’:’auc’,’tasso_di_apprendimento’:.05}

#formare il nostro modello

num_round=50

dall’ora della data all’ora dell’importazione

start = datetime.now()

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

stop = datetime.now()

#Tempo di esecuzione del modello

execution_time_xgb = stop-start

esecuzione_tempo_xgb

#datetime.timedelta( , , , ) rappresentazione => (giorni , secondi , microsecondi)

#ora prevedere il nostro modello sul set di prova

ypred=xg.predict(dtest)

ypred

#Convertire le probabilità in 1 o 0

per i nel range(0,9769):

    se ypred[i]>=.5: # impostazione della soglia a .5

       ypred[i]=1

    altro:

       ypred[i]=0 

#calcolo della precisione del nostro modello

da sklearn.metrics import accuracy_score

accuracy_xgb = accuracy_score(y_test,ypred)

accuratezza_xgb

# GBM leggera

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

#impostazione dei parametri per lightgbm

param = {‘num_foglie’:150, ‘obiettivo’:’binario’,’max_profondità’:7,’tasso_di_apprendimento’:.05,’max_bin’:200}

param[‘metrico’] = [‘auc’, ‘binary_logloss’]

#Qui abbiamo impostato max_profondità in xgb e LightGBM a 7 per avere un confronto equo tra i due.

#addestrare il nostro modello usando la luce gbm

num_round=50

start=datetime.now()

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

stop=datetime.now()

#Tempo di esecuzione del modello

execution_time_lgbm = stop-start

esecuzione_tempo_lgbm

#predisposizione sul set di prova

ypred2=lgbm.predict(x_test)

ypred2[0:5] # che mostra le prime 5 previsioni

#convertire le probabilità in 0 o 1

per i nel range(0,9769):

    se ypred2[i]>=.5: # impostazione della soglia a .5

       ypred2[i]=1

    altro: 

       ypred2[i]=0

#calcolo della precisione

accuracy_lgbm = accuracy_score(ypred2,y_test)

accuratezza_lgbm

y_test.valore_conti_di_valore()

da sklearn.metrics importa roc_auc_score

#calcolando roc_auc_score per xgboost

auc_xgb = roc_auc_score(y_test,ypred)

auc_xgb

#calcolando roc_auc_score per la luce gbm.

auc_lgbm = roc_auc_score(y_test,ypred2)

auc_lgbm comparison_dict = {‘punteggio di precisione’:(accuracy_lgbm,accuracy_xgb),’punteggio di auc’:(auc_lgbm,auc_xgb),’tempo di esecuzione’:(execution_time_lgbm,execution_time_xgb)}

#Creare un dataframe ‘comparison_df’ per confrontare le prestazioni di Lightgbm e xgb.

comparison_df = DataFrame(comparison_dict)

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

confronto_df

Confronto delle prestazioni