Registrare metriche, parametri e file con MLflow

APPLIES TO: Python SDK azure-ai-ml v2 (current)

Azure Machine Learning supporta esperimenti di registrazione e rilevamento usando MLflow Tracking. È possibile registrare modelli, metriche, parametri e artifacts 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 disporre di un'area di lavoro Azure Machine Learning. Se non ne hai uno, vedere Creare risorse dell'area di lavoro.

• È necessario che Python 3.10 o versione successiva sia installato.

• È 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 (esperimenti di rilevamento 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, artifacts 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 vengono chiamate 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)

Registrare parametri

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, anziché i 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()

È consigliabile usare il flag globale precedente quando si vuole abilitare la registrazione asincrona delle metriche nel codice e/o si usa una libreria wrapper che esegue il wrapping di mlflow per registrare le metriche effettive.

È 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.

La configurazione synchronous=False è facoltativa se si imposta il flag globale per l'accesso asincrono tramite mlflow.config.enable_async_logging().

import mlflow

with mlflow.start_run():
    # (...)
    # when global async logging flag is not set using - mlflow.config.enable_async_logging()
    mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)

import mlflow
# Set global async logging flag
mlflow.config.enable_async_logging()

with mlflow.start_run():
    # (...)
    # You can use all fluent syntax or MlflowClient APIs and all of them will log metrics in asynchronous fashion.
    mlflow.log_metric("metric1", 9.42)
    # (...)

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 immediata. 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,
        #Optional when global async logging flag is set using - mlflow.enable_async_logging()
        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 è necessario un 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'attività in Azure Machine Learning, tutte le metriche sono garantite di essere salvate.

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. L'esempio seguente illustra come to do:

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 metodi rendono persistente l'immagine specificata come artefatto durante l'esecuzione.

File di registro

In generale, i file in MLflow vengono chiamati artifacts. È possibile registrare artefatti in diversi modi in Mlflow:

Modelli di log

MLflow introduce il concetto di models come modo per creare un pacchetto di tutti i artifacts 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 metriche, parametri del modello e artifacts del modello automaticamente durante l'addestramento di un modello. Ogni framework decide automaticamente cosa tracciare per te. Sono supportate varietà delle librerie di machine learning 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ò interrogare qualsiasi artefatto registrato da un run. Artifacts non è possibile accedere 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 degli artefatti (Azure Machine Learning storage). Per scaricarli, usare il download_artifacts metodo :

file_path = mlflow.artifacts.download_artifacts(run_id="<RUN_ID>", artifact_path="feature_importance_weight.png")

Per ulteriori informazioni, fare riferimento a Ottenere metriche, parametri, artefatti e modelli.

Visualizzare le informazioni sui processi o sulle esecuzioni in studio

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

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 l'attività 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 Azure Machine Learning. Dopo l'invio di un processo di training, eseguire il drill-down in un'esecuzione specifica per visualizzare log e output:

1. Passare alla scheda Lavori.
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 addestramento, 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 di processi in cluster multi-calcolo, sono presenti log per ogni nodo IP. La struttura per ogni nodo è identica a quella dei processi a nodo singolo. Esiste un'altra cartella di log per l'esecuzione complessiva, stderr e stdout.

Azure Machine Learning registra 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 contattano Microsoft support, potrebbero essere in grado di usare questi log durante la risoluzione dei problemi.

Contenuto correlato

• Addestra modelli di ML con MLflow e Azure Machine Learning
• Eseguire la migrazione dalla registrazione dei log di SDK v1 al tracciamento con MLflow