Werken met geregistreerde modellen in Azure Machine Learning

Artikel
09/02/2024

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

In dit artikel leert u hoe u modellen in Azure Machine Learning kunt registreren en ermee kunt werken met behulp van:

De Azure Machine Learning-studio gebruikersinterface.
De Azure Machine Learning V2 CLI.
De Python Azure Machine Learning V2 SDK.

U leert het volgende:

Maak geregistreerde modellen in het modelregister op basis van lokale bestanden, gegevensarchieven of taakuitvoer.
Werk met verschillende typen modellen, zoals aangepaste, MLflow en Triton.
Modellen gebruiken als invoer of uitvoer in trainingstaken.
De levenscyclus van modelassets beheren.

Modelregistratie

Met modelregistratie kunt u uw modellen opslaan en versien in uw werkruimte in de Azure-cloud. Het modelregister helpt u bij het organiseren en bijhouden van uw getrainde modellen. U kunt modellen registreren als assets in Azure Machine Learning met behulp van de Azure CLI, de Python SDK of de gebruikersinterface van Machine Learning Studio.

Ondersteunde paden

Als u een model wilt registreren, moet u een pad opgeven dat verwijst naar de gegevens- of taaklocatie. In de volgende tabel ziet u de verschillende gegevenslocaties die Azure Machine Learning ondersteunt en de syntaxis voor de path parameter:

Locatie	Syntaxis
Lokale computer	`<model-folder>/<model-filename>`
Azure Machine Learning-gegevensarchief	`azureml://datastores/<datastore-name>/paths/<path_on_datastore>`
Azure Machine Learning-taak	`azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>`
MLflow-taak	`runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>`
Modelasset in een Machine Learning-werkruimte	`azureml:<model-name>:<version>`
Modelasset in een Machine Learning-register	`azureml://registries/<registry-name>/models/<model-name>/versions/<version>`

Ondersteunde modi

Wanneer u modellen gebruikt voor invoer of uitvoer, kunt u een van de volgende modi opgeven. U kunt bijvoorbeeld opgeven of het model alleen-lezen moet worden gekoppeld of gedownload naar het rekendoel.

ro_mount: Koppel de gegevens aan het rekendoel als alleen-lezen.
rw_mount: Lees-schrijven koppelt de gegevens.
download: Download de gegevens naar het rekendoel.
upload: Upload de gegevens van het rekendoel.
direct: Geef de URI door als een tekenreeks.

In de volgende tabel ziet u de beschikbare modusopties voor verschillende invoer en uitvoer van het modeltype.

Type	`upload`	`download`	`ro_mount`	`rw_mount`	`direct`
`custom` bestandsinvoer
`custom` mapinvoer		✓	✓		✓
`mlflow` invoer		✓	✓
`custom` bestandsuitvoer	✓			✓	✓
`custom` mapuitvoer	✓			✓	✓
`mlflow` uitvoer	✓			✓	✓

Vereisten

Een Azure-abonnement met een gratis of betaalde versie van Azure Machine Learning. Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.
Een Azure Machine Learning-werkruimte.

Als u de codevoorbeelden in dit artikel wilt uitvoeren en wilt werken met de Azure Machine Learning V2 CLI of Python Azure Machine Learning V2 SDK, hebt u ook het volgende nodig:

Azure-CLI
Python SDK

Azure CLI versie 2.38.0 of hoger geïnstalleerd.
V2 van de ml extensie die is geïnstalleerd door de volgende opdracht uit te voeren. Zie De CLI (v2) installeren, instellen en gebruiken voor meer informatie.
```
az extension add -n ml
```

Notitie

V2 biedt volledige compatibiliteit met eerdere versies. U kunt nog steeds modelassets van de v1 SDK of CLI gebruiken. Aan alle modellen die zijn geregistreerd bij de v1 CLI of SDK, wordt het type customtoegewezen.

Een model registreren met behulp van de gebruikersinterface van Studio

Een model registreren met behulp van de gebruikersinterface van Azure Machine Learning-studio:

Selecteer Modellen in de linkernavigatiebalk in uw werkruimte in de studio.
Selecteer Registreren op de pagina Modellijst en selecteer een van de volgende locaties in de vervolgkeuzelijst:
- Vanuit lokale bestanden
- Uitvoer van een taak
- Uit gegevensarchief
- Vanuit lokale bestanden (op basis van framework)
Op het eerste scherm Model registreren:
1. Navigeer naar het lokale bestand, het gegevensarchief of de taakuitvoer voor uw model.
2. Selecteer het type invoermodel: MLflow, Triton of Niet-opgegeven type.
Geef in het scherm Modelinstellingen een naam en andere optionele instellingen op voor uw geregistreerde model en selecteer Volgende.
Controleer de configuratie op het scherm Controleren en selecteer Registreren.

Een model registreren met behulp van de Azure CLI of Python SDK

De volgende codefragmenten hebben betrekking op het registreren van een model als een asset in Azure Machine Learning met behulp van de Azure CLI of Python SDK. Deze codefragmenten gebruiken custom en mlflow modeltypen.

custom type verwijst naar een modelbestand of map die is getraind met een aangepaste standaard die momenteel niet door Azure Machine Learning wordt ondersteund.
mlflow type verwijst naar een model dat is getraind met MLflow. Getrainde MLflow-modellen bevinden zich in een map die het MLmodel-bestand , het modelbestand , het conda-afhankelijkhedenbestand en het requirements.txt-bestand bevat.

Tip

U kunt de Python-versies van de volgende voorbeelden volgen door het notebook model.ipynb uit te voeren in de opslagplaats azureml-examples .

Verbinding maken met uw werkruimte

De werkruimte is de resource op het hoogste niveau voor Azure Machine Learning en biedt een gecentraliseerde werkplek met alle artefacten die u maakt in Azure Machine Learning. In deze sectie maakt u verbinding met uw Azure Machine Learning-werkruimte om het geregistreerde model te maken.

Azure-CLI
Python SDK

Meld u aan bij Azure door de prompts uit te voeren az login en te volgen.
Vervang , en <workspace-name><resource-group><location> tijdelijke aanduidingen in de volgende opdrachten door <subscription-id>de waarden voor uw omgeving.
```
az account set --subscription <subscription-id>
az configure --defaults workspace=<workspace-name> group=<resource-group> location=<location>
```

Importeer de vereiste bibliotheken:

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

Configureer werkruimtegegevens en haal een ingang op voor de werkruimte. Vervang in het volgende codefragment de <subscription-id>tijdelijke <resource-group>aanduidingen en <workspace-name> de tijdelijke aanduidingen door de waarden voor uw omgeving.
```
subscription_id = "<subscription-id>"
resource_group = "<resource-group>"
workspace = "<workspace-name>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
```

Het geregistreerde model maken

U kunt een geregistreerd model maken op basis van een model dat:

Bevindt zich op uw lokale computer.
Bevindt zich in een Azure Machine Learning-gegevensarchief.
Uitvoer van een Azure Machine Learning-taak.

Maak een YAML-bestandsnaam<>.yml. Geef in het bestand een naam op voor uw geregistreerde model, een pad naar het lokale modelbestand en een beschrijving. Voorbeeld:

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

Voer de volgende opdracht uit met de naam van uw YAML-bestand:
```
az ml model create -f <file-name>.yml
```

Zie het MODEL YAML voor een volledig voorbeeld.

In het volgende voorbeeld ziet u hoe u een geregistreerd model maakt op basis van een lokaal bestand.

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)

Gegevensarchief

U kunt een model maken op basis van een cloudpad met behulp van een van de ondersteunde URI-indelingen.

Azure-CLI
Python SDK

In het volgende voorbeeld wordt het verkorte azureml schema gebruikt voor het verwijzen naar een pad in het gegevensarchief met behulp van de syntaxis 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

Zie de CLI-verwijzing voor een volledig voorbeeld.

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)

Taakuitvoer

Als uw modelgegevens afkomstig zijn van een taakuitvoer, hebt u twee opties voor het opgeven van het modelpad. U kunt de MLflow-URI-indeling runs: of de azureml://jobs URI-indeling gebruiken.

Notitie

Het gereserveerde trefwoord artefacten vertegenwoordigt uitvoer van de standaardlocatie van het artefact.

MLflow-uitvoeringen: URI-indeling

Deze optie is geoptimaliseerd voor MLflow-gebruikers, die waarschijnlijk al bekend zijn met de MLflow runs: URI-indeling. Met deze optie maakt u een model op basis van artefacten op de standaardlocatie voor artefacten, waar alle door MLflow geregistreerde modellen en artefacten zich bevinden. Deze optie brengt ook een herkomst tot stand tussen een geregistreerd model en de uitvoering van het model is afkomstig.

Formatteren: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>

Voorbeeld:
- Azure-CLI
- Python SDK
```
az ml model create --name my-registered-model --version 1 --path runs:/my_run_0000000000/model/ --type mlflow_model
```
```
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import ModelType

run_model = Model(
    path="runs:/my_run_0000000000/model/"
    name="my-registered-model",
    description="Model created from run.",
    type=ModelType.MLFLOW_MODEL
)

ml_client.models.create_or_update(run_model) 
```

azureml://jobs URI-indeling

Met de azureml://jobs optie verwijzings-URI kunt u een model registreren bij artefacten in een van de uitvoerpaden van de taak. Deze indeling is afgestemd op de azureml://datastores verwijzings-URI-indeling en ondersteunt ook verwijzingen naar artefacten van benoemde uitvoer anders dan de standaardlocatie van het artefact.

Als u uw model niet rechtstreeks in het trainingsscript hebt geregistreerd met behulp van MLflow, kunt u deze optie gebruiken om een herkomst tot stand te brengen tussen een geregistreerd model en de taak waaruit het is getraind.

Formatteren: azureml://jobs/<run-id>/outputs/<output-name>/paths/<path-to-model>
- Standaardlocatie van artefact: azureml://jobs/<run-id>/outputs/artifacts/paths/<path-to-model>/. Deze locatie is gelijk aan MLflow runs:/<run-id>/<model>.
- Benoemde uitvoermap: azureml://jobs/<run-id>/outputs/<named-output-folder>
- Specifiek bestand in de benoemde uitvoermap: azureml://jobs/<run-id>/outputs/<named-output-folder>/paths/<model-filename>
- Specifiek mappad in de benoemde uitvoermap: azureml://jobs/<run-id>/outputs/<named-output-folder>/paths/<model-folder-name>
Voorbeeld:
- Azure-CLI
- Python SDK
Sla een model op uit een benoemde uitvoermap:
```
az ml model create --name run-model-example --version 1 --path azureml://jobs/my_run_0000000000/outputs/artifacts/paths/model/
```
Zie de CLI-verwijzing voor een volledig voorbeeld.
Een model opslaan op basis van een benoemde uitvoer:
```
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes

job_name = "<JOB_NAME>"

run_model = Model(
    path=f"azureml://jobs/{job_name}/outputs/artifacts/paths/model/",
    name="run-model-example",
    description="Model created from run.",
    type=AssetTypes.MLFLOW_MODEL,
)
# Uncomment after adding required details above
# ml_client.models.create_or_update(run_model)
```
Zie het modelnotebook voor een volledig voorbeeld.

Modellen gebruiken voor training

Met de v2 Azure CLI en Python SDK kunt u modellen ook gebruiken als invoer of uitvoer in trainingstaken.

Een model gebruiken als invoer in een trainingstaak

Azure-CLI
Python SDK

Maak een YAML-bestand met taakspecificatie, <bestandsnaam.yml.> Geef in de inputs sectie van de taak het volgende op:

Het model type, dat kan zijn mlflow_model, custom_modelof triton_model.
Het path model bevindt zich op de locatie waar het model zich bevindt. Dit kan een van de paden zijn die worden vermeld in de opmerking van het volgende voorbeeld.

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

Voer de volgende opdracht uit, waarbij u de YAML-bestandsnaam vervangt.
```
az ml job create -f <file-name>.yml
```

Zie de GitHub-opslagplaats van het model voor een volledig voorbeeld.

Met de Input klasse kunt u het volgende definiëren:

Het modelassettype, dat een van de volgende waarden kan zijn:
- AssetTypes.CUSTOM_MODEL
- AssetTypes.MLFLOW_MODEL
- AssetTypes.TRITON_MODEL
De path gegevens van uw model, die een van de volgende locaties kunnen zijn:
- Lokaal pad: <model-folder>/<model-filename>
- Azure Machine Learning-gegevensopslag: azureml://datastores/<datastore-name>/paths/<path_on_datastore>
- MLflow-uitvoering: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
- Baan: azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
- Modelasset: azureml:<my_model>:<version>

In het volgende voorbeeld wordt een MLflow-model uit een lokale map opgehaald.

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

Een model schrijven als uitvoer voor een taak

Uw taak kan een model naar uw cloudopslag schrijven met behulp van uitvoer.

Azure-CLI
Python SDK

Maak een YAML-bestand <>met een taakspecificatie.yml. Vul de outputs sectie met het type en het pad van het uitvoermodel.

$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

Een taak maken met behulp van de CLI:

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

Zie de GitHub-opslagplaats van het model voor een volledig voorbeeld.

Met de Output klasse kunt u het volgende definiëren:

Het modelassettype, dat een van de volgende waarden kan zijn:
- AssetTypes.CUSTOM_MODEL
- AssetTypes.MLFLOW_MODEL
- AssetTypes.TRITON_MODEL
Dit path kan een van de volgende locaties zijn voor uw modelgegevens:
- Lokaal pad: mlflow-model/model.pkl
- Azure Machine Learning-gegevensopslag: azureml://datastores/<datastore-name>/paths/<path_on_datastore>
- MLflow-uitvoering: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
- Baan: azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
- Modelasset: azureml:<my_model>:<version>

In het volgende voorbeeld wordt een uitvoer gemaakt die uw standaardgegevensarchief koppelt in de lees-/schrijfmodus. De code laadt gewoon het lokale MLflow-model als invoer en exporteert hetzelfde model als een uitvoer van de taak die is opgeslagen in het gekoppelde gegevensarchief.

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

Modellen beheren

Met de Azure CLI en Python SDK kunt u ook de levenscyclus van uw Azure Machine Learning-modelassets beheren.

List

Azure-CLI
Python SDK

Geef alle modellen in uw werkruimte weer:

az ml model list

Geef alle modelversies onder een bepaalde naam weer:

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

Geef alle modellen in uw werkruimte weer:

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

Geef alle modelversies onder een bepaalde naam weer:

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

Weergeven

De details van een specifiek model ophalen:

Azure-CLI
Python SDK

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)

Bijwerken

Veranderlijke eigenschappen van een specifiek model bijwerken:

Belangrijk

Alleen voor modellen description en tags kunnen ze worden bijgewerkt. Alle andere eigenschappen zijn onveranderbaar en als u ze wilt wijzigen, moet u een nieuwe versie van het model maken.

Azure-CLI
Python SDK

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)

Archiveren

Als u een model archivert, wordt het verborgen voor lijstquery's, zoals az ml model list standaard. U kunt blijven verwijzen naar en een gearchiveerd model gebruiken in uw werkstromen.

U kunt alle versies of alleen specifieke versies van een model archiveren. Als u geen versie opgeeft, worden alle versies van het model gearchiveerd. Als u een nieuwe modelversie maakt onder een gearchiveerde modelcontainer, wordt de nieuwe versie ook automatisch ingesteld als gearchiveerd.

Azure-CLI
Python SDK

Alle versies van een model archiveren:

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

Een specifieke modelversie archiveren:

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

Alle versies van een model archiveren:

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

Een specifieke modelversie archiveren:

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

Delen via

Werken met geregistreerde modellen in Azure Machine Learning

Modelregistratie

Ondersteunde paden

Ondersteunde modi

Vereisten

Een model registreren met behulp van de gebruikersinterface van Studio

Een model registreren met behulp van de Azure CLI of Python SDK

Verbinding maken met uw werkruimte

Het geregistreerde model maken

Lokaal bestand of lokale map

Gegevensarchief

Taakuitvoer

Modellen gebruiken voor training

Een model gebruiken als invoer in een trainingstaak

Een model schrijven als uitvoer voor een taak

Modellen beheren

List

Weergeven

Bijwerken

Archiveren

Feedback

Aanvullende resources

Delen via

Werken met geregistreerde modellen in Azure Machine Learning

Modelregistratie

Ondersteunde paden

Ondersteunde modi

Vereisten

Een model registreren met behulp van de gebruikersinterface van Studio

Een model registreren met behulp van de Azure CLI of Python SDK

Verbinding maken met uw werkruimte

Het geregistreerde model maken

Lokaal bestand of lokale map

Gegevensarchief

Taakuitvoer

Modellen gebruiken voor training

Een model gebruiken als invoer in een trainingstaak

Een model schrijven als uitvoer voor een taak

Modellen beheren

List

Weergeven

Bijwerken

Archiveren

Gerelateerde inhoud

Feedback

Aanvullende resources