LGBMClassifier: En Kom godt i gang - KDnuggets

Genudgivet af Platon

Abonnenter: 0

LGBMClassifier: En vejledning til at komme godt i gang
Billede af redaktør

Der er et stort antal maskinlæringsalgoritmer, der er egnede til at modellere specifikke fænomener. Mens nogle modeller bruger et sæt egenskaber til at udkonkurrere andre, inkluderer andre svage elever til at bruge resten af egenskaberne til at give yderligere information til modellen, kendt som ensemblemodeller.

Udgangspunktet for ensemblemodellerne er at forbedre modellens ydeevne ved at kombinere forudsigelserne fra forskellige modeller ved at reducere deres fejl. Der er to populære ensembling-teknikker: bagging og boosting.

Bagging, også kaldet Bootstrapped Aggregation, træner flere individuelle modeller på forskellige tilfældige delmængder af træningsdataene og danner derefter gennemsnittet af deres forudsigelser for at producere den endelige forudsigelse. Boosting involverer på den anden side træning af individuelle modeller sekventielt, hvor hver model forsøger at rette op på de fejl, der er lavet af de tidligere modeller.

Nu hvor vi har kontekst om ensemblemodellerne, lad os dobbeltklikke på den boostende ensemblemodel, specifikt Light GBM (LGBM) algoritmen udviklet af Microsoft.

LGBMClassifier står for Light Gradient Boosting Machine Classifier. Den bruger beslutningstræalgoritmer til rangering, klassificering og andre maskinlæringsopgaver. LGBMClassifier bruger en ny teknik med Gradient-baseret One-Side Sampling (GOSS) og Exclusive Feature Bundling (EFB) til at håndtere data i stor skala med nøjagtighed, hvilket effektivt gør det hurtigere og reducerer hukommelsesforbrug.

Hvad er Gradient-baseret One-Side Sampling (GOSS)?

Traditionelle gradientforstærkende algoritmer bruger alle data til træning, hvilket kan være tidskrævende, når man har at gøre med store datasæt. LightGBM's GOSS beholder på den anden side alle forekomster med store gradienter og udfører tilfældige stikprøver på forekomster med små gradienter. Intuitionen bag dette er, at instanser med store gradienter er sværere at passe og dermed bærer mere information. GOSS introducerer en konstant multiplikator for dataforekomsterne med små gradienter for at kompensere for informationstabet under prøvetagning.

Hvad er Exclusive Feature Bundling (EFB)?

I et sparsomt datasæt er de fleste af funktionerne nuller. EFB er en næsten tabsfri algoritme, der samler/kombinerer gensidigt eksklusive funktioner (funktioner, der ikke er nul på samme tid) for at reducere antallet af dimensioner og derved accelerere træningsprocessen. Da disse funktioner er "eksklusive", bevares den oprindelige funktionsplads uden væsentligt tab af information.

LightGBM-pakken kan installeres direkte ved hjælp af pip – pythons pakkehåndtering. Indtast kommandoen delt nedenfor enten på terminalen eller kommandoprompten for at downloade og installere LightGBM-biblioteket på din maskine:

pip install lightgbm

Anaconda-brugere kan installere det ved at bruge kommandoen "conda install" som angivet nedenfor.

conda install -c conda-forge lightgbm

Baseret på dit OS, kan du vælge installationsmetoden vha denne vejledning.

Lad os nu importere LightGBM og andre nødvendige biblioteker:

import numpy as np
import pandas as pd
import seaborn as sns
import lightgbm as lgb
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

Forberedelse af datasættet

Vi bruger det populære Titanic-datasæt, som indeholder information om passagererne på Titanic, hvor målvariablen angiver, om de overlevede eller ej. Du kan downloade datasættet fra Kaggle eller brug følgende kode til at indlæse den direkte fra Seaborn, som vist nedenfor:

titanic = sns.load_dataset('titanic')

Drop unødvendige kolonner såsom "dæk", "embark_town" og "alive", fordi de er overflødige eller ikke bidrager til overlevelsen af nogen person på skibet. Dernæst observerede vi, at funktionerne "alder", "billetpris" og "indbegyndt" mangler værdier - bemærk, at forskellige attributter tillægges passende statistiske mål.

# Drop unnecessary columns
titanic = titanic.drop(['deck', 'embark_town', 'alive'], axis=1) # Replace missing values with the median or mode
titanic['age'] = titanic['age'].fillna(titanic['age'].median())
titanic['fare'] = titanic['fare'].fillna(titanic['fare'].mode()[0])
titanic['embarked'] = titanic['embarked'].fillna(titanic['embarked'].mode()[0])

Til sidst konverterer vi de kategoriske variable til numeriske variable ved hjælp af pandas kategoriske koder. Nu er dataene forberedt til at starte modeltræningsprocessen.

# Convert categorical variables to numerical variables
titanic['sex'] = pd.Categorical(titanic['sex']).codes
titanic['embarked'] = pd.Categorical(titanic['embarked']).codes # Split the dataset into input features and the target variable
X = titanic.drop('survived', axis=1)
y = titanic['survived']

Træning af LGBMClassifier-modellen

For at begynde at træne LGBMClassifier-modellen skal vi opdele datasættet i inputfunktioner og målvariabler samt trænings- og testsæt ved hjælp af train_test_split-funktionen fra scikit-learn.

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Lad os mærke kode kategoriske (“hvem”) og ordinære data (“klasse”) for at sikre, at modellen leveres med numeriske data, da LGBM ikke forbruger ikke-numeriske data.

class_dict = { "Third": 3, "First": 1, "Second": 2
}
who_dict = { "child": 0, "woman": 1, "man": 2
}
X_train['class'] = X_train['class'].apply(lambda x: class_dict[x])
X_train['who'] = X_train['who'].apply(lambda x: who_dict[x])
X_test['class'] = X_test['class'].apply(lambda x: class_dict[x])
X_test['who'] = X_test['who'].apply(lambda x: who_dict[x])

Dernæst angiver vi modelhyperparametrene som argumenter til konstruktøren, eller vi kan videregive dem som en ordbog til metoden set_params.

Det sidste trin til at starte modeltræningen er at indlæse datasættet ved at oprette en forekomst af LGBMClassifier-klassen og tilpasse den til træningsdataene.

params = { 'objective': 'binary', 'boosting_type': 'gbdt', 'num_leaves': 31, 'learning_rate': 0.05, 'feature_fraction': 0.9
}
clf = lgb.LGBMClassifier(**params)
clf.fit(X_train, y_train)

Lad os derefter evaluere den trænede klassifikators ydeevne på det usete eller testdatasæt.

predictions = clf.predict(X_test)
print(classification_report(y_test, predictions))

 precision recall f1-score support 0 0.84 0.89 0.86 105 1 0.82 0.76 0.79 74 accuracy 0.83 179 macro avg 0.83 0.82 0.82 179
weighted avg 0.83 0.83 0.83 179

Tuning af hyperparameter

LGBMClassifieren giver mulighed for stor fleksibilitet via hyperparametre, som du kan indstille for optimal ydeevne. Her vil vi kort diskutere nogle af de vigtigste hyperparametre:

antal_blade: Dette er hovedparameteren til at kontrollere kompleksiteten af træmodellen. Ideelt set bør værdien af num_leaves være mindre end eller lig med 2^(max_depth).
min_data_i_blad: Dette er en vigtig parameter for at forhindre overpasning i et bladvist træ. Dens optimale værdi afhænger af antallet af træningsprøver og antal_blade.
max_depth: Du kan bruge dette til eksplicit at begrænse trædybden. Det er bedst at justere denne parameter i tilfælde af overfitting.

Lad os tune disse hyperparametre og træne en ny model:

model = lgb.LGBMClassifier(num_leaves=31, min_data_in_leaf=20, max_depth=5)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
print(classification_report(y_test, predictions))

 precision recall f1-score support 0 0.85 0.89 0.87 105 1 0.83 0.77 0.80 74 accuracy 0.84 179 macro avg 0.84 0.83 0.83 179
weighted avg 0.84 0.84 0.84 179

Bemærk, at selve justeringen af hyperparametre er en proces, der involverer forsøg og fejl og kan også være styret af erfaring og en dybere forståelse af den boostende algoritme og emneekspertise (domæneviden) af det forretningsproblem, du arbejder på.

I dette indlæg lærte du om LightGBM-algoritmen og dens Python-implementering. Det er en fleksibel teknik, der er nyttig til forskellige typer klassifikationsproblemer og bør være en del af dit maskinlæringsværktøj.

Vidhi Chugh er en AI-strateg og en digital transformationsleder, der arbejder i krydsfeltet mellem produkt, videnskab og teknik for at bygge skalerbare maskinlæringssystemer. Hun er en prisvindende innovationsleder, en forfatter og en international foredragsholder. Hun er på en mission om at demokratisere maskinlæring og bryde jargonen for, at alle kan være en del af denne transformation.