LGBMClassifier: A Getting Started Guide - KDnuggets

Återutgiven av Platon

anhängare: 0

LGBMClassifier: En guide för att komma igång
Bild av redaktör

Det finns ett stort antal maskininlärningsalgoritmer som är ägnade att modellera specifika fenomen. Medan vissa modeller använder en uppsättning attribut för att överträffa andra, inkluderar andra svaga elever för att använda resten av attributen för att ge ytterligare information till modellen, så kallade ensemblemodeller.

Utgångspunkten för ensemblemodellerna är att förbättra modellens prestanda genom att kombinera förutsägelser från olika modeller genom att minska deras fel. Det finns två populära ensemblingstekniker: packning och boosting.

Bagging, alias Bootstrapped Aggregation, tränar flera individuella modeller på olika slumpmässiga delmängder av träningsdata och beräknar sedan genomsnittet av deras förutsägelser för att producera den slutliga förutsägelsen. Boostning, å andra sidan, innebär att man tränar individuella modeller sekventiellt, där varje modell försöker rätta till de fel som gjorts av de tidigare modellerna.

Nu när vi har ett sammanhang om ensemblemodellerna, låt oss dubbelklicka på den förstärkande ensemblemodellen, närmare bestämt Light GBM (LGBM) algoritmen utvecklad av Microsoft.

LGBMClassifier står för Light Gradient Boosting Machine Classifier. Den använder beslutsträdsalgoritmer för rangordning, klassificering och andra maskininlärningsuppgifter. LGBMClassifier använder en ny teknik med Gradient-baserad One-Side Sampling (GOSS) och Exclusive Feature Bundling (EFB) för att hantera storskalig data med noggrannhet, vilket effektivt gör det snabbare och minskar minnesanvändningen.

Vad är Gradient-based One-Side Sampling (GOSS)?

Traditionella gradientförstärkningsalgoritmer använder all data för träning, vilket kan vara tidskrävande när man hanterar stora datamängder. LightGBM:s GOSS, å andra sidan, behåller alla instanser med stora gradienter och utför slumpmässig sampling på instanserna med små gradienter. Intuitionen bakom detta är att instanser med stora gradienter är svårare att passa och därmed bär på mer information. GOSS introducerar en konstant multiplikator för datainstanserna med små gradienter för att kompensera för informationsförlusten under samplingen.

Vad är Exclusive Feature Bundling (EFB)?

I en gles datauppsättning är de flesta av funktionerna nollor. EFB är en nästan förlustfri algoritm som paketerar/kombinerar ömsesidigt exklusiva funktioner (funktioner som inte är noll samtidigt) för att minska antalet dimensioner och därigenom påskynda träningsprocessen. Eftersom dessa funktioner är "exklusiva" behålls det ursprungliga funktionsutrymmet utan betydande informationsförlust.

LightGBM-paketet kan installeras direkt med pip – pythons pakethanterare. Skriv kommandot som delas nedan antingen på terminalen eller kommandotolken för att ladda ner och installera LightGBM-biblioteket på din maskin:

pip install lightgbm

Anaconda-användare kan installera det med kommandot "conda install" enligt listan nedan.

conda install -c conda-forge lightgbm

Baserat på ditt operativsystem kan du välja installationsmetod med hjälp av Denna guide.

Låt oss nu importera LightGBM och andra nödvändiga bibliotek:

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

Förbereda datauppsättningen

Vi använder den populära Titanic-datauppsättningen, som innehåller information om passagerarna på Titanic, med målvariabeln som anger om de överlevde eller inte. Du kan ladda ner datamängden från Kaggle eller använd följande kod för att ladda den direkt från Seaborn, som visas nedan:

titanic = sns.load_dataset('titanic')

Släpp onödiga kolumner som "deck", "embark_town" och "alive" eftersom de är överflödiga eller inte bidrar till någon persons överlevnad på fartyget. Därefter observerade vi att funktionerna "ålder", "pris" och "ombordat" saknade värden – observera att olika attribut tillskrivs lämpliga statistiska mått.

# 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])

Slutligen konverterar vi de kategoriska variablerna till numeriska variabler med hjälp av pandornas kategoriska koder. Nu är data förberedda för att starta modellträ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']

Utbildning av LGBMClassifier-modellen

För att börja träna LGBMClassifier-modellen måste vi dela upp datasetet i indatafunktioner och målvariabler, samt tränings- och testuppsättningar med hjälp av train_test_split-funktionen från 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)

Låt oss etikettkoda kategoriska ("vem") och ordningsdata ("klass") för att säkerställa att modellen förses med numerisk data, eftersom LGBM inte förbrukar icke-numerisk 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])

Därefter specificerar vi modellens hyperparametrar som argument till konstruktorn, eller så kan vi skicka dem som en ordbok till metoden set_params.

Det sista steget för att initiera modellträningen är att ladda datauppsättningen genom att skapa en instans av LGBMClassifier-klassen och anpassa den till träningsdatan.

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)

Låt oss sedan utvärdera den tränade klassificerarens prestanda på den osynliga eller testdatauppsättningen.

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

Inställning av hyperparameter

LGBMClassifieraren tillåter mycket flexibilitet via hyperparametrar som du kan ställa in för optimal prestanda. Här kommer vi kort att diskutera några av de viktigaste hyperparametrarna:

num_leaves: Detta är huvudparametern för att styra trädmodellens komplexitet. Helst bör värdet på num_leaves vara mindre än eller lika med 2^(max_depth).
min_data_i_blad: Detta är en viktig parameter för att förhindra övermontering i ett lövvist träd. Dess optimala värde beror på antalet träningsprover och num_leaves.
Max djup: Du kan använda detta för att explicit begränsa träddjupet. Det är bäst att justera den här parametern i händelse av överanpassning.

Låt oss ställa in dessa hyperparametrar och träna en ny modell:

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

Observera att själva justeringen av hyperparametrar är en process som involverar försök och misstag och kan också styras av erfarenhet och en djupare förståelse av den ökande algoritmen och ämnesexpertisen (domänkunskapen) för det affärsproblem du arbetar med.

I det här inlägget lärde du dig om LightGBM-algoritmen och dess Python-implementering. Det är en flexibel teknik som är användbar för olika typer av klassificeringsproblem och bör vara en del av din maskininlärningsverktygssats.

Vidhi Chugh är en AI-strateg och en digital transformationsledare som arbetar i skärningspunkten mellan produkt, vetenskap och teknik för att bygga skalbara maskininlärningssystem. Hon är en prisbelönt innovationsledare, en författare och en internationell talare. Hon är på ett uppdrag att demokratisera maskininlärning och bryta jargongen för alla att vara en del av denna transformation.