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