Gestire i registri dei modelli in Azure Machine Learning con MLflow

  • Articolo

Azure Machine Learning supporta MLflow per la gestione dei modelli quando si è connessi a un'area di lavoro. Questo approccio rappresenta un modo pratico per supportare l'intero ciclo di vita del modello per gli utenti che hanno familiarità con il client MLFlow. L'articolo seguente descrive le diverse funzionalità e il relativo confronto con altre opzioni.

Prerequisiti

  • Installare il pacchetto SDK MLflow mlflow e il plug-in di Azure Machine Learning per MLflow azureml-mlflow.

    pip install mlflow azureml-mlflow

    Suggerimento

    È possibile usare il pacchetto mlflow-skinny, che è un pacchetto di MLflow leggero senza risorse di archiviazione SQL, server, interfaccia utente o dipendenze di data science. mlflow-skinny è consigliabile per gli utenti che necessitano principalmente delle funzionalità di rilevamento e registrazione di MLflow senza importare il gruppo completo di funzionalità, incluse le distribuzioni.

  • Un'area di lavoro di Azure Machine Learning. È possibile crearne una seguendo l'esercitazione Creare risorse di Machine Learning.

  • Se si esegue il rilevamento remoto, ovvero si monitorano esperimenti in esecuzione all'esterno di Azure Machine Learning, configurare MLflow in modo che punti all'URI di rilevamento dell'area di lavoro di Azure Machine Learning. Per altre informazioni su come connettere MLflow all'area di lavoro, vedere Configurare MLflow per Azure Machine Learning.

  • Si noti che i registri dell'organizzazione non sono supportati per la gestione dei modelli con MLflow.

  • Alcune operazioni possono essere eseguite direttamente usando l'API Fluent MLflow (mlflow.<method>). Tuttavia, altri potrebbero richiedere la creazione di un client MLflow, che consente di comunicare con Azure Machine Learning nel protocollo MLflow. È possibile creare un oggetto MlflowClient come indicato di seguito. Questa esercitazione usa l'oggetto client per fare riferimento a tale client MLflow.

    import mlflow

client = mlflow.tracking.MlflowClient()

Registrazione di nuovi modelli nel registro

Il registro modelli offre un modo pratico e centralizzato per gestire i modelli in un'area di lavoro. Ogni area di lavoro ha un proprio registro di modelli indipendenti. La sezione seguente illustra diversi modi per registrare i modelli nel registro usando MLflow SDK.

Creazione di modelli da un'esecuzione esistente

Se è stato registrato un modello MLflow all'interno di un'esecuzione e si vuole registrarlo in un registro, usare l'ID esecuzione e il percorso in cui è stato registrato il modello. Vedere Gestire esperimenti ed esecuzioni con MLflow per sapere come eseguire query su queste informazioni se non sono disponibili.

mlflow.register_model(f"runs:/{run_id}/{artifact_path}", model_name)

Nota

I modelli possono essere registrati solo nel Registro di sistema nella stessa area di lavoro in cui è stata rilevata l'esecuzione. Le operazioni tra aree di lavoro non sono supportate dal momento in Azure Machine Learning.

Suggerimento

È consigliabile registrare modelli da esecuzioni o usare il metodo mlflow.<flavor>.log_model dall'interno dell'esecuzione, in quanto mantiene la derivazione dal processo che ha generato l'asset.

Creazione di modelli da asset

Se si dispone di una cartella con un modello MLModel MLflow, è possibile registrarla direttamente. Non è necessario che il modello sia sempre nel contesto di un'esecuzione. A tale scopo, è possibile usare lo schema URI file://path/to/model per registrare i modelli MLflow archiviati nel file system locale. Creare un modello semplice usando Scikit-Learn e salvarlo in formato MLflow nella risorsa di archiviazione locale:

from sklearn import linear_model

reg = linear_model.LinearRegression()
reg.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])

mlflow.sklearn.save_model(reg, "./regressor")

Suggerimento

Il metodo save_model() funziona allo stesso modo di log_model(). Mentre log_model() salva il modello in un'esecuzione attiva, save_model() usa il file system locale per salvare il modello.

È ora possibile registrare il modello dal percorso locale:

import os

model_local_path = os.path.abspath("./regressor")
mlflow.register_model(f"file://{model_local_path}", "local-model-test")

Esecuzione di query sui registri dei modelli

È possibile usare MLflow SDK per eseguire query e cercare modelli registrati nel registro. La sezione seguente illustra diversi modi per ottenerlo.

Esecuzione di query su tutti i modelli nel registro

È possibile eseguire query su tutti i modelli registrati nel registro usando il client MLflow. Nell'esempio seguente vengono stampati tutti i nomi del modello:

for model in client.search_registered_models():
    print(f"{model.name}")

Usare order_by per ordinare in base a una proprietà specifica come name, version, creation_timestamp e last_updated_timestamp:

client.search_registered_models(order_by=["name ASC"])

Nota

avviso MLflow 2.0: nelle versioni precedenti di Mlflow (<2.0), usare invece il metodo MlflowClient.list_registered_models().

Recupero di versioni specifiche del modello

Il comando search_registered_models() recupera l'oggetto modello, che contiene tutte le versioni del modello. Tuttavia, se si vuole ottenere l'ultima versione registrata del modello di un determinato modello, è possibile usare get_registered_model:

client.get_registered_model(model_name)

Se è necessaria una versione specifica del modello, è possibile indicare di conseguenza:

client.get_model_version(model_name, version=2)

Caricamento di modelli dal registro

È possibile caricare i modelli direttamente dal registro per ripristinare gli oggetti modelli registrati. Usare le funzioni mlflow.<flavor>.load_model() o mlflow.pyfunc.load_model() che indica l'URI del modello da caricare usando la sintassi seguente:

  • models:/<model-name>/latest per caricare l'ultima versione del modello.
  • models:/<model-name>/<version-number> per caricare una versione specifica del modello.
  • models:/<model-name>/<stage-name> per caricare una versione specifica in una determinata fase per un modello. Visualizzare le fasi del modello per informazioni dettagliate.

Suggerimento

Per informazioni sulla differenza tra mlflow.<flavor>.load_model() e mlflow.pyfunc.load_model(), visualizzare Flussi di lavoro per il caricamento di modelli MLflow.

Fasi del modello

MLflow supporta le fasi del modello per gestire il ciclo di vita del modello. La versione del modello può passare da una fase a un'altra. Le fasi vengono assegnate alla versione di un modello (anziché ai modelli), il che significa che un determinato modello può avere più versioni in fasi diverse.

Importante

È possibile accedere alle fasi solo tramite MLflow SDK. Non vengono visualizzati nel portale studio di Azure ML e non possono essere recuperati usando né Azure ML SDK, l'interfaccia della riga di comando di Azure ML o l'API REST di Azure ML. La creazione della distribuzione dalla fase di un determinato modello non è supportata al momento.

Fasi del modello di query

È possibile usare il client MLflow per verificare tutte le possibili fasi che un modello può essere:

client.get_model_version_stages(model_name, version="latest")

È possibile visualizzare la versione del modello in ogni fase ottenendo il modello dal registro. Nell'esempio seguente viene recuperata la versione del modello attualmente nella fase Staging.

client.get_latest_versions(model_name, stages=["Staging"])

Nota

Più versioni possono trovarsi nella stessa fase contemporaneamente in Mlflow, ma questo metodo restituisce la versione più recente (versione successiva) tra tutte.

Avviso

I nomi delle fasi fanno distinzione tra maiuscole e minuscole.

Modelli in transizione

È possibile eseguire la transizione della versione di un modello a una fase specifica usando il client MLflow.

client.transition_model_version_stage(model_name, version=3, stage="Staging")

Per impostazione predefinita, se in quella fase specifica è presente una versione del modello esistente, rimane lì. Di conseguenza, non viene sostituito perché più versioni del modello possono trovarsi contemporaneamente nella stessa fase. In alternativa, è possibile indicare archive_existing_versions=True per indicare a MLflow di spostare la versione del modello esistente nella fase Archived.

client.transition_model_version_stage(
    model_name, version=3, stage="Staging", archive_existing_versions=True
)

Caricamento di modelli dalle fasi

È possibile caricare un modello in una fase specifica direttamente da Python usando la funzione load_model e il formato URI seguente. Si noti che per il corretto funzionamento di questo metodo, è necessario che tutte le librerie e le dipendenze siano già installate nell'ambiente in cui si lavora.

model = mlflow.pyfunc.load_model(f"models:/{model_name}/Staging")

Modifica ed eliminazione di modelli

La modifica dei modelli registrati è supportata sia in Mlflow che in Azure ML. Esistono tuttavia alcune differenze importanti da notare:

Avviso

La ridenominazione dei modelli non è supportata in Azure Machine Learning perché gli oggetti modello sono immutabili.

Modelli di modifica

È possibile modificare la descrizione e i tag del modello da un modello usando Mlflow:

client.update_model_version(model_name, version=1, description="My classifier description")

Per modificare i tag, è necessario usare il metodo set_model_version_tag e remove_model_version_tag:

client.set_model_version_tag(model_name, version="1", key="type", value="classification")

Rimozione di un tag:

client.delete_model_version_tag(model_name, version="1", key="type")

Eliminazione della versione di un modello

È possibile eliminare qualsiasi versione del modello nel registro usando il client MLflow, come illustrato nell'esempio seguente:

client.delete_model_version(model_name, version="2")

Nota

Azure Machine Learning non supporta l'eliminazione dell'intero contenitore di modelli. Per ottenere la stessa operazione, è necessario eliminare tutte le versioni del modello da un determinato modello.

Matrice di supporto per la gestione dei modelli con MLflow

Il client MLflow espone diversi metodi per recuperare e gestire i modelli. La tabella seguente illustra quali di questi metodi sono attualmente supportati in MLflow quando si è connessi ad Azure ML. Viene confrontato anche con altre funzionalità di gestione dei modelli in Azure ML.

Funzionalità MLflow Azure ML con MLflow Azure ML CLIv2 Azure ML Studio
Registrazione di modelli in formato MLflow ✓ ✓ ✓ ✓
Registrazione di modelli non in formato MLflow ✓ ✓
Registrazione di modelli da esecuzioni di output/artefatti ✓ ✓1 ✓2 ✓
Registrazione di modelli da esecuzioni di output/artefatti in un server/area di lavoro di rilevamento diverso ✓ ✓5 ✓5
Cercare/elencare i modelli registrati ✓ ✓ ✓ ✓
Recupero dei dettagli delle versioni del modello registrato ✓ ✓ ✓ ✓
Modifica della descrizione delle versioni del modello registrato ✓ ✓ ✓ ✓
Modifica dei tag delle versioni del modello registrato ✓ ✓ ✓ ✓
Ridenominazione dei modelli registrati ✓ 3 3 3
Eliminazione di un modello registrato (contenitore) ✓ 3 3 3
Eliminazione della versione di un modello registrato ✓ ✓ ✓ ✓
Gestire le fasi del modello MLflow ✓ ✓
Cercare i modelli registrati in base al nome ✓ ✓ ✓ ✓4
Cercare modelli registrati usando LIKE e ILIKE di confronto di stringhe ✓ ✓4
Cercare i modelli registrati in base al tag ✓4
Supporto registri dell'organizzazione ✓ ✓

Nota

  • 1 Usare URI con formato runs:/<ruin-id>/<path>.
  • 2 Usare URI con formato azureml://jobs/<job-id>/outputs/artifacts/<path>.
  • 3 I modelli registrati sono oggetti non modificabili in Azure ML.
  • 4 Usare la casella di ricerca in studio di Azure ML. Corrispondenza parziale supportata.
  • 5 Usare registri per spostare i modelli in aree di lavoro diverse mantenendo al tempo stesso la derivazione.

Passaggi successivi