Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Automatisches Registrieren von SageMaker KI-Modellen bei Model Registry SageMaker

Wenn Sie ein MLflow-Modell registrieren, erstellt SageMaker AI automatisch eine entsprechende Modellpaketgruppe und eine Modellpaketversion in der SageMaker Modellregistrierung. Dies ermöglicht es Ihnen,

Modelle protokollieren und registrieren

In diesem Abschnitt erfahren Sie, wie Sie ein Modell für die Registrierung vorbereiten, es in der SageMaker Modellregistrierung registrieren und es in Studio anzeigen.

Erforderliche IAM-Berechtigungen

Der MLflow Tracking Server oder die MLflow App IAM Service-Rolle müssen über die folgenden Berechtigungen verfügen, um Modelle registrieren zu können:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sagemaker:CreateModelPackageGroup",
                "sagemaker:DescribeModelPackageGroup",
                "sagemaker:CreateModelPackage",
                "sagemaker:UpdateModelPackage",
                "sagemaker:AddTags",
                "sagemaker:CreateAction",
                "sagemaker:AddAssociation"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": "*"
        }
    ]
}

Weitere Informationen zum Einrichten von IAM-Rollen für MLflow Apps finden Sie unter. Richten Sie IAM-Berechtigungen für MLFlow-Apps ein

Bereiten Sie ein Modell für die Registrierung vor

Bevor Sie ein Modell registrieren, protokollieren Sie es während eines Trainingslaufs. Sie können optional eine Inferenzspezifikation und Bewertungsmetriken beifügen, die bei der Registrierung in das SageMaker AI Model Package übernommen werden.

Loggen Sie ein Modell

Verwenden Sie das MLflow SDK, um ein Modell während eines Trainingslaufs zu protokollieren:

import mlflow
from sklearn.datasets import make_regression
from sklearn.ensemble import RandomForestRegressor
from mlflow.models import infer_signature

mlflow.set_tracking_uri(arn)
mlflow.set_experiment("my-experiment")

params = {"n_estimators": 3, "random_state": 42}
X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)

with mlflow.start_run() as run:
    model = RandomForestRegressor(**params).fit(X, y)
    signature = infer_signature(X, model.predict(X))
    mlflow.log_params(params)
    model_info = mlflow.sklearn.log_model(
        model, name="sklearn-model", signature=signature, input_example=X[:3]
    )

Eine Inferenzspezifikation protokollieren (optional)

Eine Inferenzspezifikation definiert das Container-Image und die Instanztypen, die für die Bereitstellung Ihres Modells erforderlich sind. Wenn die Inferenzspezifikation vor der Registrierung an ein protokolliertes Modell angehängt wird, ist sie automatisch im SageMaker AI Model Package enthalten. Dies ermöglicht die direkte Bereitstellung auf einem SageMaker AI-Endpunkt aus der Modellregistrierung ohne zusätzliche Konfiguration.

Wird verwendetsagemaker_mlflow.log_inference_specification(), um eine Inferenzspezifikation anzuhängen:

import sagemaker_mlflow

# Get the logged model's artifact location
logged_model = mlflow.MlflowClient().get_logged_model(model_info.model_id)

inference_spec = {
    "Containers": [{
        "Image": "763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-inference:2.0.0-cpu-py310",
        "ModelDataSource": {
            "S3DataSource": {
                "S3Uri": logged_model.artifact_location + "/",
                "S3DataType": "S3Prefix",
                "CompressionType": "None",
            }
        },
    }],
    "SupportedRealtimeInferenceInstanceTypes": ["ml.m5.xlarge"],
}
sagemaker_mlflow.log_inference_specification(
    model_info.model_id,
    inference_specification=inference_spec
)

Nach der Protokollierung wird die Inferenzspezifikation als sagemaker_inference_specification.json Artefakt zusammen mit Ihrem Modell gespeichert:

Bewertungsmetriken protokollieren (optional)

Bewertungsmetriken bieten eine standardisierte Zusammenfassung der Leistung Ihres Modells. Wenn die Evaluierungsergebnisse vor der Registrierung protokolliert wurden, sind sie im SageMaker AI Model Package als Modellkarte enthalten, sodass die Metriken in der SageMaker AI Model Registry und Studio sichtbar sind. Weitere Informationen zu Modellkarten finden Sie unter Modellkartenschema.

Wird verwendetsagemaker_mlflow.evaluate(), um Bewertungsmetriken zu protokollieren:

import sagemaker_mlflow
import pandas as pd

eval_df = pd.DataFrame(X, columns=["f1", "f2", "f3"])
eval_df["target"] = y
dataset = mlflow.data.from_pandas(
    eval_df, source="s3://my-bucket/eval.csv", name="eval_set", targets="target"
)
sagemaker_mlflow.evaluate(model_info, data=dataset, model_type="regressor")

Nach der Protokollierung wird die Bewertungsgruppe als Artefakt zusammen mit Ihrem Modell gespeichert:

Registrieren Sie Modelle mithilfe des SDK

Wird verwendetmlflow.register_model(), um ein Modell in der SageMaker Modellregistrierung zu registrieren. Dadurch werden automatisch eine Modellpaketgruppe (falls keine vorhanden ist) und eine Modellpaketversion in SageMaker AI erstellt.

model_uri = f"runs:/{run.info.run_id}/sklearn-model"
mv = mlflow.register_model(model_uri, "MyRegisteredModel")

print(f"Name: {mv.name}")
print(f"Version: {mv.version}")

Sie können auch Folgendes verwendencreate_registered_model, um die Model Package Group zu erstellen, bevor Sie Versionen registrieren:

from mlflow import MlflowClient

client = MlflowClient()
client.create_registered_model("MyRegisteredModel", tags={"team": "ml-platform"})

Nach der Registrierung wird die Modellversion mit dem SageMaker AI Model Package ARN gekennzeichnet. Sie können es wie folgt abrufen:

mv = client.get_model_version("MyRegisteredModel", mv.version)
sm_arn = mv.tags["sagemaker.model_package_arn"]
print(f"SageMaker Model Package ARN: {sm_arn}")

Registrieren von Modellen über die MLflow-Benutzeroberfläche

Sie können ein Modell direkt in der MLflow-Benutzeroberfläche bei der SageMaker Modellregistrierung registrieren. Wählen Sie im Menü „Modelle“ die Option „Modell erstellen“. Auf diese Weise erstellte Modelle werden automatisch zur SageMaker Modellregistrierung hinzugefügt.

Nachdem Sie ein Modell bei der Experimentnachverfolgung protokolliert haben, navigieren Sie zur Ausführungsseite in der MLflow-Benutzeroberfläche. Wählen Sie den Bereich Artefakte und dann Modell registrieren, um die Modellversion sowohl in MLflow als auch in SageMaker Model Registry zu registrieren.

Anzeigen registrierter Modelle in Studio

Wählen Sie in Studio im linken Navigationsbereich Models aus, um Ihre registrierten Modelle anzuzeigen. Weitere Informationen zu den ersten Schritten mit Studio finden Sie unter Amazon SageMaker Studio starten.

Auf der Seite mit der Modellpaket-Version in Studio werden Trainingsmetriken und Datensätze angezeigt, die von MLflow synchronisiert wurden:

Auf der Registerkarte „Zug“ werden auch die Position des Trainingsdatensatzes und der Pfad der Modellartefakte angezeigt:

Wenn Sie eine Inferenzspezifikation protokolliert haben, werden im Abschnitt Container das Container-Image, der Speicherort der Modelldaten und die unterstützten Instanztypen angezeigt. In der Bereitstellungsphase wird Genehmigt angezeigt, was bedeutet, dass das Modell bereit für die Bereitstellung ist:

Wenn Sie Bewertungsmetriken protokolliert haben, werden auf der Registerkarte „Evaluieren“ Leistungskennzahlen wie Punktzahl, mittlerer absoluter Fehler und quadratischer Mittelwert angezeigt:

Auf der Registerkarte „Auswerten“ wird auch der Speicherort des Bewertungsdatensatzes angezeigt:

Die Registerkarte Lineage zeigt die Beziehung zwischen dem MLflow-Experiment, der Modellversion, dem Container-Image und der Modellpaketgruppe:

Einschränkungen

Phasen des Modelllebenszyklus verwalten

Nach der Registrierung eines Modells können Sie seine Lebenszyklusphase und seinen Status in der SageMaker AI Model Registry verwalten, indem Sie Aliasnamen für die MLflow-Modellversion festlegen. Wenn Sie einen Alias anhand der Benennungskonvention für den Lebenszyklus festlegen, wird der entsprechende Lebenszyklus des SageMaker AI-Modellpakets automatisch aktualisiert. Weitere Informationen zu den Phasen des Modelllebenszyklus finden Sie unter Stufenmodelle in der Modellregistrierung.

IAM-Berechtigungen für das Lebenszyklusmanagement

Der MLflow-Tracking-Server oder die MLflow App IAM-Servicerolle benötigt die sagemaker:UpdateModelPackage Berechtigung zur Verwaltung von Lebenszyklusphasen. Diese Aktion ist bereits in den oben beschriebenen Basisregistrierungsberechtigungen enthalten.

Beschränken Sie Lebenszyklusüber

Sie können IAM-Bedingungsschlüssel verwenden, um zu steuern, welche Lebenszyklusübergänge eine Rolle durchführen darf:

Beispiel: Werbeaktionen für die Produktion ablehnen

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "sagemaker:UpdateModelPackage",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "sagemaker:ModelLifeCycle/stage": "production"
                }
            }
        }
    ]
}

Beispiel: Nur staging/pending Übergänge zulassen

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "sagemaker:UpdateModelPackage",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "sagemaker:ModelLifeCycle/stage": "staging",
                    "sagemaker:ModelLifeCycle/stageStatus": "pending"
                }
            }
        }
    ]
}

Wenn ein Lebenszyklusübergang durch eine IAM-Richtlinie verweigert wird, schlägt der MLflow-Aliasvorgang fehl und gibt einen Fehler an den Aufrufer zurück.

Weitere Informationen zum Modelllebenszyklus in der SageMaker AI Model Registry finden Sie unter Ein Modell aus der Registrierung bereitstellen.

Legen Sie mithilfe des SDK Lebenszyklusphasen fest

Verwenden Sie das folgende Aliasformat, um die Phase und den Status des Lebenszyklus festzulegen:

sagemakerlifecycle-stage-status

Unterstützte Phasen:staging, production

Unterstützte Status:pending, active

import mlflow

mlflow.set_tracking_uri(arn)
client = mlflow.MlflowClient()

# Set lifecycle to staging/pending
client.set_registered_model_alias("MyRegisteredModel", "sagemakerlifecycle-staging-pending", version)

# Promote to production/active
client.set_registered_model_alias("MyRegisteredModel", "sagemakerlifecycle-production-active", version)

Sie können den Lebenszyklusstatus überprüfen, indem Sie das SageMaker AI Model Package beschreiben:

import boto3

sm = boto3.client("sagemaker")
mv = client.get_model_version("MyRegisteredModel", version)
sm_arn = mv.tags["sagemaker.model_package_arn"]

desc = sm.describe_model_package(ModelPackageName=sm_arn)
print(desc["ModelLifeCycle"]["Stage"])       # "staging"
print(desc["ModelLifeCycle"]["StageStatus"]) # "pending"

Legen Sie die Lebenszyklusphasen mithilfe der MLflow-Benutzeroberfläche fest

Navigieren Sie in der MLflow-Benutzeroberfläche zur Seite mit der Modellversion. Fügen Sie unter Aliase einen Alias hinzu, der das sagemakerlifecycle-stage-status Format verwendet. Der Lebenszyklus des SageMaker AI Model Package wird automatisch aktualisiert, wenn der Alias gespeichert wird.

Zeigen Sie die Lebenszyklusphasen in Studio an

Navigieren Sie in Studio zu Models und wählen Sie eine Model Package-Version aus. Die Lebenszyklusphase und der Status werden auf der Registerkarte Details unter Modelllebenszyklus angezeigt.

Verhindern Sie Aktualisierungen registrierter Modelle mithilfe von Ressourcen-Tags

Sie können Bedingungen verwenden, die auf IAM-Ressourcen-Tags basieren, um zu verhindern, dass der MLflow-Tracking-Server oder die MLflow App-Rolle bestimmte Modellpaketgruppen oder Modellpaketversionen ändert. Auf diese Weise können Sie verhindern, dass einzelne Modelle über MLflow aktualisiert werden, nachdem sie einen bestimmten Status erreicht haben.

Die folgende Richtlinie verweigert UpdateModelPackage beispielsweise jedes Modellpaket, das das Tag hat: locked=true

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "sagemaker:UpdateModelPackage",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "aws:ResourceTag/locked": "true"
                }
            }
        }
    ]
}

Wenn diese Richtlinie an den Tracking-Server oder die MLflow-App-Rolle angehängt ist, schlägt jeder Versuch, den Lebenszyklus eines markierten Model-Pakets von MLflow aus zu aktualisieren, fehl und es wird die Fehlermeldung „Zugriff verweigert“ angezeigt.

Sie können CreateModelPackage auf ähnliche Weise eine Modellpaketgruppe einschränken, um zu verhindern, dass neue Versionen registriert werden:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "sagemaker:CreateModelPackage",
            "Resource": "arn:aws:sagemaker:region:account:model-package-group/group-name/*",
            "Condition": {
                "StringEquals": {
                    "aws:ResourceTag/frozen": "true"
                }
            }
        }
    ]
}