Usare i modelli in Azure Machine Learning
SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)
Azure Machine Learning consente di usare diversi tipi di modelli. Questo articolo illustra l'uso di Azure Machine Learning per lavorare con diversi tipi di modello, ad esempio modelli personalizzati, di MLflow e Triton. Si apprenderà anche come registrare un modello da posizioni diverse e come usare Azure Machine Learning SDK, l'interfaccia utente e l'interfaccia della riga di comando di Azure Machine Learning per gestire i modelli.
Suggerimento
Se sono stati creati asset di modello che usano l'SDK/interfaccia della riga di comando v1, è comunque possibile usarli con SDK/interfaccia della riga di comando v2. Viene fornita la compatibilità completa con le versioni precedenti. A tutti i modelli registrati nell'SDK V1 viene assegnato il tipo custom
.
Prerequisiti
- Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.
- Un'area di lavoro di Azure Machine Learning.
- Azure Machine Learning SDK v2 per Python.
- Interfaccia della riga di comando v2 di Azure Machine Learning.
Sarà inoltre necessario:
- Installare l'interfaccia della riga di comando di Azure e l'estensione di Machine Learning nell'interfaccia della riga di comando di Azure. Per altre informazioni, vedere Installare, configurare e usare l'interfaccia della riga di comando (v2).
Percorsi supportati
Quando si specifica un modello da registrare, è necessario specificare un parametro path
che punta ai dati o alla posizione del processo. Di seguito è riportata una tabella che mostra i diversi percorsi di dati supportati in Azure Machine Learning e include esempi per il parametro path
:
Ufficio | Esempi |
---|---|
Percorso nel computer locale | mlflow-model/model.pkl |
Percorso in un archivio dati di Azure Machine Learning | azureml://datastores/<datastore-name>/paths/<path_on_datastore> |
Percorso da un processo di Azure Machine Learning | azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location> |
Percorso da un processo di MLflow | runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location> |
Percorso da un asset di modello nell'area di lavoro di Azure Machine Learning | azureml:<model-name>:<version> |
Percorso da un asset di modello nel registro di Azure Machine Learning | azureml://registries/<registry-name>/models/<model-name>/versions/<version> |
Modalità supportate
Quando si esegue un processo con input/output del modello, è possibile specificare la modalità, ad esempio per indicare se si vuole che il modello sia montato o scaricato in sola lettura nella destinazione di calcolo. La tabella seguente illustra le modalità possibili per combinazioni diverse di tipo/modalità/input/output:
Type | Input/Output | upload |
download |
ro_mount |
rw_mount |
direct |
---|---|---|---|---|---|---|
File custom |
Input | |||||
custom |
Input | ✓ | ✓ | ✓ | ||
mlflow |
Input | ✓ | ✓ | |||
File custom |
Output | ✓ | ✓ | ✓ | ||
custom |
Output | ✓ | ✓ | ✓ | ||
mlflow |
Output | ✓ | ✓ | ✓ |
Seguire la procedura in Jupyter Notebooks
È possibile seguire questo esempio in un notebook Jupyter. Nel repository azureml-examples aprire il notebook: model.ipynb.
Creare un modello nel registro dei modelli
Con la registrazione dei modelli è possibile archiviare i modelli e creare le relative versioni nel cloud di Azure, all'interno della propria area di lavoro. Il registro dei modelli consente di organizzare i modelli sottoposti a training e tenerne traccia.
I frammenti di codice in questa sezione illustrano come:
- Registrare il modello come asset in Machine Learning usando l'interfaccia della riga di comando.
- Registrare il modello come asset in Machine Learning usando l'SDK.
- Registrare il modello come asset in Machine Learning usando l'interfaccia utente.
Questi frammenti di codice usano custom
e mlflow
.
custom
è un tipo che fa riferimento a un file di modello o a una cartella sottoposta a training con uno standard personalizzato non attualmente supportato da Azure Machine Learning.mlflow
è un tipo che fa riferimento a un modello sottoposto a training con mlflow. I modelli sottoposti a training con MLflow si trovano in una cartella contenente il file MLmodel, il file del modello, il file delle dipendenze conda e il file requirements.txt.
Connettersi all'area di lavoro
Connettersi prima di tutto all'area di lavoro di Azure Machine Learning in cui si lavorerà.
az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>
Registrare il modello come asset in Machine Learning usando l'interfaccia della riga di comando
Usare le schede seguenti per selezionare la posizione in cui si trova il modello.
$schema: https://azuremlschemas.azureedge.net/latest/model.schema.json
name: local-file-example
path: mlflow-model/model.pkl
description: Model created from local file.
az ml model create -f <file-name>.yml
Per un esempio completo, vedere il file YAML del modello.
Registrare il modello come asset in Machine Learning usando l'SDK
Usare le schede seguenti per selezionare la posizione in cui si trova il modello.
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes
file_model = Model(
path="mlflow-model/model.pkl",
type=AssetTypes.CUSTOM_MODEL,
name="local-file-example",
description="Model created from local file.",
)
ml_client.models.create_or_update(file_model)
Registrare il modello come asset in Machine Learning usando l'interfaccia utente
Per creare un modello in Machine Learning, aprire la pagina Modelli dall'interfaccia utente. Selezionare Registra modello e selezionare la posizione in cui si trova il modello. Compilare i campi obbligatori e quindi selezionare Registra.
Gestire i modelli
L'SDK e l'interfaccia della riga di comando (v2) consentono anche di gestire il ciclo di vita degli asset del modello di Azure Machine Learning.
List
Elencare tutti i modelli nell'area di lavoro:
az ml model list
Elencare tutte le versioni del modello con un determinato nome:
az ml model list --name run-model-example
Mostra
Ottenere i dettagli di un modello specifico:
az ml model show --name run-model-example --version 1
Aggiornamento
Aggiornare le proprietà modificabili di un modello specifico:
az ml model update --name run-model-example --version 1 --set description="This is an updated description." --set tags.stage="Prod"
Importante
Per il modello è possibile aggiornare solo description
e tags
. Tutte le altre proprietà non sono modificabili. Se è necessario modificare una di queste proprietà, occorre creare una nuova versione del modello.
Archivio
L'archiviazione di un modello lo nasconde per impostazione predefinita dalle query di elenco (az ml model list
). È comunque possibile continuare a fare riferimento e usare un modello archiviato nei flussi di lavoro. È possibile archiviare tutte le versioni di un modello o solo una versione specifica.
Se non si specifica una versione, verranno archiviate tutte le versioni del modello con tale nome specificato. Se si crea una nuova versione del modello in un contenitore di modelli archiviati, anche la nuova versione verrà impostata automaticamente come archiviata.
Archiviare tutte le versioni di un modello:
az ml model archive --name run-model-example
Archiviare una versione specifica del modello:
az ml model archive --name run-model-example --version 1
Usare il modello per il training
L'SDK e l'interfaccia della riga di comando (v2) consentono anche di usare un modello in un processo di training come input o output.
Usare il modello come input in un processo
Creare un file YAML di specifica del processo (<file-name>.yml
). Specificare nella sezione inputs
del processo:
- Il valore per
type
, che indica se il modello èmlflow_model
,custom_model
otriton_model
. - Il valore per
path
che indica la posizione in cui si trovano i dati. Può corrispondere a uno dei percorsi indicati nella sezione Percorsi supportati.
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
# Possible Paths for models:
# AzureML Datastore: azureml://datastores/<datastore-name>/paths/<path_on_datastore>
# MLflow run: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
# Job: azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
# Model Asset: azureml:<my_model>:<version>
command: |
ls ${{inputs.my_model}}
inputs:
my_model:
type: mlflow_model # List of all model types here: https://learn.microsoft.com/azure/machine-learning/reference-yaml-model#yaml-syntax
path: ../../assets/model/mlflow-model
environment: azureml://registries/azureml/environments/sklearn-1.0/labels/latest
Eseguire quindi quanto segue nell'interfaccia della riga di comando
az ml job create -f <file-name>.yml
Per un esempio completo, vedere il repository GitHub del modello.
Usare il modello come output in un processo
Nel processo è possibile scrivere un modello nell'archiviazione basata sul cloud usando output.
Creare un file YAML di specifica del processo (<file-name>.yml
), con la sezione outputs
popolata con il tipo e il percorso in cui si vogliono scrivere i dati:
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
# Possible Paths for Model:
# Local path: mlflow-model/model.pkl
# AzureML Datastore: azureml://datastores/<datastore-name>/paths/<path_on_datastore>
# MLflow run: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
# Job: azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
# Model Asset: azureml:<my_model>:<version>
code: src
command: >-
python hello-model-as-output.py
--input_model ${{inputs.input_model}}
--custom_model_output ${{outputs.output_folder}}
inputs:
input_model:
type: mlflow_model # mlflow_model,custom_model, triton_model
path: ../../assets/model/mlflow-model
outputs:
output_folder:
type: custom_model # mlflow_model,custom_model, triton_model
environment: azureml://registries/azureml/environments/sklearn-1.0/labels/latest
Creare quindi un processo usando l'interfaccia della riga di comando:
az ml job create --file <file-name>.yml
Per un esempio completo, vedere il repository GitHub del modello.