Light GBM ist eine schnelle, geeignete, Elite-Neigungsverstärkungsstruktur, die von der Wahlbaumberechnung abhängt und für Positionierung, Charakterisierung und zahlreiche andere KI-Aufgaben verwendet wird.

Da sie von den Berechnungen für den Wahlbaum abhängt, teilt sie den Baum blattsicher mit der besten Passung, während andere verstärkende Berechnungen die Baumtiefe scharfsinnig oder eben aufschlussreich im Gegensatz zu blattweise aufteilen. Bei der Entwicklung auf einem ähnlichen Blatt in Light GBM kann also die blattweise Berechnung mehr Unglück verringern als die ebenenweise Berechnung und führt anschließend zu einer viel besseren Genauigkeit, die von Zeit zu Zeit von jeder der aktuellen Verstärkungsberechnungen erreicht werden kann. Ebenso ist sie schockierend extrem schnell, daher das Wort “Light”.

Vorangestellt ist eine diagrammatische Darstellung der Schöpfer des Light GBM, um die Unterscheidung offensichtlich zu verdeutlichen.

Aufschlussreiche Teile des Blattes führen zu einer Zunahme der Komplexität und können zu einer Überanpassung führen, und es neigt dazu, durch die Angabe eines weiteren Parameters max-profundity überfordert zu werden, der die Tiefe bestimmt, bis zu der ein Abschied erfolgt.

Unten sehen wir die Mittel zur Einführung von Light GBM und zur Durchführung eines Modells, das dieses nutzt. Wir werden die Ergebnisse den XGBOOST-Ergebnissen gegenüberstellen, indem wir zeigen, dass Sie Light GBM auf eine “LIGHT Way”-Weise anwenden sollten.

Geben Sie uns die Chance, einen Blick auf einen Teil der Vorteile von Light GBM zu werfen.

Sehenswürdigkeiten der Light GBM

Schnelleres Vorbereitungstempo und höhere Produktivität: Leichte GBM verwenden eine histogrammbasierte Berechnung, d.h. es werden unaufhörlich Komponentenbewertungen in diskrete Behälter gepackt, die die Präparationsstrategie enthalten.

Geringere Speichernutzung: Ersetzt konsistente Qualitäten bei diskreten Steckdosen, die eine geringere Speichernutzung bewirken.

Bevorzugte Genauigkeit gegenüber anderen Verstärkungsberechnungen: Sie erzeugt wesentlich verwirrendere Bäume, indem sie einem blattscharfsinnigen Split-Ansatz folgt, im Gegensatz zu einem ebenen Ansatz, der der grundlegende Faktor für die Erzielung einer höheren Genauigkeit ist. In jedem Fall kann es zuweilen zu einer Überanpassung führen, die durch die Einstellung des Parameters max_depth vermieden werden kann.

Ähnlichkeit mit riesigen Datensätzen: Im Gegensatz zu XGBOOST ist es für eine ähnlich gute Leistung bei riesigen Datensätzen mit einer kritischen Verkürzung der Vorbereitungszeit ausgestattet.

Paralleles Lernen aufrechterhalten.

Ich vermute, dass Sie sich wahrscheinlich für die Vorteile von Light GBM begeistern konnten. Geben Sie uns jetzt die Chance, die Bibliothek weiterhin in unser System einzuführen.

Licht GBM installieren

Für Windows

Verwenden von Visual Studio (oder MSBuild)

-Installieren Sie git für Windows, cmake und MS Build (Sie benötigen das MSbuild nicht, wenn Sie Visual Studio bereits installiert haben).

-Folgenden Befehl ausführen:

git-Klon –rekursiv https://github.com/Microsoft/LightGBM

cd LichtGBM

mkdir bauen

cd bauen

cmake -DCMAKE_GENERATOR_PLATFORM=x64 …

cmake –build . –target ALL_BUILD –config Freigabe

Die exe und dll befinden sich im Ordner LightGBM/Release.

Verwendung von MinGW64-Install
 git für Windows cmake und MinGW64.
-Run folgenden Befehl ausführen:

git-Klon –rekursiv https://github.com/Microsoft/LightGBM

cd LichtGBM

mkdir bauen

cd bauen

cmake -G “MinGW-Makefiles” …

mingw32-make.exe -j4

Die exe und dll befinden sich im Ordner LightGBM/.

Für Linux

Light GBM verwendet cmake zum Bauen. Nachfolgend ausführen:

git-Klon –rekursiv https://github.com/Microsoft/LightGBM

cd LichtGBM

mkdir bauen

cd bauen

cmake …

Marke -j4

Für OSX

LightGBM ist zum Kompilieren auf OpenMP angewiesen, das von Apple Clang nicht unterstützt wird. Bitte verwenden Sie stattdessen gcc/g++.
-Nachfolgend ausführen:

brauen cmake installieren

brew install gcc –without-multilib

git-Klon –rekursiv https://github.com/Microsoft/LightGBM

cd LichtGBM

mkdir bauen

cd bauen

cmake …

Marke -j4

Bevor wir uns nun kopfüber in die Erstellung unseres ersten Light GBM-Modells stürzen, wollen wir uns einige der Parameter des Light GBM ansehen, um ein Verständnis für die zugrunde liegenden Verfahren zu erhalten.

Wichtige Parameter des leichten GBM

task : Standardwert = Zug ; Optionen = Zug , Vorhersage ; Gibt die Aufgabe an, die wir durchführen wollen, die entweder Zug oder Vorhersage ist.

Anwendung: Standard=Regression, Typ=Zahl, Optionen=Optionen :

Regression : Regressionsaufgabe durchführen

Binär : Binäre Klassifizierung

mehrere Klassen: Mehrklassen-Klassifikation

lambdarank : lambdarank Anwendung

Daten: type=string; Trainingsdaten , LightGBM wird aus diesen Daten trainieren

num_iterations: Anzahl der durchzuführenden Boosting-Iterationen; Standard=100; Typ=int

num_leaves : Anzahl der Blätter in einem Baum; Standard = 31; Typ =int

Gerät : Voreinstellung= cpu ; Optionen = gpu,cpu. Gerät, auf dem wir unser Modell trainieren wollen. Wählen Sie GPU für ein schnelleres Training.

max_Tiefe: Geben Sie die maximale Tiefe an, bis zu der der Baum wachsen wird. Dieser Parameter wird verwendet, um mit Überanpassung umzugehen.

min_daten_im_Blatt: Minimale Anzahl von Daten in einem Blatt.

feature_fraction: default=1 ; gibt den Anteil der Merkmale an, der für jede Iteration genommen werden soll

bagging_fraction: default=1 ; gibt den für jede Iteration zu verwendenden Datenanteil an und wird im Allgemeinen verwendet, um das Training zu beschleunigen und eine Überanpassung zu vermeiden.

min_gain_to_split: default=.1 ; min Gewinn zur Durchführung des Splittings

max_bin : maximale Anzahl von Bins, um die Feature-Werte zu speichern.

min_data_in_bin : minimale Anzahl von Daten in einem Bin

num_threads: default=OpenMP_default, type=int ;Anzahl der Threads für Light GBM.

label : type=string ; geben Sie die Label-Spalte an

categorical_feature : type=string ; geben Sie die kategorischen Merkmale an, die wir für das Training unseres Modells verwenden wollen

num_class: default=1 ; type=int ; nur für Mehrklassenklassifizierung verwendet

LightGBM gegen XGBoost

Wie wäre es nun, wenn wir LightGBM und XGBoost gegenüberstellen, indem wir sowohl die Berechnungen auf einen Datensatz anwenden als auch danach die Ausstellung betrachten.

Hier verwenden wir einen Datensatz, der die Daten von Menschen aus verschiedenen Nationen enthält. Unser Ziel ist es, vorauszusehen, ob eine Person <=50k oder >50k der anderen Daten jährlich vor Ort zugänglich macht. Der Datensatz umfasst 32561 Wahrnehmungen und 14 Highlights, die Menschen darstellen.

Hier ist die Verbindung zum Datensatz: http://archive.ics.uci.edu/ml/datasets/Grown-up.

Erleben Sie den Datensatz, um ein angemessenes Gespür für Indikatorfaktoren zu haben, so dass Sie den darunter liegenden Code angemessen nachvollziehen können.

#Importieren von Standard-Bibliotheken

numpy als np importieren

Pandas als pd importieren

von Pandas importieren Serie, DataFrame

#import lightgbm und xgboost

lightgbm als lgb importieren

xgboost als xgb importieren

#Laden unseres Schulungsdatensatzes ‘adult.csv’ mit dem Namen ‘data’ unter Verwendung von Pandas

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

#Zuweisung von Namen zu den Spalten

data.columns=[‘age’,’workclass’,’fnlwgt’,’education’,’education-num’,’marital_Status’,’occupation’,’relationship’,’race’,’sex’,’capital_gain’,’capital_loss’,’hours_per_week’,’native_country’,’Income’]

#Ein Blick auf den Datensatz

daten.kopf()

# Label-Kodierung unserer Zielvariablen

aus sklearn.preprocessing Import LabelEncoder,OneHotEncoder

l=LabelEncoder()

l.fit(daten.Einkommen)

l.klassen_

daten.einkommen=Reihe(l.transform(daten.einkommen))  #label-Kodierung unserer Zielvariablen

data.income.value_counts()

#Ein Hot Encoding der kategorialen Merkmale

one_hot_workclass=pd.get_dummies(daten.arbeitsklasse)

one_hot_education=pd.get_dummies(daten.bildung)

one_hot_marital_Status=pd.get_dummies(data.marital_Status)

one_hot_occupation=pd.get_dummies(data.occupation)

one_hot_relationship=pd.get_dummies(daten.beziehung)

one_hot_race=pd.get_dummies(daten.rennen)

one_hot_sex=pd.get_dummies(daten.geschlecht)

one_hot_native_country=pd.get_dummies(data.native_country)

#Entfernen kategorischer Merkmale

data.drop([[‘Arbeiterklasse’,’Bildung’,’Familienstand_Status’,’Beruf’,’Verwandtschaft’,’Rasse’,’Geschlecht’,’Heimat_Land’],axis=1,inplace=True)

#Merging one hot encoded features with our dataset ‘data’

data=pd.concat([data,eine_heiße_Arbeiterklasse,eine_heiße_Bildung,ein_heißer_Ehegattenstand,ein_heißer_Beruf,eine_heiße_Beziehung,eine_heiße_Rasse,ein_heißes_Geschlecht,ein_heißes_Einheimatland],axis=1)

#Entfernen von Dulpikatspalten

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

daten=data.iloc[:, i]

#Hier ist unsere Zielvariable ‘Einkommen’ mit Werten wie 1 oder 0. 

#Trennen unserer Daten in Feature-Datensatz x und unseren Zieldatensatz y

x=data.drop(‘Einkommen’,Achse=1)

y=Daten.Einkommen

#Fehlende Werte in unsere Zielvariable einfließen lassen

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

#Nun teilen wir unseren Datensatz in Test und Zug auf

aus sklearn.model_selection importieren train_test_split

x_Zug,x_Test,y_Zug,y_Test=Zug_Test_Teilung(x,y,Test_Größe=.3)

#Xgboost anwenden

#Die Daten werden in einem DMatrix-Objekt gespeichert

#label wird verwendet, um unsere Ergebnisvariable zu definieren

dtrain=xgb.DMatrix(x_Zug,Bezeichnung=y_Zug)

dtest=xgb.DMatrix(x_test)

#Einstellungsparameter für xgboost

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

#Unser Modell trainieren

Anzahl_Runde=50

von datetime Import datetime

start = datetime.now()

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

stop = datetime.now()

#Ausführungszeit des Modells

Ausführungszeit_xgb = Stopp-Start

ausführungszeit_xgb

Darstellung #datetime.timedelta( , , , ) => (Tage, Sekunden, Mikrosekunden)

#jetzt unser Modell auf dem Testsatz vorhersagen

ypred=xg.vorhersagen(dtest)

ypred

#Wahrscheinlichkeiten in 1 oder 0 umwandeln 

für i im Bereich(0,9769):

    if ypred[i]>=.5: # Schwellenwert auf .5 setzen

       ypred[i]=1

    sonst:

       ypred[i]=0 

#Berechnungsgenauigkeit unseres Modells

aus sklearn.metrics Importgenauigkeit_Punktzahl

Genauigkeit_xgb = Genauigkeit_Punktzahl(y_test,ypred)

genauigkeit_xgb

~ Light GBM ~

train_data=lgb.datensatz(x_zug,label=y_zug)

#Einstellungsparameter für lightgbm

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

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

#Hier haben wir max_depth in xgb und LightGBM auf 7 gesetzt, um einen fairen Vergleich zwischen den beiden zu haben.

#Schulung unseres Modells mit leichtem gbm

Anzahl_Runde=50

start=datezeit.jetzt()

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

stop=datetime.now()

#Ausführungszeit des Modells

Ausführungszeit_lgbm = Stopp-Start

ausführungszeit_lgbm

#Vorhersage am Testsatz

ypred2=lgbm.predict(x_test)

ypred2[0:5] # zeigt die ersten 5 Vorhersagen

#Wahrscheinlichkeiten in 0 oder 1 umwandeln

für i im Bereich(0,9769):

    wenn ypred2[i]>=.5: # Schwellenwert auf .5 setzen

       ypred2[i]=1

    sonst: 

       ypred2[i]=0

#Berechnungsgenauigkeit

genauigkeit_lgbm = genauigkeit_kerbe(ypred2,y_test)

genauigkeit_lgbm

y_test.value_counts()

aus sklearn.metrics importieren roc_auc_score

#berechnen der roc_auc_score für xgboost

auc_xgb = roc_auc_score(y_test,ypred)

auc_xgb

#berechnen von roc_auc_score für leichte gbm.

auc_lgbm = roc_auc_score(y_test,ypred2)

auc_lgbm Vergleich_dict = {‘Genauigkeits-Punktzahl’:(Genauigkeit_lgbm,Genauigkeit_xgb),’auc-Punktzahl’:(auc_lgbm,auc_xgb),’Ausführungszeit’:(Ausführungszeit_lgbm,Ausführungszeit_xgb)}

#Erstellen eines Datenrahmens ‘comparison_df’ zum Vergleich der Leistung von Lightgbm und xgb.

vergleich_df = DatenFrame(vergleich_dict)

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

vergleich_df

Leistungsvergleich