Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Enregistrez automatiquement les modèles d' SageMaker IA dans SageMaker Model Registry

Lorsque vous enregistrez un modèle MLflow, SageMaker AI crée automatiquement un groupe de packages de modèles et une version de package de modèles correspondants dans le registre des SageMaker modèles. Elle vous permet d'effectuer les opérations suivantes :

Modèles d'enregistrement et d'enregistrement

Cette section explique comment préparer un modèle pour l'enregistrement, l'enregistrer dans le registre des SageMaker modèles et l'afficher dans Studio.

Autorisations IAM requises

Le serveur de suivi MLflow ou le rôle de service IAM MLflow App doit disposer des autorisations suivantes pour enregistrer des modèles :

{
    "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": "*"
        }
    ]
}

Pour plus d'informations sur la configuration des rôles IAM pour les applications MLflow, consultez. Configuration des autorisations IAM pour les applications MLflow

Préparer un modèle pour l'enregistrement

Avant d'enregistrer un modèle, vous l'enregistrez pendant un entraînement. Vous pouvez éventuellement joindre une spécification d'inférence et des mesures d'évaluation, qui sont reportées dans le package de modèles d' SageMaker IA lors de l'enregistrement.

Enregistrer un modèle

Utilisez le SDK MLflow pour enregistrer un modèle pendant une séance d'entraînement :

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]
    )

Consignez une spécification d'inférence (facultatif)

Une spécification d'inférence définit l'image du conteneur et les types d'instances requis pour déployer votre modèle. Lorsqu'elle est attachée à un modèle enregistré avant l'enregistrement, la spécification d'inférence est automatiquement incluse dans le package de modèles d' SageMaker IA. Cela permet un déploiement direct vers un point de terminaison SageMaker IA à partir du Model Registry sans configuration supplémentaire.

Utilisez sagemaker_mlflow.log_inference_specification() pour joindre une spécification d'inférence :

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
)

Après la journalisation, la spécification d'inférence est stockée sous forme d'sagemaker_inference_specification.jsonartefact à côté de votre modèle :

Métriques d'évaluation des journaux (facultatif)

Les mesures d'évaluation fournissent un résumé standardisé des performances de votre modèle. Lorsqu'ils sont enregistrés avant l'enregistrement, les résultats de l'évaluation sont inclus dans le package SageMaker AI Model sous forme de fiche modèle, ce qui rend les métriques visibles dans SageMaker AI Model Registry et Studio. Pour plus d'informations sur les modèles de cartes, voir Schéma de carte modèle.

sagemaker_mlflow.evaluate()À utiliser pour enregistrer les mesures d'évaluation :

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")

Après la journalisation, le groupe d'évaluation est stocké sous forme d'artefact à côté de votre modèle :

Enregistrez des modèles à l'aide du SDK

Permet mlflow.register_model() d'enregistrer un SageMaker modèle dans le registre des modèles. Cela crée automatiquement un groupe de packages de modèles (s'il n'en existe pas) et une version de package de modèles dans SageMaker AI.

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}")

Vous pouvez également utiliser create_registered_model pour créer le groupe de packages de modèles avant d'enregistrer les versions :

from mlflow import MlflowClient

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

Après l'enregistrement, la version du modèle est étiquetée avec l'ARN du SageMaker AI Model Package. Vous pouvez le récupérer comme suit :

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

Enregistrement de modèles à l’aide de l’interface utilisateur MLflow

Vous pouvez enregistrer un modèle dans le registre des SageMaker modèles directement dans l'interface utilisateur de MLflow. Dans le menu Modèles, choisissez Créer un modèle. Les modèles créés de cette manière sont automatiquement ajoutés au registre des SageMaker modèles.

Après avoir journalisé un modèle pendant le suivi des expériences, accédez à la page d’exécution dans l’interface utilisateur MLflow. Choisissez le volet Artifacts et choisissez Register le modèle pour enregistrer la version du modèle à la fois dans MLflow et dans SageMaker Model Registry.

Affichage des modèles enregistrés dans Studio

Dans Studio, choisissez Modèles dans le volet de navigation de gauche pour afficher les modèles que vous avez enregistrés. Pour plus d'informations sur la prise en main de Studio, consultez Lancer Amazon SageMaker Studio.

La page de version du package de modèle dans Studio affiche les mesures d'entraînement et les ensembles de données qui ont été synchronisés depuis MLflow :

L'onglet Train indique également l'emplacement du jeu de données d'entraînement et le chemin des artefacts du modèle :

Si vous avez enregistré une spécification d'inférence, la section Conteneur affiche l'image du conteneur, l'emplacement des données du modèle et les types d'instances pris en charge. L'étape de déploiement affiche Approuvé, ce qui indique que le modèle est prêt à être déployé :

Si vous avez enregistré des mesures d'évaluation, l'onglet Evaluer affiche des mesures de performance telles que le score, l'erreur absolue moyenne et l'erreur quadratique moyenne :

L'onglet Evaluer indique également l'emplacement du jeu de données d'évaluation :

L'onglet Lineage montre la relation entre l'expérience MLflow, la version du modèle, l'image du conteneur et le groupe de packages de modèles :

Limitations

Gérer les étapes du cycle de vie des modèles

Après avoir enregistré un modèle, vous pouvez gérer son stade de cycle de vie et son statut dans le registre des modèles SageMaker AI en définissant des alias de version du modèle MLflow. Lorsque vous définissez un alias à l'aide de la convention de dénomination du cycle de vie, le cycle de vie du package de modèles SageMaker AI correspondant est automatiquement mis à jour. Pour plus d'informations sur les étapes du cycle de vie des modèles, voir Modèles d'étapes dans le registre des modèles.

Autorisations IAM pour la gestion du cycle de vie

Le rôle de serveur de suivi MLflow ou de service IAM de l'application MLflow nécessite une sagemaker:UpdateModelPackage autorisation pour gérer les étapes du cycle de vie. Cette action est déjà incluse dans les autorisations d'enregistrement de base décrites ci-dessus.

Restreindre les transitions du cycle

Vous pouvez utiliser les clés de condition IAM pour contrôler les transitions de cycle de vie qu'un rôle est autorisé à effectuer :

Exemple : Refuser les promotions de production

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

Exemple : Autoriser uniquement staging/pending les transitions

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

Lorsqu'une transition de cycle de vie est refusée par la politique IAM, l'opération d'alias MLflow échoue et renvoie une erreur à l'appelant.

Pour plus d'informations sur le cycle de vie des modèles dans SageMaker AI Model Registry, voir Déployer un modèle à partir du registre.

Définissez les étapes du cycle de vie à l'aide du SDK

Utilisez le format d'alias suivant pour définir l'étape et le statut du cycle de vie :

sagemakerlifecycle-stage-status

Étapes prises en charge :staging, production

Statuts pris en charge :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)

Vous pouvez vérifier l'état du cycle de vie en décrivant le package de modèles d' SageMaker IA :

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"

Définissez les étapes du cycle de vie à l'aide de l'interface utilisateur MLflow

Dans l'interface utilisateur MLflow, accédez à la page de version du modèle. Sous Alias, ajoutez un alias en utilisant le sagemakerlifecycle-stage-status format. Le cycle de vie du package de modèles d' SageMaker IA est automatiquement mis à jour lorsque l'alias est enregistré.

Afficher les étapes du cycle de vie dans Studio

Dans Studio, accédez à Modèles et sélectionnez une version du package de modèles. L'étape et l'état du cycle de vie sont affichés dans l'onglet Détails sous Cycle de vie du modèle.

Empêcher les mises à jour des modèles enregistrés à l'aide de balises de ressources

Vous pouvez utiliser des conditions basées sur des balises de ressources IAM pour empêcher le serveur de suivi MLflow ou le rôle d'application MLflow de modifier des groupes de packages de modèles ou des versions de packages de modèles spécifiques. Cela vous permet d'empêcher la mise à jour de modèles individuels via MLflow une fois qu'ils ont atteint un certain état.

Par exemple, la politique suivante refuse UpdateModelPackage tout modèle de package contenant le tag locked=true :

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

Lorsque cette politique est associée au rôle de serveur de suivi ou d'application MLflow, toute tentative de mise à jour du cycle de vie d'un package modèle balisé à partir de MLflow échoue et entraîne une erreur d'accès refusé.

Vous pouvez également restreindre CreateModelPackage un groupe de packages modèles pour empêcher l'enregistrement de nouvelles versions :

{
    "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"
                }
            }
        }
    ]
}