By Qingyun Wu, Chi Wang, Antoni Baum, Richard Liaw & Michaël Galarnyk

VLAML is een lichtgewicht Python-bibliotheek van Microsoft Research die op een efficiënte en economische manier nauwkeurige machine learning-modellen vindt cutting edge algoritmen die zijn ontworpen om hulpbronnenefficiënt en gemakkelijk parallelliseerbaar te zijn. FLAML kan ook gebruiken Ray Tune voor gedistribueerde hyperparameterafstemming om deze AutoML-methoden in een cluster op te schalen.

Deze blog belicht:

• De behoefte aan economische AutoML-methoden
• Voordelige AutoML met FLAML
• Hoe de optimalisatie-algoritmen van FLAML te schalen met Ray Tune

De behoefte aan economische AutoML-methoden

 
 
AutoML staat bekend als een resource- en tijdrovende bewerking, omdat het met vallen en opstaan ​​gaat om een ​​hyperparameterconfiguratie met goede prestaties te vinden. Omdat de ruimte van mogelijke configuratiewaarden vaak erg groot is, is er behoefte aan een economische AutoML-methode die deze effectiever kan doorzoeken.

Het hoge resource- en tijdverbruik van het zoeken naar hyperparameters in AutoML komt neer op de volgende twee factoren:

1. groot aantal kandidaat-hyperparameterconfiguraties (proefversie) nodig om een ​​configuratie met goede prestaties te vinden
2. hoge 'evaluatie'-kosten van elke hyperparameter, aangezien de evaluatie het trainen en valideren van een machine learning-model met de gegeven trainingsgegevens omvat.

Om beide factoren aan te pakken, hebben Microsoft Researchers ontwikkeld VLAML (Snelle lichtgewicht AutoML).

Wat is FLAML?

 
FLAML is een nieuw uitgebrachte bibliotheek met ultramoderne optimalisatie-algoritmen voor hyperparameters. FLAML maakt gebruik van de structuur van de zoekruimte om tegelijkertijd te optimaliseren voor zowel kosten als modelprestaties. Het bevat twee nieuwe methoden ontwikkeld door Microsoft Research:

• Kostenbesparende optimalisatie (CFO)
• BlendZoeken

Cost-Frugal Optimization (CFO) is een methode die het zoekproces kostenbewust uitvoert. De zoekmethode begint vanaf een goedkoop beginpunt en beweegt geleidelijk naar een hogere kostenregio terwijl het gegeven doel wordt geoptimaliseerd (zoals modelverlies of nauwkeurigheid).

Blendsearch is een uitbreiding van CFO die de zuinigheid van CFO combineert met het verkenningsvermogen van Bayesiaanse optimalisatie. Net als CFO vereist BlendSearch een goedkoop startpunt als invoer als een dergelijk punt bestaat, en begint het zoeken vanaf daar. In tegenstelling tot CFO wacht BlendSearch echter niet tot de lokale zoekopdracht volledig is geconvergeerd voordat nieuwe startpunten worden uitgeprobeerd.

De economische HPO-methoden in FLAML zijn geïnspireerd op twee belangrijke inzichten:

1. Veel algoritmen voor machine learning hebben hyperparameters die een grote variatie in de trainingskosten kunnen veroorzaken. Een XGBoost-model met 10 bomen zal bijvoorbeeld veel sneller trainen dan een model met 1000 bomen.
2. De "kosten" voor parameters zijn vaak 'continu en consistent' — het evalueren van bomen=10 is goedkoper dan het evalueren van bomen=100, wat zelf goedkoper is dan het evalueren van bomen=500.

Samen bieden deze inzichten nuttig structurele informatie over de hyperparameters in de kostenruimte. De methoden, dwz CFO en BlendSearch, zijn in staat om deze inzichten effectief te benutten om de onderweg gemaakte kosten te verlagen zonder de convergentie naar de optimale oplossing te beïnvloeden.

Werkt FLAML?

 
In de laatste AutoML-benchmark, VLAML is in staat om dezelfde of betere prestaties te behalen als de geavanceerde AutoML-oplossingen met slechts 10% van de rekenkracht voor meer dan 62% van de taken.

De prestaties van FLAML worden toegeschreven aan de economische optimalisatiemethoden. De nieuwe HPO-methoden (CFO, BlendSearch) maken gebruik van de structuur van de zoekruimte om zoekopdrachten te kiezen die zijn geoptimaliseerd voor zowel goede prestaties als lage kosten. Dit kan een groot verschil maken in zoekefficiëntie onder budgetbeperkingen.

Afbeelding 1 toont een typisch resultaat verkregen uit FLAML en een state-of-the-art hyperparameter tuning-bibliotheek Optimaal voor het afstemmen van LightGBM met 9-dimensionale hyperparameters. Je ziet dat FLAML in veel kortere tijd tot een betere oplossing komt.

Afbeelding 1. Validatieverliescurve (1-auc) voor het afstemmen van LightGBM op een classificatie dataset. De lijnen en het gearceerde gebied tonen het gemiddelde en de standaarddeviatie van validatieverlies over 10 runs. Resultaten in deze figuur zijn verkregen uit experimenten met 1 cpu zonder parallellisatie (afbeelding door auteurs).

Het volgende codevoorbeeld laat zien hoe u aan de slag kunt met FLAML met slechts enkele regels code (ervan uitgaande dat de trainingsdataset wordt geleverd en opgeslagen als X_train, y_train). De taak is om hyperparameters van het LightGBM-model af te stemmen met een tijdsbudget van 60 seconden.

from flaml import AutoML
automl = AutoML()
automl.fit(X_train=X_train, y_train=y_train, time_budget=60, estimator_list=['lgbm']) ''' retrieve best model and best configuration found'''
print('Best ML model:', automl.model)
print('Best hyperparameter config:', automl.best_config)

In dit voorbeeld zoeken we in een standaard zoekruimte voor LightGBM, die al aanwezig is in FLAML. FLAML biedt uitgebreide aanpassingsopties voor iemands betrokken taak, zoals de leerlingklasse, de zoekruimte, de evaluatiemetriek, enz.

Een doorloopvoorbeeld

 
 
Nu gebruiken we een speelgoedvoorbeeld om het kostenbesparende gedrag van de CFO te demonstreren bij het afstemmen van XGBoost met twee hyperparameters: # bomen en # bladeren.

'''create an XGBoost learner class with a customized search space'''
from flaml.model import XGBoostSklearnEstimator
from flaml import tune class MyXGB(XGBoostSklearnEstimator):
​​ '''XGBoostSklearnEstimator with a customized search space''' @classmethod def search_space(cls, data_size, **params): upper = min(2**15, int(data_size)) return { 'n_estimators': { 'domain': tune.lograndint(lower=4, upper=upper), 'low_cost_init_value': 4, }, 'max_leaves': { 'domain': tune.lograndint(lower=4, upper=upper), 'low_cost_init_value': 4, }, } '''Use CFO in FLAML to tune XGBoost'''
from flaml import AutoML
automl = AutoML()
automl.add_learner(learner_name='my_xgboost', learner_class=MyXGB)
automl.fit(X_train=X_train, y_train=y_train, time_budget=15, estimator_list=['my_xgboost'], hpo_method='cfo')

Hoe CFO en BlendSearch werken

 
 
De twee GIF's hieronder tonen het zoektraject van CFO in respectievelijk de verlies- en evaluatiekostenruimte (dwz de evaluatietijd). CFO begint met een goedkoop beginpunt (gespecificeerd via low_cost_init_value in de zoekruimte) en voert lokale updates uit volgens de gerandomiseerde lokale zoekstrategie. Met een dergelijke strategie kan de CFO snel opschuiven naar de low-loss-regio, wat een goede convergentie-eigenschap laat zien. Bovendien vermijdt de CFO het verkennen van de dure regio tot het nodig is. Deze zoekstrategie is verder gefundeerd met a aantoonbaar convergentiepercentage en begrensde verwachte kosten.

Figuur 2. CFO bij het afstemmen van het aantal bladeren en het aantal bomen voor XGBoost. De twee heatmaps tonen de verlies- en kostenverdeling van alle configuraties. De zwarte stippen zijn de punten die in CFO zijn geëvalueerd. Zwarte stippen verbonden door lijnen zijn punten die bij evaluatie betere verliesprestaties opleveren (afbeelding door auteurs).

BlendSearch combineert deze lokale zoekstrategie die wordt gebruikt in CFO verder met globaal zoeken. Het maakt gebruik van de zuinigheid van CFO en de ruimteverkenningsmogelijkheden van wereldwijde zoekmethoden zoals Bayesiaanse optimalisatie. In het bijzonder onderhoudt BlendSearch één globaal zoekmodel en creëert geleidelijk lokale zoekthreads in de loop van de tijd op basis van de hyperparameterconfiguraties voorgesteld door het globale model. Het geeft verder prioriteit aan de wereldwijde zoekthread en meerdere lokale zoekthreads, afhankelijk van hun real-time prestaties en kosten. Het kan de efficiëntie van CFO verder verbeteren bij taken met gecompliceerde zoekruimte, bijvoorbeeld een zoekruimte die meerdere onsamenhangende, niet-continue subruimten bevat.

FLAML versus Bayesiaanse optimalisatieprestaties

 
 
Afbeelding 3 toont typisch gedrag van de economische HPO-methoden in FLAML (CFO wordt in deze afbeelding aangeduid met `LS') versus een Bayesiaanse optimalisatiemethode (BO) voor het afstemmen van XGBoost met 11 hyperparameters.

Uit figuur 3(a) zien we dat de evaluatietijd voor de voorgestelde configuraties in BO erg lang kan zijn. Wanneer de totale resource beperkt is, bijvoorbeeld 1 cpu-uur (of minder), kan BO geen bevredigend resultaat geven (Afbeelding 3(b)).

FLAML's CFO (met het label LS) en BlendSearch hebben duidelijke voordelen bij het snel vinden van goede configuraties: ze kunnen zich concentreren op configuraties die weinig evaluatietijd hebben, terwijl ze navigeren naar configuraties met goede prestaties, dwz weinig verlies.

Figuur 3. (a) is een spreidingsdiagram van de hyperparameterconfiguraties voorgesteld door verschillende methoden, waarbij de x-as en de y-as de evaluatietijd en het verlies zijn. De evaluatietijd van een hyperparameterconfiguratie is de tijd die nodig is voor het trainen van een machine learning-model met de hyperparameterconfiguratie op de trainingsgegevens en het valideren van de prestaties ervan op een validatiegegevensset. Het verlies is het validatieverlies. (b) toont het beste verlies verkregen door verschillende methoden over wandkloktijd. (beeldbron)

Hoe CFO en BlendSearch opschalen met de gedistribueerde afstemming van Ray Tune

 
 
Om hyperparameteroptimalisatie te versnellen, wilt u misschien parallelliseren uw hyperparameter-zoekopdracht. BlendSearch kan bijvoorbeeld goed werken in een parallelle setting: het maakt gebruik van meerdere zoekthreads die onafhankelijk kunnen worden uitgevoerd zonder duidelijke verslechtering van de prestaties. Deze wenselijke eigenschap is niet altijd waar voor bestaande optimalisatie-algoritmen zoals Bayesiaanse optimalisatie.

Om parallellisatie te bereiken, is FLAML geïntegreerd met Ray Tune. Ray Tune is een Python-bibliotheek die het afstemmen van hyperparameters versnelt doordat u geavanceerde optimalisatie-algoritmen op schaal kunt gebruiken. Met Ray Tune kunt u ook hyperparameter-zoekopdrachten van uw laptop naar een cluster schalen zonder uw code te wijzigen. U kunt Ray Tune in FLAML gebruiken of de hyperparameter-zoekmethoden van FLAML in Ray Tune uitvoeren om uw zoekopdracht te parallelliseren. Het volgende codevoorbeeld toont het vroegere gebruik, dat wordt bereikt door simpelweg het n_concurrent_trials argumentatie in FLAML.

'''Use BlendSearch for hyperparameter search, and Ray Tune for parallelizing concurrent trials (when n_concurrent_trials > 1) in FLAML to tune XGBoost'''
from flaml import AutoML
automl = AutoML()
automl.add_learner(learner_name='my_xgboost', learner_class=MyXGB)
automl.fit(X_train=X_train, y_train=y_train, time_budget=15, estimator_list=['my_xgboost'], hpo_method='bs', n_concurrent_trials=8)

Logo-bron (XGBoost, VLAML, Ray Tune)

De onderstaande code toont het laatste gebruik, een end-to-end voorbeeld van het gebruik van BlendSearch met Ray Tune.

from ray import tune from flaml import CFO, BlendSearch
import time def training_func(config): '''evaluate a hyperparameter configuration''' # we use a toy example with 2 hyperparameters metric = (round(config['x'])-85000)**2 - config['x']/config['y'] # usually the evaluation takes a non-neglible cost # and the cost could be related to certain hyperparameters # in this example, we assume it's proportional to x time.sleep(config['x']/100000) # use tune.report to report the metric to optimize tune.report(metric=metric) # provide the search space
search_space = { 'x': tune.lograndint(lower=1, upper=100000), 'y': tune.randint(lower=1, upper=100000) } # provide the low cost partial config
low_cost_partial_config={'x':1} # set up BlendSearch
blendsearch = BlendSearch( metric="metric", mode="min", space=search_space, low_cost_partial_config=low_cost_partial_config) blendsearch.set_search_properties(config={"time_budget_s": 60}) analysis = tune.run( training_func, # the function to evaluate a config config=search_space, metric='metric', # the name of the metric used for optimization mode='min', # the optimization mode, 'min' or 'max' num_samples=-1, # the maximal number of configs to try, -1 means infinite time_budget_s=60, # the time budget in seconds local_dir='logs/', # the local directory to store logs search_alg=blendsearch # or cfo ) print(analysis.best_trial.last_result) # the best trial's result
print(analysis.best_config) # the best config

Andere belangrijke Ray Tune-functies zijn onder meer:

• Automatische integratie met tools voor het volgen van experimenten zoals Tensorboard en Weights/Biases
• Ondersteuning voor GPU's
• Vroeg stoppen
• Een scikit-learn API om eenvoudig mee te integreren XGBoost, LichtGBM, Scikit-Leren, Etc.

Benchmarkresultaten

 
 
We hebben een experiment uitgevoerd om te controleren hoe goed BlendSearch zich verhoudt tot Optuna (met multivariate TPE-sampler) en willekeurig zoeken in een zeer parallelle setting. We hebben een subset van 12 datasets uit de AutoML-benchmark. Elke optimalisatierun werd uitgevoerd met 16 proeven parallel gedurende 20 minuten, met behulp van 3-voudige kruisvalidatie, met behulp van ROC-AUC (weighted one-vs-rest for multiclass datasets). De runs werden drie keer herhaald met verschillende willekeurige zaden. Reproductiecode is te vinden hier.

Afbeelding door auteurs

BlendSearch behaalde de beste kruisvalidatiescore in 6 van de 12 datasets. Bovendien had BlendSearch een gemiddelde verbetering van 2.52% ten opzichte van willekeurig zoeken, vergeleken met Optuna's 1.96%. Het is vermeldenswaard dat BlendSearch univariate Optuna-TPE gebruikte als globale zoeker - het gebruik van multivariate TPE zou de scores hoogstwaarschijnlijk verder verbeteren.

afbeelding door auteurs

Bovendien evalueerde BlendSearch, dankzij de kostenbesparende aanpak, gemiddeld twee keer zoveel pogingen als de andere zoekers in dezelfde tijdslimiet. Hieruit blijkt dat de kloof tussen BlendSearch en de andere algoritmen zal toenemen met grotere tijdsbudgetten.

Conclusie

 
 
FLAML is een nieuw uitgebrachte bibliotheek met state-of-the-art hyperparameter optimalisatie-algoritmen die gebruikmaken van de structuur van de zoekruimte om tegelijkertijd te optimaliseren voor zowel kosten als modelprestaties. FLAML kan ook gebruiken Ray Tune voor gedistribueerde hyperparameterafstemming om deze economische AutoML-methoden op te schalen binnen een cluster.

Voor meer informatie over FLAML, zie de GitHub-repository en project pagina. Als je op de hoogte wilt blijven van alles wat met Ray te maken heeft, overweeg dan @raydistributed volgen op twitter en meld u aan voor de nieuwsbrief.

 
ORIGINELE. Met toestemming opnieuw gepost.

Zie ook:

• Machine Learning Pipeline-optimalisatie met TPOT
• Binaire classificatie met geautomatiseerde machine learning
• Overzicht van AutoNLP van Hugging Face met voorbeeldproject