Registrare metriche, parametri e file con MLflow

SI APPLICA A: Python SDK azure-ai-ml v2 (corrente)

Azure Machine Learning supporta la registrazione e il monitoraggio degli esperimenti tramite il rilevamento di MLflow. È possibile registrare modelli, metriche, parametri e artefatti con MLflow, localmente nel computer o in un ambiente cloud.

I log consentono di diagnosticare gli errori e gli avvisi o di tenete traccia di metriche delle prestazioni come parametri e prestazioni modello. Questo articolo illustra come abilitare la registrazione negli scenari seguenti:

Prerequisiti

• È necessario avere un'area di lavoro di Azure Machine Learning. Se non è disponibile, vedere Creare risorse dell'area di lavoro.

• È necessario che siano installati i pacchetti mlflow e azureml-mlflow. In caso contrario, usare il comando seguente per installarli nell'ambiente di sviluppo:

  pip install mlflow azureml-mlflow
  

  Nota

  Per la registrazione asincrona delle metriche, è necessario disporre di MLflow versione 2.8.0+ e azureml-mlflow versione 1.55+.

• Se si esegue il rilevamento remoto (verifica degli esperimenti eseguiti all'esterno di Azure Machine Learning), configurare MLflow per tenere traccia degli esperimenti. Per altre informazioni, vedere Configurare MLflow per Azure Machine Learning.

• Per registrare metriche, parametri, artefatti e modelli negli esperimenti in Azure Machine Learning usando MLflow, è sufficiente importare MLflow nello script:

  import mlflow
  

Configurare gli esperimenti

MLflow organizza le informazioni negli esperimenti e nelle esecuzioni (in Azure Machine Learning le esecuzioni sono denominate processi). Esistono alcune differenze in come configurarle a seconda della modalità di esecuzione del codice:

import mlflow
# Set the experiment
mlflow.set_experiment("mlflow-experiment")

# Start the run
mlflow_run = mlflow.start_run()
# Log metrics or other information
mlflow.log_metric('mymetric', 1)
# End run 
mlflow.end_run()

import mlflow
mlflow.set_experiment("mlflow-experiment")

# Start the run, log metrics, end the run
with mlflow.start_run() as run:
    # Run started when context manager is entered, and ended when context manager exits
    mlflow.log_metric('mymetric', 1)
    mlflow.log_metric('anothermetric',1)
    pass

with mlflow.start_run(run_name="iris-classifier-random-forest") as run:
    mlflow.log_metric('mymetric', 1)
    mlflow.log_metric('anothermetric',1)

import mlflow

mlflow.autolog()

mlflow.log_metric('mymetric', 1)
mlflow.log_metric('anothermetric',1)

Parametri del log

MLflow supporta i parametri di registrazione usati dagli esperimenti. I parametri possono essere di qualsiasi tipo e possono essere registrati usando la sintassi seguente:

mlflow.log_param("num_epochs", 20)

MLflow offre anche un modo pratico per registrare più parametri indicandoli tutti usando un dizionario. Diversi framework possono anche passare parametri ai modelli usando dizionari e quindi questo è un modo pratico per registrarli nell'esperimento.

params = {
    "num_epochs": 20,
    "dropout_rate": .6,
    "objective": "binary_crossentropy"
}

mlflow.log_params(params)

Metriche di log

Le metriche, invece dei parametri, sono sempre numeriche e possono essere registrate in modo sincrono o asincrono. Quando vengono registrate le metriche, sono immediatamente disponibili per l'utilizzo al ritorno delle chiamate. La tabella seguente descrive come registrare tipi numerici specifici:

Metriche di log in modo asincrono

MLflow consente anche la registrazione delle metriche in modo asincrono. La registrazione asincrona delle metriche è particolarmente utile nei casi in cui i processi di training di grandi dimensioni con decine di nodi di calcolo potrebbero essere in esecuzione e provare a registrare le metriche contemporaneamente. È utile anche quando un numero ridotto di nodi sta tentando di registrare un numero elevato di metriche.

La registrazione asincrona delle metriche consente di registrare immediatamente le metriche evitando di attendere che vengano materializzati nel servizio back-end. Questo approccio si adatta a routine di training di grandi dimensioni che registrano centinaia di migliaia di valori delle metriche ed è l'approccio consigliato.

MLflow registra le metriche in modo sincrono per impostazione predefinita, tuttavia, è possibile modificare questo comportamento in qualsiasi momento:

import mlflow

mlflow.config.enable_async_logging()

È possibile impostare la stessa proprietà usando una variabile di ambiente:

export MLFLOW_ENABLE_ASYNC_LOGGING=True

Per registrare metriche specifiche in modo asincrono, usare l'API di registrazione MLflow come in genere, ma aggiungere il parametro aggiuntivo synchronous=False.

import mlflow

with mlflow.start_run():
    # (...)
    mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)

Quando si utilizza log_metric(synchronous=False), il controllo viene restituito automaticamente al chiamante una volta accettata l'operazione. Tuttavia, il valore non è disponibile per la lettura in modo corretto. La registrazione asincrona delle metriche garantisce l'ordine e le metriche vengono mantenute con il timestamp di quando sono state registrate.

Se è necessario attendere che un determinato valore venga salvato in modo permanente nel back-end, è possibile usare l'operazione metrica restituita per attenderlo, come illustrato nell'esempio seguente:

import mlflow

with mlflow.start_run():
    # (...)
    run_operation = mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)
    run_operation.wait()
    # (...)

È possibile registrare in modo asincrono una metrica alla volta o registrare un batch di metriche, come illustrato nell'esempio seguente:

import mlflow
import time
from mlflow.entities import Metric

with mlflow.start_run() as current_run:
    mlflow_client = mlflow.tracking.MlflowClient()

    metrics = {"metric-0": 3.14, "metric-1": 6.28}
    timestamp = int(time.time() * 1000)
    metrics_arr = [Metric(key, value, timestamp, 0) for key, value in metrics.items()]

    run_operation = mlflow_client.log_batch(
        run_id=current_run.info.run_id,
        metrics=metrics_arr,
        synchronous=False,
    )

L'operazione wait() è disponibile anche quando si registra un batch di metriche:

run_operation.wait()

Non è necessario chiamare wait() nelle routine se non occorre eseguire l'accesso immediato ai valori delle metriche. Azure Machine Learning attende automaticamente il completamento del processo per verificare se è presente una metrica in sospeso da rendere persistente. Al termine di un processo in Azure Machine Learning, è garantito che tutte le metriche siano persistenti.

Curve di log o elenco di valori

Le curve (o un elenco di valori numerici) possono essere registrate con MLflow registrando la stessa metrica più volte. Nell'esempio seguente viene illustrato come effettuare questa operazione:

list_to_log = [1, 2, 3, 2, 1, 2, 3, 2, 1]
from mlflow.entities import Metric
from mlflow.tracking import MlflowClient
import time

client = MlflowClient()
client.log_batch(mlflow.active_run().info.run_id, 
                 metrics=[Metric(key="sample_list", value=val, timestamp=int(time.time() * 1000), step=0) for val in list_to_log])

Immagini di log

MLflow supporta due modi per registrare le immagini. Entrambi i modi per rendere persistente l'immagine specificata come artefatto all'interno dell'esecuzione.

File di registro

In generale, i file in MLflow sono denominati artefatti. È possibile registrare gli artefatti in diversi modi in Mlflow:

Modelli di log

MLflow introduce il concetto di modelli come un modo per creare un pacchetto di tutti gli artefatti necessari per il funzionamento di un determinato modello. I modelli in MLflow sono sempre una cartella con un numero arbitrario di file, a seconda del framework usato per generare il modello. I modelli di registrazione hanno il vantaggio di tenere traccia di tutti gli elementi del modello come singola entità che può essere registrata e quindi distribuita. Oltre a questo, i modelli MLflow godono del vantaggio della distribuzione senza codice e possono essere usati con la dashboard di intelligenza artificiale responsabile in Studio. Per altre informazioni, vedere Da artefatti a modelli in MLflow.

Per salvare il modello da un'esecuzione di training, usare l'API log_model() per il framework usato. Ad esempio, mlflow.sklearn.log_model(). Per altre informazioni, vedere Registrazione di modelli MLflow. Per la migrazione di modelli esistenti a MLflow, vedere Convertire modelli personalizzati in MLflow.

Registrazione automatica

Con Azure Machine Learning e MLflow, gli utenti possono registrare automaticamente metriche, parametri del modello e artefatti del modello durante il training di un modello. Ogni framework decide cosa tenere traccia automaticamente. Sono supportate diverse librerie di apprendimento automatico più diffuse. Altre informazioni sulla registrazione automatica con MLflow.

Per abilitare la registrazione automatica, inserire il codice seguente prima del codice di training:

mlflow.autolog()

Visualizzare informazioni sui processi o sulle esecuzioni con MLflow

È possibile visualizzare le informazioni registrate usando MLflow tramite l'oggetto MLflow.entities.Run:

import mlflow

run = mlflow.get_run(run_id="<RUN_ID>")

È possibile visualizzare le metriche, i parametri e i tag per l'esecuzione nel campo dati dell'oggetto run.

metrics = run.data.metrics
params = run.data.params
tags = run.data.tags

MLflow può eseguire query su qualsiasi artefatto registrato da un'esecuzione. Non è possibile accedere agli artefatti usando l'oggetto run stesso e il client MLflow deve essere invece usato:

client = mlflow.tracking.MlflowClient()
client.list_artifacts("<RUN_ID>")

Questo metodo elenca tutti gli artefatti registrati nell'esecuzione, ma rimangono archiviati nell'archivio artefatti (archiviazione di Azure Machine Learning). Per scaricarli, usare il metodo download_artifact:

file_path = client.download_artifacts("<RUN_ID>", path="feature_importance_weight.png")

Per altre informazioni, vedere Recupero di metriche, parametri, artefatti e modelli.

Visualizzare informazioni sui processi o sulle esecuzioni in studio

È possibile esplorare i record dei processi completati, incluse le metriche registrate, nello studio di Azure Machine Learning.

Passare alla scheda Processi. Per visualizzare tutti i processi nell'area di lavoro in Esperimenti, selezionare la scheda Tutti i processi. È possibile eseguire il drill-down dei processi per esperimenti specifici applicando il filtro Esperimento nella barra dei menu superiore. Selezionare il processo di interesse per immettere la visualizzazione dei dettagli e quindi selezionare la scheda Metriche.

Selezionare le metriche registrate per eseguire il rendering dei grafici sul lato destro. È possibile personalizzare i grafici applicando lo smoothing, modificando il colore o tracciando più metriche in un singolo grafico. È anche possibile ridimensionare e riorganizzare il layout come desiderato. Dopo aver creato la visualizzazione desiderata, è possibile salvarla per usarla in futuro e condividerla con i membri del team usando un collegamento diretto.

Visualizzare e scaricare i log di diagnostica

I file di log sono una risorsa essenziale per il debug dei carichi di lavoro di Azure Machine Learning. Dopo aver inviato un processo di training, eseguire il drill-down a un'esecuzione specifica per visualizzare i log e gli output:

1. Passare alla scheda Processi.
2. Selezionare il runID per un'esecuzione specifica.
3. Selezionare Output e log nella parte superiore della pagina.
4. Selezionare Scarica tutto per scaricare tutti i log in una cartella ZIP.
5. È anche possibile scaricare singoli file di log scegliendo il file di log e selezionando Scarica

Cartella user_logs

Questa cartella contiene informazioni sui log generati dall'utente. Questa cartella è aperta per impostazione predefinita e viene selezionato il log std_log.txt. std_log.txt è la posizione in cui vengono visualizzati i log del codice (ad esempio, le istruzioni di stampa). Questo file contiene il log stdout e i log stderr dello script di controllo e dello script di training, uno per processo. Nella maggior parte dei casi, è possibile monitorare i log qui.

Cartella system_logs

Questa cartella contiene i log generati da Azure Machine Learning e viene chiuso per impostazione predefinita. I log generati dal sistema vengono raggruppati in cartelle diverse, in base alla fase del processo nel runtime.

Altre cartelle

Per il training dei processi in cluster con più risorse di calcolo, sono presenti log per ogni nodo IP. La struttura per ogni nodo è identica a quella dei processi a nodo singolo. È disponibile una cartella di log per l'esecuzione complessiva, stderr e i log stdout.

Azure Machine Learning registra le informazioni provenienti da varie origini durante il training, ad esempio AutoML o il contenitore Docker che esegue il processo di training. Molti di questi log non sono documentati. Se si verificano problemi e si contatta il supporto tecnico Microsoft, l'agente potrebbe essere in grado di utilizzare questi log durante la risoluzione dei problemi.

Contenuto correlato

• Eseguire il training dei modelli di Machine Learning con MLflow e Azure Machine Learning
• Eseguire la migrazione dalla registrazione dell'SDK v1 al rilevamento MLflow