Light GBM est une structure rapide, appropriée, de renforcement de gradient boosting, dépendant du calcul de l’arbre de choix, utilisée pour le positionnement, la caractérisation et de nombreuses autres missions d’IA.
Comme il dépend des calculs de l’arbre de choix, il divise la feuille de l’arbre la mieux adaptée tandis que d’autres calculs de renforcement divisent la profondeur de l’arbre en deux parties, l’une judicieuse et l’autre perspicace, par opposition à la feuille. Ainsi, lors du développement sur une feuille similaire dans Light GBM, le calcul feuille par feuille peut réduire plus de malchance que le calcul par niveau et apporte par la suite une bien meilleure précision qui peut être obtenue de temps en temps par n’importe lequel des calculs de renforcement actuels. De même, il est extrêmement rapide, d’où le mot “Light”.
Nous présentons ici une représentation schématique des créateurs du Light GBM afin de clarifier la distinction.
Les parties perspicaces de la feuille conduisent à une augmentation de la complexité et peuvent provoquer un surajustement et elle a tendance à être dépassée en indiquant un autre paramètre, la profondeur maximale, qui détermine la profondeur à laquelle la séparation se produira.
Ci-dessous, nous verrons les moyens d’introduire le GBM léger et de faire fonctionner un modèle l’utilisant. Nous comparerons les résultats avec ceux de XGBOOST en montrant qu’il faut prendre la MGF légère d’une manière “légère”.
Donnez-nous l’occasion de jeter un coup d’œil sur une partie des avantages de Light GBM.
Points d’intérêt de Light GBM
Un rythme de préparation plus rapide et une productivité accrue : Le Light GBM utilise un calcul basé sur l’histogramme, c’est-à-dire qu’il met en commun des estimations de composants sans cesse renouvelées dans des conteneurs discrets qui fixent la stratégie de préparation.
Utilisation moindre de la mémoire : Remplace les qualités constantes par des réceptacles discrets qui entraînent une moindre utilisation de la mémoire.
Précision préférable à un autre calcul de stimulation : Il crée des arbres beaucoup plus déroutants en suivant une approche de division des feuilles par opposition à une approche par niveau qui est le facteur fondamental pour obtenir une plus grande précision. Dans tous les cas, il peut parfois conduire à un surajustement dont on peut se passer en réglant le paramètre max_depth.
Similitude avec d’énormes ensembles de données : Il est équipé pour fonctionner aussi bien avec d’énormes ensembles de données avec une diminution critique de la préparation d’un moment par rapport à XGBOOST.
Maintien de l’apprentissage parallèle.
Je suppose que vous avez plus que probablement bénéficié des avantages de la MGF légère. Donnez-nous maintenant une chance de continuer à introduire la bibliothèque dans notre système.
Installer la lumière GBM
Pour Windows
Utilisation de Visual Studio (ou MSBuild)
-Installez git pour windows, cmake et MS Build (pas besoin de MSbuild si vous avez déjà installé Visual Studio).
-Exécuter en suivant le commandement :
git clone –recursive https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir construire
construction de cd
cmake -DCMAKE_GENERATOR_PLATFORM=x64 ..
cmake –build . –target ALL_BUILD –config Release
L’exe et la dll se trouveront dans le dossier LightGBM/Release.
Utilisation de MinGW64-Installer
git pour windows cmake et MinGW64.
-Exécuter la commande suivante :
git clone –recursive https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir construire
construction de cd
cmake -G “MinGW Makefiles” ..
mingw32-make.exe -j4
L’exe et la dll se trouveront dans le dossier LightGBM/.
Pour Linux
Light GBM utilise cmake pour construire. Run following :
git clone –recursive https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir construire
construction de cd
cmake ..
faire -j4
Pour OSX
LightGBM dépend d’OpenMP pour la compilation, qui n’est pas supporté par Apple Clang, veuillez utiliser gcc/g++ à la place.
-Exécuter la suite :
brew install cmake
brew install gcc –sans multilib
git clone –recursive https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir construire
construction de cd
cmake ..
faire -j4
Maintenant, avant de nous lancer dans la construction de notre premier modèle de MGB léger, examinons certains des paramètres de la MGB léger afin de comprendre les procédures sous-jacentes.
Paramètres importants de la GBM légère
task : valeur par défaut = train ; options = train , prédiction ; Spécifie la tâche que nous souhaitons effectuer qui est soit le train soit la prédiction.
application : default=regression, type=enum, options= options :
régression : effectuer une tâche de régression
binaire : Classification binaire
multiclasse : Classification multiclasse
lambdarank : demande de lambdarank
données : type=string ; données de formation, LightGBM s’entraînera à partir de ces données
num_iterations : nombre d’itérations de boosting à effectuer ; default=100 ; type=int
num_leaves : nombre de feuilles dans un arbre ; par défaut = 31 ; type =int
device : default= cpu ; options = gpu,cpu. Dispositif sur lequel nous voulons entraîner notre modèle. Choisissez GPU pour une formation plus rapide.
max_depth : Précisez la profondeur maximale à laquelle l’arbre va pousser. Ce paramètre est utilisé pour traiter les cas de surpopulation.
min_data_in_leaf : Nombre minimal de données dans une feuille.
feature_fraction : default=1 ; spécifie la fraction de caractéristiques à prendre pour chaque itération
bagging_fraction : default=1 ; spécifie la fraction de données à utiliser pour chaque itération et est généralement utilisé pour accélérer l’entraînement et éviter le suréquipement.
min_gain_to_split : default=.1 ; min gain pour effectuer le fractionnement
max_bin : nombre maximum de bacs pour contenir les valeurs des caractéristiques.
min_data_in_bin : nombre minimum de données dans un bac
num_threads : default=OpenMP_default, type=int ;Nombre de threads pour Light GBM.
label : type=string ; préciser la colonne du label
categorical_feature : type=string ; préciser les caractéristiques catégorielles que nous voulons utiliser pour former notre modèle
num_class : default=1 ; type=int ; utilisé uniquement pour la classification multi-classes
LightGBM contre XGBoost
Et si nous mettions en contraste LightGBM et XGBoost en appliquant les calculs à un ensemble de données et en regardant ensuite l’exposition.
Nous utilisons ici un ensemble de données qui contient des informations sur des personnes de différentes nations. Notre objectif est d’anticiper si un individu rend <=50k ou >50k par an sur place les autres données accessibles. L’ensemble de données comprend 32561 perceptions et 14 points saillants représentant des personnes.
Voici le lien avec l’ensemble des données : http://archive.ics.uci.edu/ml/datasets/Grown-up.
Faites l’expérience de l’ensemble de données pour avoir un instinct approprié sur les facteurs indicateurs afin de pouvoir comprendre le code ci-dessous de manière appropriée.
#importation de bibliothèques standard
import numpy as np
importer les pandas en tant que pd
de la série sur l’importation de pandas, DataFrame
#import lightgbm et xgboost
importer lightgbm en tant que lgb
importer xgboost en tant que xgb
#chargement de notre base de données de formation “adult.csv” avec le nom “data” en utilisant des pandas
data=pd.read_csv(‘adult.csv’,header=None)
#Assigner des noms aux colonnes
data.columns=[‘âge’, ‘classe ouvrière’, ‘fnlwgt’, ‘éducation’, ‘éducation-num’, ‘statut_marital’, ‘profession’, ‘relation’, ‘race’, ‘sexe’, ‘gain_capital’, ‘perte_capital’, ‘heures_par_semaine’, ‘pays_naturel’, ‘revenu’]
#un aperçu de l’ensemble des données
data.head()
# Label Encodage de notre variable cible
de sklearn.preprocessing import LabelEncoder,OneHotEncoder
l=LabelEncoder()
l.fit(data.Income)
l.classes_
données.revenu=série(l.transformer(données.revenu)) #label codant notre variable cible
données.revenus.valeur_comptes()
#Un encodage à chaud des caractéristiques de la catégorie
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)
#suppression des caractéristiques catégorielles
data.drop([“classe ouvrière”, “éducation”, “statut_marital”, “profession”, “relation”, “race”, “sexe”, “pays_naturel”],axis=1,inplace=True)
#Fusion d’une fonctionnalité codée à chaud avec notre ensemble de données “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)
# supprimer les colonnes dupliquées
_, i = np.unique(data.columns, return_index=True)
data=data.iloc[ :, i]
#Notre variable cible est le “revenu”, avec des valeurs de 1 ou 0.
#Séparation de nos données en un ensemble de données de caractéristiques x et un ensemble de données cibles y
x=data.drop(‘Revenu’,axis=1)
y=données.revenus
#Imputation des valeurs manquantes dans notre variable cible
y.fillna(y.mode()[0],inplace=True)
#Maintenant, nous divisons notre ensemble de données en deux parties : test et formation
de sklearn.model_selection import train_test_split
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=.3)
#Appliquer xgboost
#Les données sont stockées dans un objet DMatrix
#label est utilisé pour définir notre variable de résultat
dtrain=xgb.DMatrix(x_train,label=y_train)
dtest=xgb.DMatrix(x_test)
#établir les paramètres de xgboost
parameters={‘max_depth’:7, ‘eta’:1, ‘silent’:1, ‘objective’ : ‘binary:logistic’, ‘eval_metric’ : ‘auc’, ‘learning_rate’ :.05}
#former notre modèle
num_round=50
à partir de la date-heure importation date-heure
start = datetime.now()
xg=xgb.train(paramètres,dtrain,num_round)
stop = datetime.now()
#Durée d’exécution du modèle
execution_time_xgb = stop-start
execution_time_xgb
#datetime.timedelta( , , ) représentation => (jours , secondes , microsecondes)
#prédisant maintenant notre modèle sur un banc d’essai
ypred=xg.predict(dtest)
ypred
#Convertir les probabilités en 1 ou 0
pour i dans la fourchette(0,9769) :
if ypred[i]>=.5 : # setting threshold to .5
ypred[i]=1
d’autre part :
ypred[i]=0
#Calculer la précision de notre modèle
de sklearn.metrics import accuracy_score
accuracy_xgb = accuracy_score(y_test,ypred)
accuracy_xgb
# Light GBM
train_data=lgb.Dataset(x_train,label=y_train)
#établir des paramètres pour la Gbm lumière
param = {‘num_leaves’:150, ‘objective’ : ‘binary’, ‘max_depth’:7, ‘learning_rate’ :.05, ‘max_bin’:200}
param[‘métrique’] = [‘auc’, ‘binary_logloss’]
#Nous avons fixé la profondeur maximale en xgb et en LightGBM à 7 pour avoir une comparaison équitable entre les deux.
#Formation de notre modèle à l’aide de light gbm
num_round=50
start=datetime.now()
lgbm=lgb.train(param,train_data,num_round)
stop=datetime.now()
#Durée d’exécution du modèle
execution_time_lgbm = stop-start
execution_time_lgbm
#prévision sur le banc d’essai
ypred2=lgbm.predict(x_test)
ypred2[0:5] # montrant les 5 premières prédictions
#convertir les probabilités en 0 ou 1
pour i dans la fourchette(0,9769) :
if ypred2[i]>=.5 : # setting threshold to .5
ypred2[i]=1
d’autre part :
ypred2[i]=0
#calculer la précision
accuracy_lgbm = accuracy_score(ypred2,y_test)
accuracy_lgbm
y_test.value_counts()
de sklearn.metrics import roc_auc_score
#calculer le score de roc_auc_score pour xgboost
auc_xgb = roc_auc_score(y_test,ypred)
auc_xgb
#Calculer le score de roc_auc_score pour le gbm léger.
auc_lgbm = roc_auc_score(y_test,ypred2)
auc_lgbm comparison_dict = {“score de précision” :(accuracy_lgbm,accuracy_xgb), “auction score” :(auc_lgbm,auc_xgb), “execution time” :(execution_time_lgbm,execution_time_xgb)}
#Création d’une trame de données ‘comparison_df’ pour comparer les performances de Lightgbm et xgb.
comparison_df = DataFrame(comparison_dict)
comparison_df.index= [“LightGBM”, “xgboost”]
comparaison_df
Comparaison des performances