Utiliser des modèles inscrits dans Azure Machine Learning

• Version 2.38.0 ou ultérieure d’Azure CLI installée.

• Extension ml V2 installée en exécutant la commande suivante. Pour plus d’informations, consultez Installer, configurer et utiliser l’interface CLI (v2).

  az extension add -n ml
  

• Version 3.8 ou version ultérieure de Python installée.

• Kit SDK Azure Machine Learning v2 pour Python installé en exécutant la commande suivante :

  pip install azure-ai-ml azure-identity
  

1. Connectez-vous à Azure en exécutant az login et en suivant les invites.

2. Dans les commandes suivantes, remplacez les espaces réservés <subscription-id>, <workspace-name>, <resource-group> et <location> par les valeurs de votre environnement.

   az account set --subscription <subscription-id>
   az configure --defaults workspace=<workspace-name> group=<resource-group> location=<location>
   

1. Importez les bibliothèques nécessaires :

   from azure.ai.ml import MLClient, Input
   from azure.ai.ml.entities import Model
   from azure.ai.ml.constants import AssetTypes
   from azure.identity import DefaultAzureCredential
   

2. Configurez les détails de l’espace de travail et obtenez un handle pour l’espace de travail. Dans l’extrait de code suivant, remplacez les espaces réservés <subscription-id>, <resource-group> et <workspace-name> par les valeurs de votre environnement.

   subscription_id = "<subscription-id>"
   resource_group = "<resource-group>"
   workspace = "<workspace-name>"
   
   ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
   

1. Créez un fichier YAML <file-name>.yml. Dans le fichier, indiquez un nom pour votre modèle inscrit, un chemin d’accès au fichier de modèle local ainsi qu’une description. Par exemple :

   $schema: https://azuremlschemas.azureedge.net/latest/model.schema.json
   name: local-file-example
   path: mlflow-model/model.pkl
   description: Model created from local file.
   

2. Exécutez la commande suivante en utilisant le nom de votre fichier YAML :

   az ml model create -f <file-name>.yml
   

Pour obtenir un exemple complet, consultez le modèle YAML.

L’exemple suivant montre la création d’un modèle inscrit à partir d’un fichier local.

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)

L’exemple suivant utilise le schéma azureml abrégé pour pointer vers un chemin d’accès sur le magasin de données en utilisant la syntaxe azureml://datastores/<datastore-name>/paths/<path_on_datastore>.

az ml model create --name my-model --version 1 --path azureml://datastores/myblobstore/paths/models/cifar10/cifar.pt

Pour obtenir un exemple complet, consultez les informations de référence CLI.

L’exemple suivant utilise le schéma azureml abrégé pour pointer vers un chemin d’accès sur le magasin de données en utilisant la syntaxe azureml://datastores/${{datastore-name}}/paths/${{path_on_datastore}}.

from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes

cloud_model = Model(
    path=file_model.path,
    # The above line basically provides a path in the format "azureml://subscriptions/XXXXXXXXXXXXXXXX/resourceGroups/XXXXXXXXXXX/workspaces/XXXXXXXXXXX/datastores/workspaceblobstore/paths/model.pkl"
    # Users could also use,"azureml://datastores/workspaceblobstore/paths/model.pkl" as a shorthand to the same location
    name="cloud-path-example",
    type=AssetTypes.CUSTOM_MODEL,
    description="Model created from cloud path.",
)
ml_client.models.create_or_update(cloud_model)

1. Créez un fichier YAML de spécification de travail, <file-name>.yml. Dans la section inputs du travail, spécifiez :

   • Le type du modèle, qui peut être mlflow_model, custom_model ou triton_model.
   • Le path où se trouve votre modèle, qui peut être l’un des chemins d’accès répertoriés dans le commentaire de l’exemple suivant.

   $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://video2.skills-academy.com/azure/machine-learning/reference-yaml-model#yaml-syntax
       path: ../../assets/model/mlflow-model
   environment: azureml://registries/azureml/environments/sklearn-1.5/labels/latest
   

2. Exécutez la commande suivante, en remplaçant le nom de fichier par votre nom de fichier YAML.

   az ml job create -f <file-name>.yml
   

Pour obtenir un exemple complet, consultez le référentiel modèle GitHub.

La classe Input vous permet de définir :

• Le type de ressource de modèle, qui peut prendre l’une des valeurs suivantes :

  • AssetTypes.CUSTOM_MODEL
  • AssetTypes.MLFLOW_MODEL
  • AssetTypes.TRITON_MODEL

• Le path à vos données de modèle, qui peut être l’un des emplacements suivants :

  • Chemin d’accès local : <model-folder>/<model-filename>
  • Magasin de données Azure Machine Learning : azureml://datastores/<datastore-name>/paths/<path_on_datastore>
  • Exécution MLflow : runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
  • Travail : azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
  • Ressource du modèle : azureml:<my_model>:<version>

L’exemple suivant entre un modèle MLflow à partir d’un dossier local.

from azure.ai.ml import command
from azure.ai.ml.entities import Model
from azure.ai.ml import Input
from azure.ai.ml.constants import AssetTypes
from azure.ai.ml import MLClient

my_job_inputs = {
    "input_model": Input(type=AssetTypes.MLFLOW_MODEL, path="mlflow-model")
}

job = command(
    code="./src",  # local path where the code is stored
    command="ls ${{inputs.input_model}}",
    inputs=my_job_inputs,
    environment="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:9",
    compute="cpu-cluster",
)

# submit the command
returned_job = ml_client.jobs.create_or_update(job)
# get a URL for the status of the job
returned_job.services["Studio"].endpoint

1. Créez un fichier YAML de spécification de travail intitulé <file-name>.yml. Remplissez la section outputs avec le type et le chemin d’accès du modèle de sortie.

   $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.5/labels/latest
   

2. Créez un travail à l’aide de l’interface CLI :

   az ml job create --file <file-name>.yml
   

Pour obtenir un exemple complet, consultez le référentiel modèle GitHub.

La classe Output vous permet de définir :

• Le type de ressource de modèle, qui peut prendre l’une des valeurs suivantes :

  • AssetTypes.CUSTOM_MODEL
  • AssetTypes.MLFLOW_MODEL
  • AssetTypes.TRITON_MODEL

• Le path à vos données de modèle, qui peut être l’un des emplacements suivants :

  • Chemin d’accès local : mlflow-model/model.pkl
  • Magasin de données Azure Machine Learning : azureml://datastores/<datastore-name>/paths/<path_on_datastore>
  • Exécution MLflow : runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
  • Travail : azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
  • Ressource du modèle : azureml:<my_model>:<version>

L’exemple suivant crée une sortie qui monte votre magasin de données par défaut en mode lecture-écriture. Le code charge simplement le modèle MLflow local en tant qu’entrée et exporte le même modèle en tant que sortie du travail enregistré dans le magasin de données monté.

from azure.ai.ml import command
from azure.ai.ml.entities import Model
from azure.ai.ml import Input, Output
from azure.ai.ml.constants import AssetTypes

my_job_inputs = {
    "input_model": Input(type=AssetTypes.MLFLOW_MODEL, path="mlflow-model"),
    "input_data": Input(type=AssetTypes.URI_FILE, path="./mlflow-model/input_example.json"),}

my_job_outputs = {
    "output_folder": Output(type=AssetTypes.CUSTOM_MODEL)
}

job = command(
    code="./src",  # local path where the code is stored
    command="python load_write_model.py --input_model ${{inputs.input_model}} --output_folder ${{outputs.output_folder}}",
    inputs=my_job_inputs,
    outputs=my_job_outputs,
    environment="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:9",
    compute="cpu-cluster",
)

# submit the command
returned_job = ml_client.create_or_update(job)
# get a URL for the status of the job
returned_job.services["Studio"].endpoint

Répertoriez l’ensemble des modèles dans votre espace de travail :

az ml model list

Répertoriez l’ensemble des versions de le modèle sous un nom donné :

az ml model list --name run-model-example

Répertoriez l’ensemble des modèles dans votre espace de travail :

models = ml_client.models.list()
for model in models:
    print(model.name)

Répertoriez l’ensemble des versions de le modèle sous un nom donné :

models = ml_client.models.list(name="run-model-example")
for model in models:
    print(model.version)

az ml model show --name run-model-example --version 1

model_example = ml_client.models.get(name="run-model-example", version="1")
print(model_example)

az ml model update --name  run-model-example --version 1 --set description="This is an updated description." --set tags.stage="Prod"

model_example.description="This is an updated description."
model_example.tags={"stage":"Prod"}
ml_client.models.create_or_update(model=model_example)

Archivez toutes les versions d’un modèle :

az ml model archive --name run-model-example

Archivez une version spécifique d’un modèle :

az ml model archive --name run-model-example --version 1

Archivez toutes les versions d’un modèle :

ml_client.models.archive(name="run-model-example")

Archivez une version spécifique d’un modèle :

ml_client.models.archive(name="run-model-example", version="1")