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