Arbeiten mit registrierten Modellen in Azure Machine Learning

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python SDK azure-ai-ml v2 (aktuell)

In diesem Artikel lernen Sie, wie Sie Modelle in Azure Machine Learning registrieren und mit ihnen arbeiten, indem Sie folgendes verwenden:

• Die Benutzeroberfläche von Azure Machine Learning Studio.
• Die CLI von Azure Machine Learning V2.
• Das Python-SDK von Azure Machine Learning V2.

Folgendes wird vermittelt:

• Erstellen Sie registrierte Modelle in der Modellregistrierung aus lokalen Dateien, Datenspeichern oder Auftragsausgaben.
• Arbeiten Sie mit verschiedenen Typen von Modellen, z. B. benutzerdefiniert, MLflow und Triton.
• Verwenden Sie Modelle als Eingaben oder Ausgaben in Trainingsaufträgen.
• Verwalten Sie den Lebenszyklus von Modellressourcen.

Modellregistrierung

Die Modellregistrierung ermöglicht es Ihnen, Ihre Modelle in Ihrem Arbeitsbereich in der Azure-Cloud zu speichern und zu versionieren. Mithilfe der Modellregistrierung können Sie Ihre trainierten Modelle organisieren und nachverfolgen. Sie können Modelle als eine Ressource in Azure Machine Learning registrieren, indem Sie die Azure CLI, das Python-SDK oder die Machine Learning Studio-Benutzeroberfläche verwenden.

Unterstützte Pfade

Um ein Modell zu registrieren, müssen Sie einen Pfad angeben, der auf den Daten- oder Auftragsspeicherort verweist. Die folgende Tabelle zeigt die verschiedenen Datenspeicherorte, die Azure Machine Learning unterstützt, sowie die Syntax für den Parameter path:

Location	Syntax
Lokaler Computer	<model-folder>/<model-filename>
Azure Machine Learning-Datenspeicher	azureml://datastores/<datastore-name>/paths/<path_on_datastore>
Azure Machine Learning-Auftrag	azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
MLflow-Auftrag	runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
Modellressource in einem Machine Learning-Arbeitsbereich	azureml:<model-name>:<version>
Modellressource in einer Machine Learning-Registrierung	azureml://registries/<registry-name>/models/<model-name>/versions/<version>

Unterstützte Modi

Wenn Sie Modelle für Eingaben oder Ausgaben verwenden, können Sie einen der folgenden Modi angeben. Sie können beispielsweise angeben, ob das Modell schreibgeschützt eingebunden oder in das Computeziel heruntergeladen werden soll.

• ro_mount: Binden Sie die Daten als schreibgeschützt in das Computeziel ein.
• rw_mount: Binden Sie die Daten mit Lese-/Schreibzugriff ein.
• download: Laden Sie die Daten in das Computeziel herunter.
• upload: Laden Sie die Daten aus dem Computeziel hoch.
• direct: Übergeben Sie den URI als Zeichenfolge.

Die folgende Tabelle zeigt die verfügbaren Modusoptionen für die verschiedenen Ein- und Ausgabemodelltypen.

type	upload	download	ro_mount	rw_mount	direct
custom Dateieingabe
custom Ordnereingabe		✓	✓		✓
mlflow-Eingabe		✓	✓
custom Dateiausgabe	✓			✓	✓
custom Ordnerausgabe	✓			✓	✓
mlflow-Ausgabe	✓			✓	✓

Voraussetzungen

• Ein Azure-Abonnement mit einer kostenlosen oder kostenpflichtigen Version von Azure Machine Learning. Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.
• Ein Azure Machine Learning-Arbeitsbereich.

Um die Codebeispiele in diesem Artikel auszuführen und mit der CLI oder dem Python-SDK von Azure Machine Learning V2 zu arbeiten, benötigen Sie auch Folgendes:

Azure-Befehlszeilenschnittstelle

• Azure CLI Version 2.38.0 oder höher installiert.

• V2 der ml-Erweiterung, die durch das Ausführen des folgenden Befehls installiert wird. Weitere Informationen finden Sie unter Installieren, Einrichten und Verwenden der CLI (v2).

  az extension add -n ml
  

Python SDK

• Python 3.8 oder höher installiert.

• Das Azure Machine Learning-SDK v2 für Python, das durch das Ausführen des folgenden Befehls installiert wird:

  pip install azure-ai-ml azure-identity
  

Hinweis

V2 bietet vollständige Abwärtskompatibilität. Sie können weiterhin Modellressourcen aus dem SDK oder der CLI der Version v1 verwenden. Allen mit der CLI oder dem SDK der Version v1 registrierten Modellen ist der Typ custom zugewiesen.

Registrieren eines Modells mithilfe der Studio-Benutzeroberfläche

So registrieren Sie ein Modell mithilfe der Azure Machine Learning Studio-Benutzeroberfläche:

1. Wählen Sie in Ihrem Arbeitsbereich im Studio Modelle aus der linken Navigation aus.

2. Wählen Sie auf der Seite Modellliste die Option Registrieren aus, und wählen Sie einen der folgenden Speicherorte aus der Dropdownliste aus:

   • Aus lokalen Dateien
   • Aus einer Auftragsausgabe
   • Aus dem Datenspeicher
   • Von lokalen Dateien (basierend auf Framework)

3. Führen Sie auf dem ersten Bildschirm Modell registrieren folgendes aus:

   1. Navigieren Sie zur lokalen Datei, zum Datenspeicher oder der Auftragsausgabe für Ihr Modell.
   2. Wählen Sie den Typ des Eingabemodells aus: MLflow, Triton oder Nicht spezifizierter Typ.

4. Geben Sie auf dem Bildschirm Modelleinstellungen einen Namen und andere optionale Einstellungen für Ihr registriertes Modell an, und wählen Sie Weiter aus.

5. Überprüfen Sie auf dem Bildschirm Überprüfen die Konfiguration, und wählen Sie dann Registrieren aus.

Registrieren eines Modells mithilfe der Azure CLI oder dem Python-SDK

Die folgenden Codeausschnitte behandeln das Registrieren eines Modells als eine Ressource in Azure Machine Learning mithilfe der Azure CLI oder dem Python-SDK. Diese Codeausschnitte verwenden die Modelltypen custom und mlflow.

• Der Typ custom bezieht sich auf eine Modelldatei oder einen Ordner, der mit einem benutzerdefinierten Standard trainiert wurde, den Azure Machine Learning derzeit nicht unterstützt.
• Der Typ mlflow bezieht sich auf ein Modell, das mit MLflow trainiert wurde. Trainierte MLflow-Modelle befinden sich in einem Ordner, der die MLmodel-Datei, die Datei mit dem Modell, die Datei mit Conda-Abhängigkeiten und die Datei requirements.txt enthält.

Tipp

Sie können die Python-Versionen der folgenden Beispiele nachvollziehen, indem Sie das model.ipynb-Notebook im azureml-examples-Repository ausführen.

Herstellen einer Verbindung mit Ihrem Arbeitsbereich

Der Arbeitsbereich ist die Ressource der obersten Ebene für Azure Machine Learning und ein zentraler Ort für die Arbeit mit allen Artefakten, die Sie während der Nutzung von Azure Machine Learning erstellen. In diesem Abschnitt stellen Sie eine Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich her, um das registrierte Modell zu erstellen.

Azure-Befehlszeilenschnittstelle

1. Melden Sie sich bei Azure an, indem Sie az login ausführen und den Eingabeaufforderungen folgen.

2. Ersetzen Sie in den folgenden Befehlen die Platzhalter <subscription-id>, <workspace-name>, <resource-group> und <location> mit den Werten für Ihre Umgebung.

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

Python SDK

1. Importieren Sie die erforderlichen 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
   

2. Konfigurieren Sie Arbeitsbereichsdetails und rufen Sie einen Handle für den Arbeitsbereich ab. Ersetzen Sie im folgenden Codeausschnitt die Platzhalter <subscription-id>, <resource-group> und <workspace-name> mit den Werten für Ihre Umgebung.

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

Erstellen des registrierten Modells

Sie können ein registriertes Modell aus einem Modell erstellen, das folgende Charakteristiken aufweist:

• Es befindet sich auf Ihrem lokalen Computer.
• Es befinden sich in einem Azure Machine Learning-Datenspeicher.
• Es ist eine Ausgabe aus einem Azure Machine Learning-Auftrag.

Lokale Datei oder lokaler Ordner

Azure-Befehlszeilenschnittstelle

1. Erstellen Sie einen YAML-Datei <file-name>.yml. Geben Sie in der Datei einen Namen für Ihr registriertes Modell, einen Pfad zur lokalen Modelldatei und eine Beschreibung an. Zum Beispiel:

   $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. Führen Sie den folgenden Befehl mit dem Namen Ihrer YAML-Datei aus:

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

Ein vollständiges Beispiel finden Sie im YAML-Code des Modells.

Python SDK

Das folgende Beispiel zeigt das Erstellen eines registrierten Modells aus einer lokalen Datei.

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)

Datenspeicher

Sie können ein Modell aus einem Cloudpfad mit einem beliebigen der unterstützten URI-Formate erstellen.

Azure-Befehlszeilenschnittstelle

Im folgenden Beispiel wird das Kurzschema azureml verwendet, um mithilfe der Syntax azureml://datastores/<datastore-name>/paths/<path_on_datastore> auf einen Pfad im Datenspeicher zu verweisen.

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

Ein vollständiges Beispiel finden Sie in der Referenz zur CLI.

Python SDK

Im folgenden Beispiel wird das Kurzschema azureml verwendet, um mithilfe der Syntax azureml://datastores/${{datastore-name}}/paths/${{path_on_datastore}} auf einen Pfad im Datenspeicher zu verweisen.

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)

Auftragsausgabe

Wenn Ihre Modelldaten aus einer Auftragsausgabe stammen, haben Sie zwei Optionen zum Angeben des Modellpfads. Sie können das MLflow-URI-Format runs: oder das URI-Format azureml://jobs verwenden.

Hinweis

Das reservierte Schlüsselwort artifacts steht für die Ausgabe aus dem Standardartefaktspeicherort.

• MLflow-Ausführung: URI-Format

  Diese Option ist für MLflow-Benutzer optimiert, die wahrscheinlich bereits mit dem MLflow-URI-Format runs: vertraut sind. Diese Option erstellt ein Modell aus Artefakten am Standardartefaktspeicherort, in dem sich alle von MLflow protokollierten Modelle und Artefakte befinden. Diese Option stellt auch eine Datenherkunft zwischen einem registrierten Modell und der Ausführung her, aus der das Modell stammt.

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

  Beispiel:

  Azure-Befehlszeilenschnittstelle

  az ml model create --name my-registered-model --version 1 --path runs:/my_run_0000000000/model/ --type mlflow_model
  

  Python SDK

  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-Format

  Mit der Referenz-URI-Option azureml://jobs können Sie ein Modell aus Artefakten in einem beliebigen Ausgabepfad des Auftrags registrieren. Dieses Format entspricht dem Referenz-URI-Format azureml://datastores und unterstützt auch das Referenzieren auf Artefakte aus benannten Ausgaben, die sich vom Standardartefaktspeicherort unterscheiden.

  Wenn Sie Ihr Modell nicht direkt innerhalb des Trainingsskripts mit MLflow registriert haben, können Sie diese Option verwenden, um eine Datenherkunft zwischen einem registrierten Modell und dem Auftrag herzustellen, mit dem es trainiert wurde.

  Format: azureml://jobs/<run-id>/outputs/<output-name>/paths/<path-to-model>

  • Standardartefaktspeicherort: azureml://jobs/<run-id>/outputs/artifacts/paths/<path-to-model>/. Dieser Speicherort entspricht MLflow runs:/<run-id>/<model>.
  • Benannter Ausgabeordner: azureml://jobs/<run-id>/outputs/<named-output-folder>
  • Bestimmte Datei innerhalb des benannten Ausgabeordners: azureml://jobs/<run-id>/outputs/<named-output-folder>/paths/<model-filename>
  • Bestimmter Ordnerpfad innerhalb des benannten Ausgabeordners: azureml://jobs/<run-id>/outputs/<named-output-folder>/paths/<model-folder-name>

  Beispiel:

  Azure-Befehlszeilenschnittstelle

  Speichern eines Modells aus einem benannten Ausgabeordner:

  az ml model create --name run-model-example --version 1 --path azureml://jobs/my_run_0000000000/outputs/artifacts/paths/model/
  

  Ein vollständiges Beispiel finden Sie in der Referenz zur CLI.

  Python SDK

  Speichern eines Modells aus einer benannten Ausgabe:

  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)

  Ein vollständiges Beispiel finden Sie im Modellnotebook.

---

Verwenden von Modellen für das Training

Mit der Azure CLI und dem Python-SDK der Version v2 können Sie Modelle auch als Eingaben oder Ausgaben in Trainingsaufträgen verwenden.

Verwenden eines Modells als Eingabe in einem Trainingsauftrag

Azure-Befehlszeilenschnittstelle

1. Erstellen Sie eine YAML-Datei <file-name>.yml für die Auftragsspezifikation. Geben Sie im Abschnitt inputs des Auftrags Folgendes an:

   • Das Modell type, das mlflow_model, custom_model oder triton_model sein kann.
   • Der path, an dem sich Ihr Modell befindet. Dies kann einer der im Kommentar des folgenden Beispiels aufgeführten Pfade sein.

   $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
   

2. Führen Sie den folgenden Befehl aus und ersetzen Sie dabei Ihren YAML-Dateinamen.

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

Ein vollständiges Beispiel finden Sie im Modellrepository auf GitHub.

Python SDK

Die Input-Klasse, mit der Sie Folgendes definieren können:

• Der Modellressourcentyp, der einer der folgenden Werte sein kann:

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

• Der path Ihrer Modelldaten, der einer der folgenden Speicherorte sein kann:

  • Lokaler Pfad: <model-folder>/<model-filename>
  • Azure Machine Learning-Datenspeicher: azureml://datastores/<datastore-name>/paths/<path_on_datastore>
  • MLflow-Ausführung: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
  • Auftrag: azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
  • Modellressource: azureml:<my_model>:<version>

Das folgende Beispiel verwendet ein MLflow-Modell aus einem lokalen Ordner als Eingabe.

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

Schreiben eines Modells als Ausgabe für einen Auftrag

Ihr Auftrag kann mithilfe von Ausgaben ein Modell in Ihren cloudbasierten Speicher schreiben.

Azure-Befehlszeilenschnittstelle

1. Erstellen Sie eine YAML-Datei <file-name>.yml für die Auftragsspezifikation. Füllen Sie den Abschnitt outputs mit dem Ausgabemodelltyp und dem Pfad auf.

   $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. Erstellen Sie einen Auftrag mithilfe der CLI:

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

Ein vollständiges Beispiel finden Sie im Modellrepository auf GitHub.

Python SDK

Die Output-Klasse, mit der Sie Folgendes definieren können:

• Der Modellressourcentyp, der einer der folgenden Werte sein kann:

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

• Der path für Ihre Modelldaten, der einer der folgenden Speicherorte sein kann:

  • Lokaler Pfad: mlflow-model/model.pkl
  • Azure Machine Learning-Datenspeicher: azureml://datastores/<datastore-name>/paths/<path_on_datastore>
  • MLflow-Ausführung: runs:/<run-id>/<path-to-model-relative-to-the-root-of-the-artifact-location>
  • Auftrag: azureml://jobs/<job-name>/outputs/<output-name>/paths/<path-to-model-relative-to-the-named-output-location>
  • Modellressource: azureml:<my_model>:<version>

Im folgenden Beispiel wird eine Ausgabe erstellt, die den Standarddatenspeicher im Lese-/Schreibmodus einbindet. Der Code lädt einfach das lokale MLflow-Modell als Eingabe und exportiert dasselbe Modell als eine Ausgabe des Auftrags, der im eingebundenen Datenspeicher gespeichert ist.

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

Verwalten von Modellen

Mit der Azure CLI und dem Python-SDK können Sie auch den Lebenszyklus Ihrer Azure Machine Learning-Modellressourcen verwalten.

Liste

Azure-Befehlszeilenschnittstelle

Auflisten aller Modelle in Ihrem Arbeitsbereich:

az ml model list

Auflisten aller Modellversionen unter einem bestimmten Namen:

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

Python SDK

Auflisten aller Modelle in Ihrem Arbeitsbereich:

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

Auflisten aller Modellversionen unter einem bestimmten Namen:

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

Anzeigen

Abrufen von Details zu einem bestimmten Modell:

Azure-Befehlszeilenschnittstelle

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

Python SDK

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

Aktualisieren

Aktualisieren änderbarer Eigenschaften eines bestimmten Modells:

Wichtig

Bei Modellen können nur description und tags aktualisiert werden. Alle anderen Eigenschaften sind unveränderlich, und wenn Sie diese ändern müssen, sollten Sie eine neue Version des Modells erstellen.

Azure-Befehlszeilenschnittstelle

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

Python SDK

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

Archivieren

Durch das Archivieren eines Modells wird es standardmäßig aus Listenabfragen wie az ml model list ausgeblendet. Sie können in Ihren Workflows weiterhin auf ein archiviertes Modell verweisen und es verwenden.

Sie können alle Versionen oder nur bestimmte Versionen eines Modells archivieren. Wenn Sie keine Version angeben, werden alle Versionen des Modells archiviert. Wenn Sie eine neue Modellversion in einem archivierten Modellcontainer erstellen, wird diese neue Version ebenfalls automatisch als archiviert festgelegt.

Azure-Befehlszeilenschnittstelle

Archivieren aller Versionen eines Modells:

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

Archivieren einer bestimmten Modellversion:

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

Python SDK

Archivieren aller Versionen eines Modells:

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

Archivieren einer bestimmten Modellversion:

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

Zugehöriger Inhalt

• Freigeben von Modellen, Komponenten und Umgebungen für Arbeitsbereiche mit Registrierungen
• Clientbibliothek für Python im Azure Machine Learning-Paket – Version 1.16.1
• Azure CLI ML-Erweiterung
• MLflow und Azure Machine Learning
• Bereitstellen von MLflow-Modellen für Onlineendpunkte