Ottimizzazione degli iperparametri per un modello con Azure Machine Learning (v1)

SI APPLICA A:Estensione per Machine Learning dell’interfaccia della riga di comando di Azure CLI v1

Importante

Alcuni comandi dell'interfaccia della riga di comando (CLI) di Azure in questo articolo usano l'estensione azure-cli-ml, o v1, per Azure Machine Learning. L'assistenza per l'estensione v1 terminerà il 30 settembre 2025. Sarà possibile installare e usare l'estensione v1 fino a tale data.

Consigliamo di passare all'estensione ml, o v2, prima del 30 settembre 2025. Per ulteriori informazioni sull'estensione v2, vedere Estensione dell'interfaccia della riga di comando di Azure ML e Python SDK v2.

Automatizzazione dell'ottimizzazione efficiente degli iperparametri usando il pacchetto HyperDrive di Azure Machine Learning (v1). Informazioni su come completare i passaggi necessari per ottimizzare gli iperparametri con Azure Machine Learning SDK:

1. Definire lo spazio di ricerca dei parametri
2. Specificare una metrica primaria da ottimizzare
3. Specificare i criteri di terminazione anticipata per le esecuzioni con prestazioni ridotte
4. Creare e assegnare risorse
5. Avviare un esperimento con la configurazione definita
6. Visualizzare le esecuzioni di training
7. Selezionare la configurazione migliore per il modello

Che cos'è l'ottimizzazione degli iperparametri?

Gli iperparametri sono parametri regolabili che consentono di controllare il processo di training del modello. Ad esempio, con le reti neurali, si decide il numero di livelli nascosti e il numero di nodi in ogni livello. Le prestazioni del modello dipendono principalmente dagli iperparametri.

L'ottimizzazione degli iperparametri, detta anche affinamento degli iperparametri, è il processo di ricerca della configurazione degli iperparametri che produce prestazioni ottimali. Il processo è generalmente manuale e costoso a livello di calcolo.

Azure Machine Learning consente di automatizzare l'ottimizzazione degli iperparametri e di eseguire esperimenti in parallelo per affinare gli iperparametri in modo efficiente.

Definire lo spazio di ricerca

Ottimizzare gli iperparametri grazie all'esplorazione dell'intervallo dei valori definiti per ogni iperparametro.

Gli iperparametri possono essere discreti o continui e avere una distribuzione di valori descritta con un'espressione di parametro.

Iperparametri discreti

Gli iperparametri discreti vengono specificati come una scelta (choice) tra valori discreti. choice può essere:

• Uno o più valori delimitati da virgole
• Un oggetto range
• Un oggetto list arbitrario

    {
        "batch_size": choice(16, 32, 64, 128)
        "number_of_hidden_layers": choice(range(1,5))
    }

In questo caso, batch_size uno dei valori [16, 32, 64, 128] e number_of_hidden_layers accetta uno dei valori [1, 2, 3, 4].

È inoltre possibile specificare i seguenti iperparametri discreti avanzati usando una distribuzione:

• quniform(low, high, q): restituisce un valore come round(uniform(low, high) / q) * q
• qloguniform(low, high, q): restituisce un valore come round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q): restituisce un valore come round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q): restituisce un valore come round(exp(normal(mu, sigma)) / q) * q

Iperparametri continui

Gli iperparametri continui vengono specificati come distribuzione su un intervallo di valori continuo:

• uniform(low, high) : restituisce un valore distribuito in modo uniforme tra low e high
• loguniform(low, high) : restituisce un valore ricavato in base a exp(uniform(low, high)), in modo che il logaritmo del valore restituito sia distribuito uniformemente
• normal(mu, sigma) : restituisce un valore reale distribuito in modo normale con la media mu e la deviazione standard sigma
• lognormal(mu, sigma) : restituisce un valore ricavato in base a exp(normal(mu, sigma)), in modo che il logaritmo del valore restituito sia distribuito in modo normale

Esempio di definizione per lo spazio dei parametri:

    {    
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1)
    }

Questo codice definisce uno spazio di ricerca con due parametri: learning_rate e keep_probability. learning_rate ha una distribuzione normale con un valore medio di 10 e una deviazione standard pari a 3. keep_probability ha una distribuzione uniforme con un valore minimo di 0,05 e un valore massimo di 0,1.

Campionamento dello spazio degli iperparametri

Specificare il metodo di campionamento dei parametri da usare nello spazio degli iperparametri. Azure Machine Learning supporta i seguenti metodi:

• Campionamento casuale
• Campionamento a griglia
• Campionamento bayesiano

Campionamento casuale

Il campionamento casuale supporta iperparametri discreti e continui. Supporta la terminazione anticipata delle esecuzioni con prestazioni ridotte. Alcuni utenti eseguono una ricerca iniziale con campionamento casuale e successivamente affinano lo spazio di ricerca per migliorare i risultati.

Nel campionamento casuale i valori degli iperparametri vengono selezionati in modo casuale dallo spazio di ricerca definito.

from azureml.train.hyperdrive import RandomParameterSampling
from azureml.train.hyperdrive import normal, uniform, choice
param_sampling = RandomParameterSampling( {
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Campionamento a griglia

Il campionamento a griglia supporta iperparametri discreti. Usare il campionamento a griglia se può essere previsto un budget per eseguire una ricerca completa nello spazio di ricerca. Supporta la terminazione anticipata delle esecuzioni con prestazioni ridotte.

Il campionamento a griglia esegue una ricerca a griglia semplice su tutti i valori possibili. Il campionamento a griglia può essere usato soltanto con gli iperparametri choice. Ad esempio, nello spazio seguente sono presenti sei campioni:

from azureml.train.hyperdrive import GridParameterSampling
from azureml.train.hyperdrive import choice
param_sampling = GridParameterSampling( {
        "num_hidden_layers": choice(1, 2, 3),
        "batch_size": choice(16, 32)
    }
)

Campionamento bayesiano

Il campionamento bayesiano si basa sull'algoritmo di ottimizzazione bayesiano. Vengono selezionati i campioni in base alla modalità di esecuzione dei campioni precedenti, affinché i nuovi campioni migliorino la metrica primaria.

Il campionamento bayesiano è consigliato se si dispone di un budget sufficiente per esplorare lo spazio degli iperparametri. Per ottenere risultati ottimali, è consigliabile ottimizzare un numero massimo di esecuzioni maggiore o uguale a 20 volte il numero di iperparametri affinati.

Il numero di esecuzioni simultanee influisce sull'efficacia del processo di ottimizzazione. In genere, un numero minore di esecuzioni simultanee può migliorare la convergenza di campionamento, poiché il minor grado di parallelismo aumenta il numero di esecuzioni che traggono vantaggio dalle esecuzioni precedentemente completate.

Il campionamento bayesiano supporta solo le distribuzioni choice, uniform e quniformnello spazio di ricerca.

from azureml.train.hyperdrive import BayesianParameterSampling
from azureml.train.hyperdrive import uniform, choice
param_sampling = BayesianParameterSampling( {
        "learning_rate": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Specificare la metrica primaria

Specificare la metrica primaria da affinare per l'ottimizzazione degli iperparametri. Ogni esecuzione di training viene valutata in base a questa metrica primaria I criteri di terminazione anticipata usano la metrica primaria per individuare le esecuzioni con prestazioni ridotte.

Specificare i seguenti attributi per la metrica primaria:

• primary_metric_name: il nome della metrica primaria deve corrispondere esattamente al nome della metrica registrato dallo script di training
• primary_metric_goal: può essere PrimaryMetricGoal.MAXIMIZE o PrimaryMetricGoal.MINIMIZE e determina se la metrica primaria verrà aumentata o ridotta durante la valutazione dell'esecuzione.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

Questo esempio aumenta al massimo “l’accuratezza”.

Registrare le metriche per l'ottimizzazione degli iperparametri

Lo script di training per il modello deve registrare la metrica primaria durante il training del modello, in modo che HyperDrive possa accedervi per ottimizzare gli iperparametri.

Registrare la metrica primaria nello script di training con il seguente frammento di esempio:

from azureml.core.run import Run
run_logger = Run.get_context()
run_logger.log("accuracy", float(val_accuracy))

Lo script di training calcola val_accuracy e lo registra come "accuratezza" della metrica primaria. Ogni volta che si registra, la metrica viene ricevuta dal servizio di ottimizzazione degli iperparametri. Spetta all'utente determinare la frequenza di segnalazione.

Per altre informazioni sulla registrazione dei valori nelle esecuzioni di training del modello, vedere Abilitazione del registrazione nelle esecuzioni di training di Azure Machine Learning.

Specificare i criteri per la terminazione anticipata

È possibile interrompere automaticamente le esecuzioni con prestazioni insufficienti tramite un criterio di terminazione anticipata. La terminazione anticipata migliora l'efficienza computazionale.

È possibile configurare i seguenti parametri per controllare quando un criterio viene applicato:

• evaluation_interval: frequenza di applicazione del criterio. Ogni volta che lo script di training registra la metrica primaria viene conteggiata come un intervallo. Un valore evaluation_interval pari a 1 causa l'applicazione del criterio ogni volta che lo script di training segnala la metrica primaria. Un valore evaluation_interval pari a 2 applicherà il criterio tutte le altre volte. Se non specificato, evaluation_interval è impostato su 1 per impostazione predefinita.
• delay_evaluation: ritarda la prima valutazione dei criteri per un numero di intervalli specificato. Si tratta di un parametro facoltativo che consente l'esecuzione di tutte le configurazioni per un numero minimo iniziale di intervalli, evitando la terminazione anticipata delle esecuzioni di training. Se specificato, i criteri vengono applicati ogni multiplo di evaluation_interval che è maggiore o uguale a delay_evaluation.

Azure Machine Learning supporta i seguenti criteri di terminazione anticipata:

• Criteri Bandit
• Criteri di arresto Median
• Criteri di selezione Truncation
• Nessun criterio di interruzione

Criteri Bandit

I criteri Bandit si basano su fattore/entità del margine di flessibilità e sull'intervallo di valutazione. Bandit termina l'esecuzione quando la metrica primaria non rientra nella quantità specificata di fattore di flessibilità/margine di flessibilità dell'esecuzione più riuscita.

Nota

Il campionamento bayesiano non supporta la terminazione anticipata. Per usare il campionamento Bayesian, impostare early_termination_policy = None.

Specificare i seguenti parametri di configurazione:

• slack_factor o slack_amount: margine di flessibilità consentito rispetto all'esecuzione di training con le migliori prestazioni. slack_factor specifica il margine di flessibilità consentito come rapporto. slack_amount specifica il margine di flessibilità consentito come valore assoluto, anziché come rapporto.

  Considerare ad esempio un criterio Bandit applicato all'intervallo 10. Si supponga che l'esecuzione con le migliori prestazioni nell'intervallo 10 abbia segnalato una metrica primaria di 0,8 con l'obiettivo di aumentare al massimo la metrica primaria. Se il criterio specifica slack_factor pari a 0,2, saranno terminate le esecuzioni di training la cui metrica migliore nell'intervallo 10 è minore di 0,66 (0,8/(1+slack_factor)).

• evaluation_interval: (facoltativo) frequenza di applicazione del criterio

• delay_evaluation: (facoltativo) ritarda la prima valutazione dei criteri per un numero di intervalli specificato

from azureml.train.hyperdrive import BanditPolicy
early_termination_policy = BanditPolicy(slack_factor = 0.1, evaluation_interval=1, delay_evaluation=5)

In questo esempio, i criteri di terminazione anticipata vengono applicati a ogni intervallo in cui vengono segnalate le metriche, a partire dall'intervallo di valutazione 5. Verrà terminata qualsiasi esecuzione la cui metrica migliore è minore di (1/(1+0,1) o del 91% rispetto all'esecuzione con le migliori prestazioni.

Criteri di arresto con valore mediano

L’arresto con valore mediano è un criterio di terminazione anticipata basato sulle medie di esecuzione delle metriche primarie segnalate dalle esecuzioni. Il criterio calcola le medie di esecuzione su tutte le esecuzioni di training e arresta le esecuzioni il cui valore di metrica primaria è inferiore al valore mediano delle medie.

I parametri di configurazione accettati da questi criteri sono i seguenti:

• evaluation_interval: frequenza per l'applicazione del criterio (parametro facoltativo).
• delay_evaluation: ritarda la prima valutazione dei criteri per un numero di intervalli specificato (parametro facoltativo).

from azureml.train.hyperdrive import MedianStoppingPolicy
early_termination_policy = MedianStoppingPolicy(evaluation_interval=1, delay_evaluation=5)

In questo esempio, i criteri di terminazione anticipata vengono applicati a ogni intervallo, a partire dall'intervallo di valutazione 5. Un'esecuzione viene terminata nell'intervallo 5 se la metrica primaria migliore è inferiore al valore mediano delle medie in esecuzione negli intervalli 1:5 di tutte le esecuzioni di training.

Criteri di selezione con troncamento

La selezione con troncamento annulla una percentuale delle esecuzioni con le prestazioni più basse in ogni intervallo di valutazione. Le esecuzioni vengono confrontate usando la metrica primaria.

I parametri di configurazione accettati da questi criteri sono i seguenti:

• truncation_percentage: percentuale delle esecuzioni con le prestazioni più basse da terminare in ogni intervallo di valutazione. Immettere un valore intero compreso tra 1 e 99.
• evaluation_interval: (facoltativo) la frequenza di applicazione dei criteri
• delay_evaluation: (facoltativo) ritarda la prima valutazione dei criteri per un numero di intervalli specificato
• exclude_finished_jobs: specifica se escludere i processi completati quando si applica il criterio

from azureml.train.hyperdrive import TruncationSelectionPolicy
early_termination_policy = TruncationSelectionPolicy(evaluation_interval=1, truncation_percentage=20, delay_evaluation=5, exclude_finished_jobs=true)

In questo esempio, i criteri di terminazione anticipata vengono applicati a ogni intervallo, a partire dall'intervallo di valutazione 5. L'esecuzione termina nell’intervallo 5 se le prestazioni in tale intervallo rientrano nel 20% inferiore delle prestazioni di tutte le esecuzioni dell’intervallo 5 ed esclude i processi completati quando si applica il criterio.

Nessun criterio di terminazione (impostazione predefinita)

Se non viene specificato alcun criterio, il servizio di ottimizzazione degli iperparametri consente l'esecuzione di tutte le esecuzioni di training fino al completamento.

policy=None

Selezione di un criterio di interruzione anticipata

• Per impostare un criterio conservativo che consenta un risparmio senza terminare i processi promettenti, prendere in considerazione il criterio di arresto con valore mediano con evaluation_interval pari a 1 e delay_evaluation pari a 5. Queste sono impostazioni conservative, che possono garantire circa il 25-35% di risparmio senza alcuna perdita sulla metrica primaria (in base ai dati di valutazione).
• Per un risparmio più consistente, usare il criterio Bandit con slack consentito inferiore o il criterio di selezione con troncamento con una percentuale di troncamento maggiore.

Creazione e assegnazione di risorse

Controllare il budget delle risorse specificando il numero massimo di esecuzioni di training.

• max_total_runs: numero massimo di esecuzioni di training. Deve essere un numero intero compreso tra 1 e 1000.
• max_duration_minutes: (facoltativo) durata massima in minuti dell'esperimento di ottimizzazione degli iperparametri. Viene eseguito dopo l'annullamento della durata.

Nota

Se si specificano sia max_total_runs che max_duration_minutes, l'esperimento di ottimizzazione degli iperparametri viene terminato quando viene raggiunta la prima di queste due soglie.

Specificare inoltre il numero massimo di esecuzioni di training da eseguire simultaneamente durante la ricerca per l'ottimizzazione degli iperparametri.

• max_concurrent_runs: (facoltativo) numero massimo di esecuzioni simultanee. Se non è specificato, tutte le esecuzioni vengono avviate in parallelo. Se specificato, deve essere un numero intero compreso tra 1 e 100.

Nota

Il numero di esecuzioni simultanee è limitato dalle risorse disponibili nella destinazione di calcolo specificata. Verificare che nella destinazione di calcolo siano disponibili risorse sufficienti per la concorrenza desiderata.

max_total_runs=20,
max_concurrent_runs=4

Con questo codice, l'esperimento di ottimizzazione degli iperparametri viene configurato per l'uso di un massimo di 20 esecuzioni totali, eseguendo 4 configurazioni per volta.

Configurazione dell'esperimento di ottimizzazione degli iperparametri

Per configurare l'esperimento di ottimizzazione degli iperparametri, indicare quanto segue:

• Spazio di ricerca degli iperparametri definito
• Criterio di interruzione anticipata
• Metrica primaria
• Impostazioni di allocazione delle risorse
• ScriptRunConfig script_run_config

ScriptRunConfig è lo script di training eseguito con gli iperparametri campionati. Definisce le risorse per processo (nodo singolo o multiplo) e la destinazione di calcolo da usare.

Nota

La destinazione di calcolo usata in script_run_config deve avere risorse sufficienti a soddisfare il livello di concorrenza. Per altre informazioni su ScriptRunConfig, vedere Configurazione delle esecuzioni di training.

Configurare l'esperimento di ottimizzazione degli iperparametri:

from azureml.train.hyperdrive import HyperDriveConfig
from azureml.train.hyperdrive import RandomParameterSampling, BanditPolicy, uniform, PrimaryMetricGoal

param_sampling = RandomParameterSampling( {
        'learning_rate': uniform(0.0005, 0.005),
        'momentum': uniform(0.9, 0.99)
    }
)

early_termination_policy = BanditPolicy(slack_factor=0.15, evaluation_interval=1, delay_evaluation=10)

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

HyperDriveConfig imposta i parametri passati a ScriptRunConfig script_run_config. A sua volta, script_run_config passa i parametri allo script di training. Il frammento di codice precedente è tratto dal notebook di esempio Eseguire il training, ottimizzare gli iperparametri e distribuire con PyTorch. In questo esempio vengono ottimizzati i parametri learning_rate e momentum. L'arresto anticipato delle esecuzioni viene determinato da un BanditPolicy, che arresta un'esecuzione la cui metrica primaria non rientra in slack_factor (vedere Riferimento alla classe BanditPolicy).

Il codice seguente dell'esempio mostra la modalità di ricezione, analisi e passaggio dei valori ottimizzati alla funzione fine_tune_model dello script di training:

# from pytorch_train.py
def main():
    print("Torch version:", torch.__version__)

    # get command-line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--num_epochs', type=int, default=25,
                        help='number of epochs to train')
    parser.add_argument('--output_dir', type=str, help='output directory')
    parser.add_argument('--learning_rate', type=float,
                        default=0.001, help='learning rate')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum')
    args = parser.parse_args()

    data_dir = download_data()
    print("data directory is: " + data_dir)
    model = fine_tune_model(args.num_epochs, data_dir,
                            args.learning_rate, args.momentum)
    os.makedirs(args.output_dir, exist_ok=True)
    torch.save(model, os.path.join(args.output_dir, 'model.pt'))

Importante

Ogni esecuzione degli iperparametri riavvia il training dall’inizio, inclusa la ricompilazione del modello e di tutti i data loader. È possibile ridurre al minimo il costo usando una pipeline di Azure Machine Learning o un processo manuale per eseguire la preparazione dei dati quanto più possibile prima delle esecuzioni di training.

Invio di un esperimento di ottimizzazione degli iperparametri

Dopo aver definito la configurazione dell'ottimizzazione degli iperparametri, inviare l’esperimento:

from azureml.core.experiment import Experiment
experiment = Experiment(workspace, experiment_name)
hyperdrive_run = experiment.submit(hd_config)

Ottimizzazione degli iperparametri con avvio a caldo (facoltativo)

L’individuazione dei valori migliori degli iperparametri per il modello può essere un processo iterativo. È possibile riutilizzare le conoscenze delle cinque esecuzioni precedenti per accelerare l'ottimizzazione degli iperparametri.

L'avvio a caldo viene gestito in modo diverso a seconda del metodo di campionamento:

• Campionamento bayesiano: le versioni di valutazione dell'esecuzione precedente vengono usate come conoscenze precedenti per selezionare nuovi campioni e per migliorare la metrica primaria.
• Campionamento casuale o a griglia: la terminazione anticipata usa le conoscenze delle esecuzioni precedenti per determinare le esecuzioni con prestazioni insufficienti.

Specificare l'elenco delle esecuzioni padre da cui si desidera eseguire l’avvio a caldo.

from azureml.train.hyperdrive import HyperDriveRun

warmstart_parent_1 = HyperDriveRun(experiment, "warmstart_parent_run_ID_1")
warmstart_parent_2 = HyperDriveRun(experiment, "warmstart_parent_run_ID_2")
warmstart_parents_to_resume_from = [warmstart_parent_1, warmstart_parent_2]

In caso di annullamento di un esperimento di ottimizzazione degli iperparametri, è possibile riprendere le esecuzioni di training dall'ultimo checkpoint. Tuttavia, lo script di training deve gestire la logica del checkpoint.

L'esecuzione di training deve usare la stessa configurazione degli iperparametri e integrare le cartelle di output. Lo script di training deve accettare l'argomento resume-from, che contiene i file del checkpoint o del modello da cui riprendere l'esecuzione del training. È possibile riprendere singole esecuzioni di training usando il seguente frammento:

from azureml.core.run import Run

resume_child_run_1 = Run(experiment, "resume_child_run_ID_1")
resume_child_run_2 = Run(experiment, "resume_child_run_ID_2")
child_runs_to_resume = [resume_child_run_1, resume_child_run_2]

È possibile configurare l'esperimento di ottimizzazione degli iperparametri per l’avvio a caldo da un esperimento precedente o riprendere singole esecuzioni di training usando i parametri facoltativi resume_from e resume_child_runs nella configurazione:

from azureml.train.hyperdrive import HyperDriveConfig

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             resume_from=warmstart_parents_to_resume_from,
                             resume_child_runs=child_runs_to_resume,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

Visualizzare le esecuzioni di ottimizzazione degli iperparametri

È possibile visualizzare le esecuzioni di ottimizzazione degli iperparametri in studio di Azure Machine Learning oppure usare un widget Notebook.

Studio

È possibile visualizzare tutte le esecuzioni di ottimizzazione degli iperparametri in studio di Azure Machine Learning. Per ulteriori informazioni su come visualizzare un esperimento nel portale, vedere Visualizzare i record di esecuzione in studio.

• Grafico delle metriche: questa visualizzazione tiene traccia delle metriche registrate per ogni elemento figlio di hyperdrive eseguito nel corso dell'ottimizzazione degli iperparametri. Ogni riga rappresenta un'esecuzione figlio e ogni punto misura il valore della metrica primaria in corrispondenza dell'iterazione del runtime.

  

• Grafico delle coordinate parallele: questa visualizzazione mostra la correlazione tra le prestazioni della metrica primaria e i singoli valori degli iperparametri. Il grafico è interattivo tramite lo spostamento degli assi (selezione e trascinamento dell'etichetta dell'asse) e evidenziando i valori su un singolo asse (selezionare e trascinare verticalmente lungo un singolo asse per evidenziare un intervallo di valori desiderati). Il grafico delle coordinate parallele include un asse nella parte più a destra del grafico che traccia il valore della metrica migliore corrispondente agli iperparametri impostati per l'istanza di esecuzione. L'asse viene fornito per proiettare in modo più leggibile la legenda del gradiente del grafico sui dati.

  

• Grafico a dispersione bidimensionale: questa visualizzazione mostra la correlazione tra due iperparametri singoli insieme al valore della metrica primaria associata.

  

• Grafico a dispersione tridimensionale: questa visualizzazione è uguale alla visualizzazione 2D, ma consente di visualizzare tre dimensioni degli iperparametri per la correlazione con il valore della metrica primaria. È anche possibile selezionare e trascinare per riorientare il grafico per visualizzare correlazioni diverse nello spazio 3D.

  

Widget del notebook

Usare il widget Notebook per visualizzare lo stato delle esecuzioni di training. Il frammento seguente mostra tutte le esecuzioni di ottimizzazione degli iperparametri in un Jupyter Notebook:

from azureml.widgets import RunDetails
RunDetails(hyperdrive_run).show()

Il codice mostra una tabella con informazioni dettagliate sulle esecuzioni di training per ciascuna configurazione degli iperparametri.

È anche possibile visualizzare le prestazioni di ognuna delle esecuzioni nel corso del training.

Individuare il modello migliore

Dopo aver completato tutte le esecuzioni di ottimizzazione degli iperparametri, individuare la configurazione con le migliori prestazioni e i valori migliori degli iperparametri:

best_run = hyperdrive_run.get_best_run_by_primary_metric()
best_run_metrics = best_run.get_metrics()
parameter_values = best_run.get_details()['runDefinition']['arguments']

print('Best Run Id: ', best_run.id)
print('\n Accuracy:', best_run_metrics['accuracy'])
print('\n learning rate:',parameter_values[3])
print('\n keep probability:',parameter_values[5])
print('\n batch size:',parameter_values[7])

Notebook di esempio

Fare riferimento ai notebook train-hyperparameter-* in questa cartella:

• how-to-use-azureml/ml-frameworks

Per informazioni su come eseguire i notebook, vedere l'articolo Esplorare Azure Machine Learning con notebook Jupyter.

Passaggi successivi

• Tenere traccia di un esperimento
• Distribuire un modello con training