Création d'une fiche modèle

Important

Les IAM politiques personnalisées qui autorisent Amazon SageMaker Studio ou Amazon SageMaker Studio Classic à créer des SageMaker ressources Amazon doivent également accorder des autorisations pour ajouter des balises à ces ressources. L'autorisation d'ajouter des balises aux ressources est requise car Studio et Studio Classic balisent automatiquement toutes les ressources qu'ils créent. Si une IAM politique autorise Studio et Studio Classic à créer des ressources mais n'autorise pas le balisage, des erreurs « AccessDenied » peuvent se produire lors de la tentative de création de ressources. Pour de plus amples informations, veuillez consulter Fournir des autorisations pour le balisage des ressources SageMaker.

AWS Politiques gérées pour Amazon SageMakerqui donnent des autorisations pour créer des SageMaker ressources incluent déjà des autorisations pour ajouter des balises lors de la création de ces ressources.

Vous pouvez créer une Amazon SageMaker Model Card à l'aide de la SageMaker console ou du SageMaker PythonSDK. Vous pouvez également utiliser les API opérations directement. Pour plus d'informations sur les API opérations, consultezFaible niveau SageMaker APIs pour les modèles de cartes.

Création d'une carte modèle à l'aide de la SageMaker console

Accédez à la SageMaker console Amazon. Dans le volet de navigation, sous Governance (Gouvernance), choisissez Model cards (Fiches modèles). Dans l'angle supérieur droit, choisissez Create model card (Créer une fiche modèle).

Suivez les quatre étapes décrites dans l'invite Create model card (Créer une fiche modèle) pour documenter les détails relatifs à votre modèle.

Étape 1 : saisissez les détails et l'utilisation prévue du modèle

Si votre modèle est une AWS ressource, spécifiez le nom exact du modèle dans ce champ pour renseigner automatiquement les détails du modèle. Pour parcourir les noms de modèles existants, consultez la section Modèles dans la SageMaker console Amazon. Chaque nom de modèle unique ne peut être associé qu'à une seule fiche modèle.

Si votre modèle n'est pas une AWS ressource, attribuez-lui un nom unique. Pour ajouter un modèle en tant que AWS ressource, consultez la section Créer un modèle dans le manuel Amazon SageMaker Developer Guide. Vous pouvez également ajouter votre modèle en tant que package modèle à l'aide de SageMakerMarketplace ou SageMaker Model Registry.

Pour plus d'informations sur les utilisations prévues, veuillez consulter Utilisations prévues d'un modèle. Pour plus d'informations sur les évaluations de risque, veuillez consulter Évaluations de risque.

Étape 2 : saisissez les détails de l'entraînement

Ajoutez tous les détails de l'entraînement, ses observations, les jeux de données, les hyperparamètres et les détails concernant la fonction d'objectif du modèle pour la fiche modèle.

La fonction d'objectif d'une fiche modèle peut être n'importe quelle fonction optimisée pendant l'entraînement. Cela peut inclure, sans toutefois s'y limiter, des fonctions de coût, des fonctions de perte ou des métriques d'objectif. Dans cette section, documentez la fonction d'objectif la plus essentielle pour l'entraînement de votre modèle.

Nous vous recommandons de cataloguer les attributs suivants de votre fonction d'objectif :

• Direction de l'optimisation

• Métrique

• Description

Par exemple, vous pouvez minimiser (direction de l'optimisation) la perte d'entropie croisée (métrique) pour un problème de classification binaire (description) ou maximiser la probabilité d'une régression logistique. En outre, vous pouvez fournir des notes expliquant pourquoi vous avez choisi cette fonction d'objectif plutôt que d'autres.

Étape 3 : saisissez les détails de l'évaluation

Si vous disposez de rapports d'évaluation existants générés par SageMaker Clarify ou Model Monitor, fournissez un S3 URI pour ces rapports ou téléchargez-les manuellement pour les ajouter à la fiche modèle.

Pour plus d'informations sur SageMaker Clarify, voir Exécuter des tâches de traitement SageMaker Clarify pour l'analyse des biais et l'explicabilité.

Pour plus d'informations sur la surveillance de la dérive des métriques de qualité des modèles à l'aide de Model Monitor, veuillez consulter Surveiller la qualité du modèle.

Pour ajouter votre propre rapport d'évaluation, sélectionnez Generic model card evaluation (Évaluation de la fiche modèle générique). Tous les rapports d'évaluation des fiches modèles doivent figurer dans le JSONSchéma de carte modèle.

Étape 4 : saisissez des informations supplémentaires

Ajoutez des champs de détails de fiche modèle personnalisés pour toute information supplémentaire que vous souhaitez inclure sur votre fiche modèle. Par exemple, vous pouvez inclure le champ personnalisé Line of business (Secteur d'activité) avec la valeur Personal finance (Finances personnelles).

Enregistrer la fiche modèle

Après avoir vérifié les informations de votre fiche modèle, choisissez Save (Enregistrer) dans le coin inférieur droit pour enregistrer votre fiche modèle.

Créez une carte modèle à l'aide du SageMaker Python SDK

Avant de créer une fiche modèle, vous devez d'abord définir son contenu. Lorsque vous utilisez le SageMaker PythonSDK, le contenu du modèle comprend une vue d'ensemble du modèle, les détails de la formation, les utilisations prévues, les détails de l'évaluation et des informations supplémentaires.

Vous pouvez créer des cartes de modèles pour :

• Modèles hébergés dans SageMaker

• Packages de modèles (modèles) dans le registre des SageMaker modèles

• Modèles hébergés ou enregistrés en dehors de SageMaker

Vous pouvez également créer des cartes de modèles sans y associer aucun modèle.

Nous vous recommandons d'ajouter les modèles que vous avez formés au registre des SageMaker modèles. Le registre des modèles vous aide à cataloguer les modèles et à suivre les versions des modèles. Lorsque vous créez une carte de modèle, les informations relatives au modèle provenant du registre des modèles renseignent automatiquement la carte de modèle. Vous pouvez modifier la carte de modèle ou y ajouter des informations après l'avoir créée.

Pour en savoir plus sur le registre des modèles, consultez Déploiement de l'enregistrement des modèles avec le registre des modèles. Pour en savoir plus sur la création d'une carte de modèle à partir d'un registre des modèles, consultez Créez une carte modèle pour votre modèle dans le registre des SageMaker modèles.

Note

Pour utiliser des cartes modèles avec le SageMaker PythonSDK, vous devez d'abord établir une SageMaker session. Pour plus d'informations, consultez Session dans la SDK API référence SageMaker Python.

Pour créer une carte modèle pour les modèles qui ne figurent pas dans le registre des SageMaker modèles, voirCréation d'un modèle qui ne figure pas dans le registre des modèles.

Création d'un modèle qui ne figure pas dans le registre des modèles

Utilisez les informations des sections suivantes pour créer une carte de modèle pour un modèle que vous n'avez pas ajouté au registre des modèles.

Étape 1 : Définir la vue d'ensemble du modèle

Définissez une vue d'ensemble de votre modèle.

model_overview = ModelOverview.from_model_name(
model_name=model_name,
sagemaker_session=sagemaker_session,
model_description="A-description-of-your-model",
problem_type="Problem-type", # For example, "Binary Classification"
algorithm_type="Algorithm-type", # For example, "Logistic Regression"
model_creator="Name-of-model-creator",
model_owner="Name-of-model-owner",
)

Si votre modèle est une AWS ressource, les informations générales telles que le modèleARN, le conteneur URI d'inférence et l'emplacement S3 des artefacts du modèle sont automatiquement récupérables. Imprimez les AWS métadonnées associées à l'aide des commandes suivantes :

print(model_overview.model_id)
print(model_overview.inference_environment.container_image)
print(model_overview.model_artifact)

Étape 2 : Définir les détails d'entraînement

Pour définir les détails d'entraînement de votre modèle, vous devez d'abord définir sa fonction d'objectif.

objective_function = ObjectiveFunction(
    function=Function(
        function=ObjectiveFunctionEnum.MINIMIZE,
        facet=FacetEnum.LOSS,
    ),
    notes="An-explanation-about-objective-function",
)

Vous pouvez ensuite définir les détails de votre entraînement à l'aide de la vue d'ensemble, de la session et de la fonction d'objectif de votre modèle existants. Ajoutez toutes les observations relatives à l'entraînement ici.

training_details = TrainingDetails.from_model_overview(
    model_overview=model_overview,
    sagemaker_session=sagemaker_session,
    objective_function=objective_function,
    training_observations="Model-training-observations",
)

Encore une fois, si votre modèle est une AWS ressource, certains détails de formation sont renseignés automatiquement. Imprimez le travail de formationARN, le conteneur URI de formation et les indicateurs de formation à l'aide des commandes suivantes :

print(training_details.training_job_details.training_arn)
print(training_details.training_job_details.training_environment.container_image) 
print([{"name": i.name, "value": i.value} for i in training_details.training_job_details.training_metrics]) 

Définition des détails de l'évaluation

Pour définir les détails d'évaluation de votre modèle, vous devez d'abord définir un ou plusieurs groupes de métriques afin de décrire celles utilisées pour totes les tâches d'évaluation.

my_metric_group = MetricGroup(
name="binary classification metrics",
metric_data=[Metric(name="accuracy", type=MetricTypeEnum.NUMBER, value=0.5)]
)

Vous pouvez ensuite définir les détails de votre évaluation à l'aide de métriques d'évaluation et de jeux de données pour chaque tâche d'évaluation. Ajoutez ici des observations d'évaluation et attribuez un nom unique à votre tâche d'évaluation.

evaluation_details = [
    EvaluationJob(
        name="Example-evaluation-job",
        evaluation_observation="Evaluation-observations",
        datasets=["s3://path/to/evaluation/data"],
        metric_groups=[my_metric_group],
    )
]

Si vous disposez de rapports d'évaluation existants générés par SageMakerClarify ou SageMaker Model Monitor, téléchargez-les sur Amazon S3 et fournissez un S3 URI pour analyser automatiquement les métriques d'évaluation. Pour ajouter votre propre rapport d'évaluation de carte modèle générique, fournissez un rapport au JSONformat des résultats d'évaluation.

report_type = "clarify_bias.json"
example_evaluation_job.add_metric_group_from_json(
    f"example_metrics/{report_type}", EvaluationMetricTypeEnum.CLARIFY_BIAS
) 

Étape 3 : Définir les utilisations prévues

Définissez les utilisations prévues du modèle, y compris son objectif général et les cas d'utilisation auxquels il était destiné. Il est également recommandé d'inclure tous les facteurs susceptibles de contribuer à l'efficacité de ce modèle dans un cas d'utilisation particulier, ainsi que l'évaluation des risques du modèle par votre organisation. Pour plus d'informations, veuillez consulter Utilisations prévues d'un modèle et Évaluations de risque.

intended_uses = IntendedUses(
purpose_of_model="Purpose-of-the-model",
intended_uses="The-intended-uses-of-this-model",
factors_affecting_model_efficiency="Any-factors-effecting-model-efficacy",
risk_rating=RiskRatingEnum.LOW,
explanations_for_risk_rating="Explanation-for-low-risk-rating",
)

Définition d'informations supplémentaires

Enfin, vous pouvez ajouter d'autres informations personnalisées à votre fiche modèle. Vous pouvez documenter toutes les considérations éthiques, les mises en garde et les recommandations concernant le modèle. Vous pouvez également ajouter les détails personnalisés de votre choix sous la forme de paires clé-valeur.

additional_information = AdditionalInformation(
ethical_considerations="Any-ethical-considerations",
caveats_and_recommendations="Any-caveats-and-recommendations",
custom_details={"custom details1": "details-value"},
)

Étape 4 : Créer une carte de modèle

Nommez votre carte modèle, définissez une carte modèle, puis utilisez cette définition pour créer une carte modèle à l'aide de SageMaker PythonSDK.

model_card_name = "my-model-card"
my_card = ModelCard(
    name=model_card_name,
    status=ModelCardStatusEnum.DRAFT,
    model_overview=model_overview,
    training_details=training_details,
    intended_uses=intended_uses,
    evaluation_details=evaluation_details,
    additional_information=additional_information,
    sagemaker_session=sagemaker_session,
)
my_card.create()

Créez une carte modèle pour votre modèle dans le registre des SageMaker modèles

Avant de commencer à créer une carte modèle, assurez-vous d'avoir créé un groupe de packages de modèles et un package de modèles. Pour plus d'informations sur l'utilisation du registre des modèles, consultez Déploiement de l'enregistrement des modèles avec le registre des modèles.

Important

Vous devez disposer des autorisations nécessaires pour utiliser les opérations dans SageMaker Model Registry. Nous vous recommandons d'utiliser une politique AmazonSageMakerModelRegistryFullAccess AWS gérée. Pour plus d’informations sur la stratégie gérée, consultez AWS Politiques gérées pour le registre des modèles.

Utilisez le SageMaker Python SDK pour créer une carte modèle pour un package de modèles dans le SageMaker Model Registry. Un package de modèles est un modèle que vous avez entraîné. Lorsque vous créez un modèle de carte, Amazon SageMaker Model Cards importe automatiquement les données du modèle d'emballage dans le modèle de carte.

Lorsque vous créez une carte modèle pour un modèle de package, Amazon SageMaker Model Card utilise cette DescribeModelPackageopération pour ajouter les données du modèle de package à la carte modèle. Voici des exemples de champs qui peuvent être importés d'un package de modèles dans une carte de modèle :

• ModelDataUrl

• ModelPackageDescription

• ModelPackageGroupName

• ModelPackageStatus

• ModelPackageVersion

Utilisez le code suivant pour définir le package de modèles et créer une carte de modèle à partir de celui-ci :

mp_details = ModelPackage.from_model_package_arn(
    model_package_arn="example_model_package_arn",
    sagemaker_session=sagemaker_session,
)

model_card_name = "example-model-card"
my_card = ModelCard(
    name=model_card_name,
    status=ModelCardStatusEnum.status,
    model_package_details=mp_details,
    sagemaker_session=sagemaker_session,
)
my_card.create()
            

Pour status, vous spécifiez le statut d'approbation de la carte de modèle. Si vous ne spécifiez aucun statut, SageMaker Model Cards utilise la valeur par défaut deDRAFT. Si vous ne spécifiez pas de SageMaker session, SageMaker Model Cards utilise la SageMaker session par défaut.

Vous devez spécifier un nom pour le modèle et le nom de ressource Amazon (ARN) du package modèle. Pour plus d'informations sur l'obtention du nom de ressource Amazon (ARN) pour le modèle de package, consultezAfficher et mettre à jour les détails d'une version de modèle (Boto3).

La carte de modèle que vous avez créée à partir du package de modèles peut contenir des informations manquantes ou inexactes. Vous pouvez ajouter des informations à la carte de modèle ou la modifier. Pour plus d'informations sur la gestion de vos cartes de modèles, consultez Actions de cartes modèles.

SageMaker Model Registry prend en charge la gestion des versions de vos packages de modèles. Vous pouvez versionner votre package de modèles et créer une carte de modèle pour chaque version. Les informations issues des cartes de modèles des versions précédentes sont reportées dans les cartes de modèles créées à partir des versions suivantes. Par exemple, vous pourriez avoir la version 1, la version 2 et la version 3 d'un package de modèles. Supposons que vous ayez déjà créé une carte de modèle pour la version 1, mais que vous n'en ayez pas créé pour la version 2. Si vous créez un modèle de carte pour la version 3, Amazon SageMaker Model Cards transfère automatiquement les informations du modèle de carte pour la version 1 vers le modèle de carte pour la version 3.

Note

Vous pouvez également créer des cartes de modèles pour les packages de modèles qui n'utilisent pas la gestion des versions. Toutefois, la plupart des flux de travail de machine learning impliquent plusieurs versions du même modèle. Nous vous recommandons donc de procéder comme suit :

1. Créez une version pour chaque package de modèles.

2. Créez une carte de modèle pour chaque version du package de modèles.