Ottimizza gli iperparametri con l'ottimizzazione automatica dei modelli di Amazon SageMaker

I modelli di machine learning (ML) stanno conquistando il mondo. Le loro prestazioni si basano sull'utilizzo dei giusti dati di addestramento e sulla scelta del modello e dell'algoritmo giusti. Ma non finisce qui. In genere, gli algoritmi rinviano alcune decisioni di progettazione al professionista ML affinché le adotti per i loro dati e compiti specifici. Queste decisioni di progettazione differite si manifestano come iperparametri.

Cosa significa quel nome? Il risultato dell'addestramento ML, il modello, può essere in gran parte visto come una raccolta di parametri appresi durante l'addestramento. Pertanto, i parametri utilizzati per configurare il processo di addestramento ML vengono quindi chiamati iperparametri, ovvero parametri che descrivono la creazione di parametri. In ogni caso, sono di uso molto pratico, come il numero di epoche da addestrare, il tasso di apprendimento, la profondità massima di un albero decisionale e così via. E prestiamo molta attenzione a loro perché hanno un impatto importante sulle prestazioni finali del tuo modello.

Proprio come girare una manopola su un ricevitore radio per trovare la frequenza giusta, ogni iperparametro dovrebbe essere attentamente regolato per ottimizzare le prestazioni. La ricerca nello spazio degli iperparametri per i valori ottimali è indicata come messa a punto dell'iperparametro or ottimizzazione degli iperparametri (HPO) e dovrebbe risultare in un modello che fornisca previsioni accurate.

In questo post, impostiamo ed eseguiamo il nostro primo lavoro HPO utilizzando Ottimizzazione automatica del modello di Amazon SageMaker (AMT). Apprendiamo i metodi disponibili per esplorare i risultati e creiamo alcune visualizzazioni approfondite delle nostre prove HPO e dell'esplorazione dello spazio iperparametrico!

Ottimizzazione automatica del modello di Amazon SageMaker

Come professionista ML che utilizza SageMakerAMT, puoi concentrarti su quanto segue:

• Fornire un lavoro di formazione
• Definire la giusta metrica oggettiva corrispondente alla tua attività
• Ambito dello spazio di ricerca degli iperparametri

SageMaker AMT si occupa del resto e non è necessario pensare all'infrastruttura, all'orchestrazione dei lavori di formazione e al miglioramento della selezione degli iperparametri.

Iniziamo utilizzando SageMaker AMT per il nostro primo semplice lavoro HPO, per addestrare e mettere a punto un algoritmo XGBoost. Vogliamo che il tuo viaggio AMT sia pratico e pratico, quindi abbiamo condiviso l'esempio di seguito Repository GitHub. Questo post riguarda il 1_tuning_of_builtin_xgboost.ipynb taccuino.

In un prossimo post, estenderemo l'idea di trovare solo i migliori iperparametri e includeremo l'apprendimento dello spazio di ricerca e a quali intervalli di iperparametri è sensibile un modello. Mostreremo anche come trasformare un'attività di ottimizzazione one-shot in una conversazione in più passaggi con il professionista ML, da imparare insieme. Restate sintonizzati (gioco di parole)!

Prerequisiti

Questo post è per chiunque sia interessato a conoscere HPO e non richiede una conoscenza preliminare dell'argomento. Tuttavia, la familiarità di base con i concetti di ML e la programmazione Python è utile. Per la migliore esperienza di apprendimento, ti consigliamo vivamente di seguirci eseguendo ogni passaggio nel taccuino parallelamente alla lettura di questo post. E alla fine del taccuino, puoi anche provare una visualizzazione interattiva che rende vivi i risultati della messa a punto.

Panoramica della soluzione

Creeremo una configurazione end-to-end per eseguire il nostro primo lavoro HPO utilizzando SageMaker AMT. Quando il nostro lavoro di messa a punto è completo, esaminiamo alcuni dei metodi disponibili per esplorare i risultati, sia tramite il Console di gestione AWS e in modo programmatico tramite gli SDK e le API AWS.

Per prima cosa, familiarizziamo con l'ambiente e SageMaker Training eseguendo un lavoro di formazione autonomo, senza alcuna messa a punto per ora. Utilizziamo l'algoritmo XGBoost, uno dei tanti algoritmi forniti come a Algoritmo integrato di SageMaker (non è richiesto alcun copione di formazione!).

Vediamo come SageMaker Training opera nei seguenti modi:

• Avvia e arresta un'istanza
• Fornisce il contenitore necessario
• Copia i dati di addestramento e convalida nell'istanza
• Gestisce la formazione
• Raccoglie metriche e registri
• Raccoglie e memorizza il modello addestrato

Quindi passiamo ad AMT ed eseguiamo un lavoro HPO:

• Impostiamo e lanciamo il nostro lavoro di messa a punto con AMT
• Ci immergiamo nei metodi disponibili per estrarre metriche e metadati dettagliati sulle prestazioni per ogni lavoro di formazione, che ci consentono di saperne di più sui valori ottimali nel nostro spazio iperparametrico
• Ti mostriamo come visualizzare i risultati delle prove
• Ti forniamo gli strumenti per visualizzare i dati in una serie di grafici che rivelano preziose informazioni sul nostro spazio iperparametrico

Addestra un algoritmo XGBoost integrato di SageMaker

Tutto inizia con l'addestramento di un modello. In tal modo, abbiamo un'idea di come funziona SageMaker Training.

Vogliamo sfruttare la velocità e la facilità d'uso offerte da SageMaker algoritmi incorporati. Tutto ciò di cui abbiamo bisogno sono alcuni passaggi per iniziare con la formazione:

1. Preparare e caricare i dati – Scarichiamo e prepariamo il nostro set di dati come input per XGBoost e lo carichiamo sul nostro Servizio di archiviazione semplice Amazon (Amazon S3) secchio.
2. Seleziona l'URI dell'immagine del nostro algoritmo integrato – SageMaker utilizza questo URI per recuperare il nostro contenitore di addestramento, che nel nostro caso contiene uno script di addestramento XGBoost pronto all'uso. Sono supportate diverse versioni dell'algoritmo.
3. Definire gli iperparametri – SageMaker fornisce un'interfaccia per definire il iperparametri per il nostro algoritmo integrato. Questi sono gli stessi iperparametri utilizzati dalla versione open source.
4. Costruisci lo stimatore – Definiamo i parametri di addestramento come il tipo di istanza e il numero di istanze.
5. Chiama la funzione fit() – Iniziamo il nostro lavoro di formazione.

Il diagramma seguente mostra come questi passaggi interagiscono.

Fornisci i dati

Per eseguire l'addestramento ML, dobbiamo fornire dati. Forniamo i nostri dati di formazione e convalida a SageMaker tramite Amazon S3.

Nel nostro esempio, per semplicità, utilizziamo il bucket predefinito SageMaker per archiviare i nostri dati. Ma sentiti libero di personalizzare i seguenti valori secondo le tue preferenze:

sm_sess = sagemaker.session.Session([..])

BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
output_path = f's3://{BUCKET}/{PREFIX}/output'

Nel notebook utilizziamo un set di dati pubblico e memorizziamo i dati localmente nel file data directory. Quindi carichiamo i nostri dati di addestramento e convalida su Amazon S3. Successivamente, definiamo anche i puntatori a queste posizioni per passarli a SageMaker Training.

# acquire and prepare the data (not shown here)
# store the data locally
[..]
train_data.to_csv('data/train.csv', index=False, header=False)
valid_data.to_csv('data/valid.csv', index=False, header=False)
[..]
# upload the local files to S3
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/train/train.csv')).upload_file('data/train.csv')
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/valid/valid.csv')).upload_file('data/valid.csv')

In questo post, ci concentriamo sull'introduzione di HPO. A titolo illustrativo, utilizziamo un set di dati e un'attività specifici, in modo da poter ottenere misurazioni di metriche oggettive che utilizziamo quindi per ottimizzare la selezione degli iperparametri. Tuttavia, per il posto complessivo non contano né i dati né l'attività. Per presentarvi un quadro completo, descriviamo brevemente cosa facciamo: addestriamo un modello XGBoost che dovrebbe classificare le cifre scritte a mano dal
Riconoscimento ottico del set di dati di cifre scritte a mano [1] tramite Scikit-learn. XGBoost è un eccellente algoritmo per i dati strutturati e può anche essere applicato al set di dati Digits. I valori sono immagini 8×8, come nell'esempio seguente che mostra a
0 a
5 e
4.

Selezionare l'URI dell'immagine XGBoost

Dopo aver scelto il nostro algoritmo integrato (XGBoost), dobbiamo recuperare l'URI dell'immagine e passarlo a SageMaker per caricarlo sulla nostra istanza di addestramento. Per questo passaggio, esaminiamo il file versioni disponibili. Qui abbiamo deciso di utilizzare la versione 1.5.1, che offre l'ultima versione dell'algoritmo. A seconda dell'attività, i professionisti ML possono scrivere il proprio script di formazione che, ad esempio, include passaggi di preparazione dei dati. Ma questo non è necessario nel nostro caso.

Se vuoi scrivere il tuo copione di allenamento, resta sintonizzato, ci pensiamo noi nel nostro prossimo post! Ti mostreremo come eseguire i lavori di SageMaker Training con i tuoi script di formazione personalizzati.

Per ora, abbiamo bisogno dell'URI immagine corretto specificando l'algoritmo, la regione AWS e il numero di versione:

xgboost_container = sagemaker.image_uris.retrieve('xgboost', region, '1.5-1')

Questo è tutto. Ora abbiamo un riferimento all'algoritmo XGBoost.

Definire gli iperparametri

Ora definiamo i nostri iperparametri. Questi valori configurano il modo in cui il nostro modello verrà addestrato e alla fine influenzano il modo in cui il modello si comporta rispetto alla metrica oggettiva rispetto alla quale stiamo misurando, come l'accuratezza nel nostro caso. Si noti che nulla del seguente blocco di codice è specifico di SageMaker. In realtà stiamo usando il versione open source di XGBoost, appena fornito e ottimizzato per SageMaker.

Sebbene ognuno di questi iperparametri sia configurabile e regolabile, la metrica oggettiva multi:softmax è determinato dal nostro set di dati e dal tipo di problema che stiamo risolvendo. Nel nostro caso, il set di dati Digits contiene più etichette (l'osservazione di una cifra scritta a mano potrebbe essere 0 or 1,2,3,4,5,6,7,8,9), il che significa che è un problema di classificazione multiclasse.

hyperparameters = {
    'num_class': 10,
    'max_depth': 5,
    'eta':0.2,
    'alpha': 0.2,
    'objective':'multi:softmax',
    'eval_metric':'accuracy',
    'num_round':200,
    'early_stopping_rounds': 5
}

Per ulteriori informazioni sugli altri iperparametri, fare riferimento a Iperparametri XGBoost.

Costruisci lo stimatore

Configuriamo la formazione su un oggetto stimatore, che è un'interfaccia di alto livello per SageMaker Training.

Successivamente, definiamo il numero di istanze su cui eseguire il training, il tipo di istanza (basata su CPU o GPU) e la dimensione dello storage collegato:

estimator = sagemaker.estimator.Estimator(
    image_uri=xgboost_container, 
    hyperparameters=hyperparameters,
    role=role,
    instance_count=1, 
    instance_type='ml.m5.large', 
    volume_size=5, # 5 GB 
    output_path=output_path
)

Ora abbiamo la configurazione dell'infrastruttura di cui abbiamo bisogno per iniziare. SageMaker Training si prenderà cura di tutto il resto.

Chiama la funzione fit()

Ricordi i dati che abbiamo caricato su Amazon S3 in precedenza? Ora creiamo riferimenti ad esso:

s3_input_train = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/train', content_type='csv')
s3_input_valid = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/valid', content_type='csv')

Una chiamata a fit() lancia la nostra formazione. Passiamo i riferimenti ai dati di addestramento che abbiamo appena creato per indirizzare SageMaker Training ai nostri dati di addestramento e convalida:

estimator.fit({'train': s3_input_train, 'validation': s3_input_valid})

Si noti che per eseguire HPO in un secondo momento, in realtà non è necessario chiamare fit() qui. Abbiamo solo bisogno dell'oggetto stimatore in seguito per HPO e potremmo semplicemente passare alla creazione del nostro lavoro HPO. Ma poiché vogliamo conoscere SageMaker Training e vedere come eseguire un singolo lavoro di formazione, lo chiamiamo qui ed esaminiamo l'output.

Dopo l'avvio dell'addestramento, iniziamo a vedere l'output sotto le celle, come mostrato nello screenshot seguente. L'uscita è disponibile in Amazon Cloud Watch così come in questo taccuino.

Il testo nero è l'output del registro di SageMaker stesso, che mostra i passaggi coinvolti nell'orchestrazione dell'addestramento, come l'avvio dell'istanza e il caricamento dell'immagine di addestramento. Il testo blu viene emesso direttamente dall'istanza di addestramento stessa. Possiamo osservare il processo di caricamento e analisi dei dati di addestramento e vedere visivamente l'avanzamento dell'addestramento e il miglioramento della metrica obiettivo direttamente dallo script di addestramento in esecuzione sull'istanza.

Si noti inoltre che al termine del lavoro di output, vengono visualizzati la durata dell'addestramento in secondi e i secondi fatturabili.

Infine, vediamo che SageMaker carica il nostro modello di addestramento nel percorso di output S3 definito sull'oggetto stimatore. Il modello è pronto per essere distribuito per l'inferenza.

In un post futuro, creeremo il nostro contenitore di addestramento e definiremo le nostre metriche di addestramento da emettere. Vedrai come SageMaker è indipendente da quale contenitore lo passi per l'addestramento. Questo è molto utile quando vuoi iniziare rapidamente con un algoritmo integrato, ma poi decidi di passare il tuo script di allenamento personalizzato!

Ispeziona i lavori di formazione attuali e precedenti

Finora, abbiamo lavorato dal nostro notebook con il nostro codice e inviato lavori di formazione a SageMaker. Cambiamo prospettiva e lasciamo il notebook per un momento per vedere come appare sulla console SageMaker.

SageMaker conserva un registro storico dei lavori di addestramento eseguiti, delle loro configurazioni come iperparametri, algoritmi, input di dati, tempo fatturabile e risultati. Nell'elenco dello screenshot precedente, vengono visualizzati i lavori di addestramento più recenti filtrati per XGBoost. Il lavoro di formazione evidenziato è il lavoro che abbiamo appena addestrato nel notebook, di cui hai visto l'output in precedenza. Immergiamoci in questo lavoro di formazione individuale per ottenere maggiori informazioni.

Lo screenshot seguente mostra la visualizzazione della console del nostro processo di formazione.

Possiamo rivedere le informazioni che abbiamo ricevuto come output della cella al nostro fit() funzione nel lavoro di addestramento individuale all'interno della console SageMaker, insieme ai parametri e ai metadati che abbiamo definito nel nostro estimatore.

Richiama l'output del log dall'istanza di addestramento che abbiamo visto in precedenza. Possiamo accedere ai log del nostro lavoro di formazione anche qui, scorrendo fino al file Monitorare sezione e scelta Visualizza i registri.

Questo ci mostra i log dell'istanza all'interno di CloudWatch.

Ricorda anche gli iperparametri che abbiamo specificato nel nostro notebook per il lavoro di formazione. Li vediamo anche qui nella stessa interfaccia utente del lavoro di formazione.

In effetti, i dettagli e i metadati che abbiamo specificato in precedenza per il nostro lavoro di addestramento e stimatore possono essere trovati in questa pagina sulla console SageMaker. Disponiamo di un utile registro delle impostazioni utilizzate per l'addestramento, ad esempio quale contenitore di addestramento è stato utilizzato e le posizioni dei set di dati di addestramento e convalida.

Potresti chiederti a questo punto, perché esattamente questo è rilevante per l'ottimizzazione degli iperparametri? È perché puoi cercare, ispezionare e approfondire quelle prove HPO che ci interessano. Forse quelle con i migliori risultati o quelle che mostrano un comportamento interessante. Lasciamo a te ciò che definisci "interessante". Ci fornisce un'interfaccia comune per ispezionare i nostri lavori di formazione e puoi utilizzarla con SageMaker Search.

Sebbene SageMaker AMT organizzi i lavori HPO, le prove HPO vengono tutte avviate come singoli lavori di formazione SageMaker e sono accessibili come tali.

Con la formazione coperta, mettiamoci a punto!

Addestra e ottimizza un algoritmo XGBoost integrato di SageMaker

Per mettere a punto il nostro modello XGBoost, riutilizzeremo i nostri iperparametri esistenti e definiremo gli intervalli di valori che vogliamo esplorare per loro. Pensa a questo come a un'estensione dei confini dell'esplorazione all'interno del nostro spazio di ricerca iperparametrico. Il nostro lavoro di ottimizzazione campiona dallo spazio di ricerca ed eseguirà lavori di addestramento per nuove combinazioni di valori. Il codice seguente mostra come specificare gli intervalli di iperparametri da cui SageMaker AMT dovrebbe campionare:

from sagemaker.tuner import IntegerParameter, ContinuousParameter, HyperparameterTuner

hpt_ranges = {
    'alpha': ContinuousParameter(0.01, .5),
    'eta': ContinuousParameter(0.1, .5),
    'min_child_weight': ContinuousParameter(0., 2.),
    'max_depth': IntegerParameter(1, 10)
}

Gli intervalli per un singolo iperparametro sono specificati dal loro tipo, come Parametro continuo. Per ulteriori informazioni e suggerimenti sulla scelta di questi intervalli di parametri, fare riferimento a Ottimizza un modello XGBoost.

Non abbiamo ancora eseguito alcun esperimento, quindi non conosciamo gli intervalli di valori validi per i nostri iperparametri. Pertanto, iniziamo con un'ipotesi plausibile, utilizzando la nostra conoscenza degli algoritmi e la nostra documentazione degli iperparametri per gli algoritmi integrati. Questo definisce un punto di partenza per definire lo spazio di ricerca.

Quindi eseguiamo un campionamento del processo di ottimizzazione dagli iperparametri negli intervalli definiti. Di conseguenza, possiamo vedere quali intervalli di iperparametri producono buoni risultati. Con questa conoscenza, possiamo affinare i confini dello spazio di ricerca restringendo o ampliando gli intervalli di iperparametri da utilizzare. Dimostriamo come imparare dalle prove nella sezione successiva e finale, dove indaghiamo e visualizziamo i risultati.

Nel nostro prossimo post, continueremo il nostro viaggio e ci immergeremo più a fondo. Inoltre, impareremo che ci sono diverse strategie che possiamo utilizzare per esplorare il nostro spazio di ricerca. Eseguiremo i successivi processi HPO per trovare valori ancora più performanti per i nostri iperparametri, confrontando queste diverse strategie. Vedremo anche come iniziare a caldo con SageMaker AMT per utilizzare le conoscenze acquisite dagli spazi di ricerca esplorati in precedenza nella nostra esplorazione oltre quei confini iniziali.

Per questo post, ci concentriamo su come analizzare e visualizzare i risultati di un singolo lavoro HPO utilizzando la strategia di ricerca bayesiana, che è probabilmente un buon punto di partenza.

Se segui il notebook collegato, nota che passiamo lo stesso stimatore che abbiamo utilizzato per il nostro singolo lavoro di formazione XGBoost integrato. Questo oggetto stimatore funge da modello per i nuovi processi di addestramento creati da AMT. AMT varierà quindi gli iperparametri all'interno degli intervalli che abbiamo definito.

Specificando che vogliamo massimizzare la nostra metrica oggettiva, validation:accuracy, stiamo dicendo a SageMaker AMT di cercare queste metriche nei log dell'istanza di addestramento e di scegliere i valori dell'iperparametro che ritiene possano massimizzare la metrica di accuratezza sui nostri dati di convalida. Abbiamo scelto un appropriato metrica oggettiva per XGBoost dalla nostra documentazione

Inoltre, possiamo sfruttare la parallelizzazione con max_parallel_jobs. Questo può essere uno strumento potente, soprattutto per le strategie le cui prove sono selezionate in modo indipendente, senza considerare (imparare da) i risultati delle prove precedenti. Esploreremo ulteriormente queste altre strategie e parametri nel nostro prossimo post. Per questo post utilizziamo il bayesiano, che è un'eccellente strategia predefinita.

Definiamo anche max_jobs per definire quante prove eseguire in totale. Sentiti libero di deviare dal nostro esempio e usa un numero più piccolo per risparmiare denaro.

n_jobs = 50
n_parallel_jobs = 3

tuner_parameters = {
    'estimator': estimator, # The same estimator object we defined above
    'base_tuning_job_name': 'bayesian',
    'objective_metric_name': 'validation:accuracy',
    'objective_type': 'Maximize',
    'hyperparameter_ranges': hpt_ranges,
    'strategy': 'Bayesian',
    'max_jobs': n_jobs,
    'max_parallel_jobs': n_parallel_jobs
}

Ancora una volta chiamiamo fit(), allo stesso modo di quando abbiamo lanciato un singolo lavoro di formazione in precedenza nel post. Ma questa volta sull'oggetto sintonizzatore, non sull'oggetto stimatore. Questo dà il via al lavoro di messa a punto e, a sua volta, AMT inizia i lavori di formazione.

tuner = HyperparameterTuner(**tuner_parameters)
tuner.fit({'train': s3_input_train, 'validation': s3_input_valid}, wait=False)
tuner_name = tuner.describe()['HyperParameterTuningJobName']
print(f'tuning job submitted: {tuner_name}.')

Il diagramma seguente espande la nostra architettura precedente includendo HPO con SageMaker AMT.

Vediamo che il nostro lavoro HPO è stato inviato. A seconda del numero di prove, definito da n_jobs e il livello di parallelizzazione, questo potrebbe richiedere del tempo. Per il nostro esempio, potrebbero essere necessari fino a 30 minuti per 50 prove con solo un livello di parallelizzazione di 3.

tuning job submitted: bayesian-221102-2053.

Al termine di questo lavoro di ottimizzazione, esploriamo le informazioni a nostra disposizione sulla console SageMaker.

Esamina i processi AMT sulla console

Troviamo il nostro lavoro di ottimizzazione sulla console SageMaker scegliendo Training nel riquadro di navigazione e poi Lavori di ottimizzazione degli iperparametri. Questo ci fornisce un elenco dei nostri lavori AMT, come mostrato nello screenshot seguente. Qui troviamo il nostro bayesian-221102-2053 lavoro di messa a punto e scoprire che ora è completo.

Diamo un'occhiata più da vicino ai risultati di questo lavoro HPO.

Abbiamo esplorato l'estrazione dei risultati a livello di codice nel file taccuino. Prima tramite il SDK Python di SageMaker, che è una libreria Python open source di livello superiore, che fornisce un'API dedicata a SageMaker. Poi attraverso Boto3, che ci fornisce API di livello inferiore per SageMaker e altri servizi AWS.

Utilizzando SageMaker Python SDK, possiamo ottenere i risultati del nostro lavoro HPO:

sagemaker.HyperparameterTuningJobAnalytics(tuner_name).dataframe()[:10]

Questo ci ha permesso di analizzare i risultati di ciascuna delle nostre prove in un DataFrame Pandas, come mostrato nello screenshot seguente.

Ora cambiamo di nuovo prospettiva e vediamo come appaiono i risultati sulla console SageMaker. Quindi esamineremo le nostre visualizzazioni personalizzate.

Nella stessa pagina, scegliendo il nostro bayesian-221102-2053 tuning job ci fornisce un elenco di prove che sono state eseguite per il nostro lavoro di tuning. Ogni prova HPO qui è un lavoro di formazione SageMaker. Ricorda in precedenza quando abbiamo addestrato il nostro singolo modello XGBoost e analizzato il lavoro di addestramento nella console SageMaker. Possiamo fare la stessa cosa per le nostre prove qui.

Mentre indaghiamo sulle nostre prove, lo vediamo bayesian-221102-2053-048-b59ec7b4 ha creato il modello con le migliori prestazioni, con un'accuratezza di convalida di circa l'89.815%. Esploriamo quali iperparametri hanno portato a questa performance scegliendo il Miglior lavoro di formazione scheda.

Possiamo vedere una vista dettagliata dei migliori iperparametri valutati.

Possiamo immediatamente vedere quali valori di iperparametro hanno portato a queste prestazioni superiori. Tuttavia, vogliamo saperne di più. Riesci a indovinare cosa? Lo vediamo alpha assume un valore approssimativo di 0.052456 e, analogamente, eta è impostato su 0.433495. Questo ci dice che questi valori hanno funzionato bene, ma ci dice poco sullo spazio iperparametrico stesso. Ad esempio, potremmo chiederci se 0.433495 per eta era il valore più alto testato o se c'è spazio per la crescita e il miglioramento del modello selezionando valori più alti.

Per questo, dobbiamo ridurre lo zoom e avere una visione molto più ampia per vedere come si sono comportati gli altri valori per i nostri iperparametri. Un modo per guardare molti dati contemporaneamente è tracciare i nostri valori iperparametrici dalle nostre prove HPO su un grafico. In questo modo vediamo come questi valori si sono comportati relativamente. Nella sezione successiva, estraiamo questi dati da SageMaker e li visualizziamo.

Visualizza le nostre prove

L'SDK di SageMaker ci fornisce i dati per la nostra esplorazione e i notebook ti danno una sbirciatina. Ma ci sono molti modi per utilizzarla e visualizzarla. In questo post, condividiamo un esempio utilizzando il Altair libreria di visualizzazione statistica, che usiamo per produrre una panoramica più visiva delle nostre prove. Questi si trovano nel amtviz pacchetto, che stiamo fornendo come parte del campione:

from amtviz import visualize_tuning_job
visualize_tuning_job(tuner, trials_only=True)

Il potere di queste visualizzazioni diventa immediatamente evidente quando si traccia l'accuratezza della convalida delle nostre prove (asse y) nel tempo (asse x). Il seguente grafico a sinistra mostra l'accuratezza della convalida nel tempo. Possiamo vedere chiaramente che le prestazioni del modello migliorano man mano che eseguiamo più prove nel tempo. Questo è un risultato diretto e previsto dell'esecuzione di HPO con una strategia bayesiana. Nel nostro prossimo post, vediamo come questo si confronta con altre strategie e osserviamo che questo non deve essere il caso per tutte le strategie.

Dopo aver esaminato l'avanzamento complessivo nel tempo, ora diamo un'occhiata al nostro spazio iperparametrico.

I seguenti grafici mostrano l'accuratezza della convalida sull'asse y, con ogni grafico visualizzato max_depth, alpha, etae min_child_weight sull'asse x, rispettivamente. Abbiamo tracciato il nostro intero lavoro HPO in ogni grafico. Ogni punto è una singola prova e ogni grafico contiene tutte le 50 prove, ma separate per ogni iperparametro. Ciò significa che la nostra prova con le migliori prestazioni, la n. 48, è rappresentata esattamente da un punto blu in ciascuno di questi grafici (che abbiamo evidenziato per te nella figura seguente). Possiamo confrontare visivamente le sue prestazioni nel contesto di tutte le altre 49 prove. Quindi, diamo un'occhiata da vicino.

Affascinante! Vediamo immediatamente quali regioni dei nostri intervalli definiti nel nostro spazio iperparametrico sono più performanti! Ripensando al nostro eta value, ora è chiaro che il campionamento di valori più vicini a 0 ha prodotto prestazioni peggiori, mentre avvicinandosi al nostro confine, 0.5, si ottengono risultati migliori. Il contrario sembra essere vero per alphae max_depth sembra avere un insieme più limitato di valori preferiti. Guardando max_depth, puoi anche vedere come l'utilizzo di una strategia bayesiana istruisca SageMaker AMT a campionare più frequentemente i valori che ha appreso funzionare bene in passato.

Guardando il nostro eta valore, potremmo chiederci se valga la pena esplorare più a destra, forse oltre 0.45? Continua a diminuire con una precisione inferiore o abbiamo bisogno di più dati qui? Questa domanda fa parte dello scopo dell'esecuzione del nostro primo lavoro HPO. Ci fornisce informazioni su quali aree dello spazio degli iperparametri dovremmo esplorare ulteriormente.

Se sei interessato a saperne di più e sei entusiasta quanto noi di questa introduzione all'argomento, resta sintonizzato per il nostro prossimo post, dove parleremo di più delle diverse strategie HPO, confrontandole tra loro e pratica la formazione con il nostro script Python.

ripulire

Per evitare di incorrere in costi indesiderati quando hai finito di sperimentare con HPO, devi rimuovere tutti i file nel tuo bucket S3 con il prefisso amt-visualize-demo e anche chiudere le risorse di Studio.

Esegui il seguente codice nel tuo notebook per rimuovere tutti i file S3 da questo post.

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

Se si desidera conservare i set di dati o gli artefatti del modello, è possibile modificare il prefisso nel codice a amt-visualize-demo/data cancellare solo i dati o amt-visualize-demo/output per eliminare solo gli artefatti del modello.

Conclusione

In questo post, abbiamo addestrato e messo a punto un modello utilizzando la versione integrata di SageMaker dell'algoritmo XGBoost. Utilizzando HPO con SageMaker AMT, abbiamo imparato a conoscere gli iperparametri che funzionano bene per questo particolare algoritmo e set di dati.

Abbiamo visto diversi modi per rivedere i risultati del nostro lavoro di ottimizzazione degli iperparametri. Partendo dall'estrazione degli iperparametri della prova migliore, abbiamo anche imparato come ottenere una comprensione più profonda di come le nostre prove sono progredite nel tempo e quali valori degli iperparametri hanno un impatto.

Utilizzando la console SageMaker, abbiamo anche visto come approfondire le sessioni di allenamento individuali e rivedere i loro registri.

Abbiamo quindi eseguito lo zoom indietro per visualizzare tutte le nostre prove insieme e rivedere le loro prestazioni in relazione ad altre prove e iperparametri.

Abbiamo appreso che, sulla base delle osservazioni di ogni prova, siamo stati in grado di navigare nello spazio degli iperparametri per vedere che piccole modifiche ai valori dei nostri iperparametri possono avere un enorme impatto sulle prestazioni del nostro modello. Con SageMaker AMT, possiamo eseguire l'ottimizzazione degli iperparametri per trovare buoni valori di iperparametri in modo efficiente e massimizzare le prestazioni del modello.

In futuro, esamineremo diverse strategie HPO offerte da SageMaker AMT e come utilizzare il nostro codice di addestramento personalizzato. Facci sapere nei commenti se hai una domanda o vuoi suggerire un'area che dovremmo trattare nei prossimi post.

Fino ad allora, auguriamo a te e ai tuoi modelli buon apprendimento e messa a punto!

Riferimenti

citazioni:

[1] Dua, D. e Graff, C. (2019). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, School of Information and Computer Science.

Circa gli autori

Andrea Ellul è un architetto di soluzioni con Amazon Web Services. Lavora con piccole e medie imprese in Germania. Al di fuori del lavoro, Andrew ama esplorare la natura a piedi o in bicicletta.

Elina Lesyk è un Solutions Architect con sede a Monaco di Baviera. La sua attenzione è rivolta ai clienti aziendali del settore dei servizi finanziari. Nel tempo libero, a Elina piace imparare la teoria della chitarra in spagnolo per imparare in modo incrociato e andare a correre.

Mariano Campi è Principal Solutions Architect con Amazon Web Services. Lavora con clienti di servizi finanziari in Germania sull'apprendimento automatico. Nel tempo libero Mariano ama fare escursioni con sua moglie.