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