Entraînement d’un modèle (console)Entraînement d’un modèle (kit SDK)

Entraînement d’un modèle Étiquettes personnalisées Amazon Rekognition

Vous pouvez entraîner un modèle à l’aide de la console Étiquettes personnalisées Amazon Rekognition ou de l’API Étiquettes personnalisées Amazon Rekognition. Si l’entraînement du modèle échoue, utilisez les informations de la section Débogage d’un entraînement de modèle en échec pour trouver la cause de cet échec.

Note

Le temps nécessaire à l’entraînement d’un modèle vous est facturé. L’entraînement dure généralement de 30 minutes à 24 heures. Pour plus d’informations, consultez Heures d’entraînement.

Une nouvelle version du modèle est créée chaque fois que celui-ci est entraîné. Étiquettes personnalisées Amazon Rekognition crée un nom pour le modèle. Ce nom combine le nom du projet et la date de création du modèle.

Pour entraîner votre modèle, Étiquettes personnalisées Amazon Rekognition crée une copie de vos images d’entraînement et de test source. Par défaut, les images copiées sont chiffrées au repos à l’aide d’une clé détenue et gérée par AWS. Vous pouvez également choisir d’utiliser votre propre AWS KMS key. Si vous utilisez votre propre clé KMS, vous devez disposer des autorisations suivantes sur la clé KMS.

km : CreateGrant
km : DescribeKey

Pour plus d’informations, consultez Concepts d’AWS Key Management Service. Vos images source ne sont pas affectées.

Vous pouvez utiliser le chiffrement côté serveur KMS (SSE-KMS) pour chiffrer les images d’entraînement et de test de votre compartiment Amazon S3, avant qu’elles ne soient copiées par Étiquettes personnalisées Amazon Rekognition. Pour autoriser les étiquettes personnalisées Amazon Rekognition à accéder à vos images AWS , votre compte doit disposer des autorisations suivantes sur la clé KMS.

km : GenerateDataKey
kms:Decrypt

Pour plus d’informations, consultez Utilisation du chiffrement côté serveur avec des clés AWS KMS (SSE-KMS).

Une fois que vous avez entraîné un modèle, vous pouvez évaluer ses performances et l’améliorer. Pour plus d’informations, consultez Amélioration d’un modèle entraîné Étiquettes personnalisées Amazon Rekognition.

Pour connaître les autres tâches possibles avec un modèle, telles que le balisage, consultez Gestion d'un modèle Amazon Rekognition Custom Labels.

Entraînement d’un modèle (console)

Vous pouvez utiliser la console Étiquettes personnalisées Amazon Rekognition pour entraîner un modèle.

L’entraînement nécessite un projet comprenant un jeu de données d’entraînement et un jeu de données de test. Si votre projet ne dispose pas d’un jeu de données de test, la console Étiquettes personnalisées Amazon Rekognition divise le jeu de données d’entraînement pendant l’entraînement afin d’en créer un pour votre projet. Les images choisies constituent un échantillon représentatif et ne sont pas utilisées dans le jeu de données d’entraînement. Nous vous recommandons de diviser votre jeu de données d’entraînement uniquement si vous ne disposez pas d’un jeu de données de test que vous pouvez utiliser. La division d’un jeu de données d’entraînement réduit le nombre d’images disponibles pour l’entraînement.

Note

Le temps nécessaire à l’entraînement d’un modèle vous est facturé. Pour plus d’informations, consultez Heures d’entraînement.

Pour entraîner votre modèle (console)

Ouvrez la console Amazon Rekognition à l’adresse https://console.aws.amazon.com/rekognition/.
Choisissez Utiliser Custom Labels.
Dans le volet de navigation de gauche, choisissez Projets.
Sur la page Projets, choisissez le projet qui contient le modèle que vous souhaitez entraîner.
Sur la page Projet, sélectionnez Entraîner un modèle.
(Facultatif) Si vous souhaitez utiliser votre propre clé de chiffrement AWS KMS, procédez comme suit :
1. Dans Chiffrement des données d’image, choisissez Personnaliser les paramètres de chiffrement (avancé).
2. Dans encryption.aws_kms_key, saisissez l’Amazon Resource Name (ARN) de votre clé, ou choisissez une clé AWS KMS existante. Pour créer une clé, choisissez Créer une clé AWS KMS.
(Facultatif) Si vous souhaitez ajouter des balises à votre modèle, procédez comme suit :
1. Dans la section Balises, choisissez Ajouter une balise.
2. Saisissez :
  1. Le nom de la clé dans le champ Clé.
  2. La valeur de la clé dans le champ Valeur.
3. Pour ajouter d’autres balises, répétez les étapes 6a et 6b.
4. (Facultatif) Si vous souhaitez supprimer une balise, choisissez Supprimer en regard de la balise que vous souhaitez supprimer. Si vous supprimez une balise précédemment enregistrée, elle sera supprimée lorsque vous enregistrerez vos modifications.
Sur la page Entraîner un modèle, choisissez Entraîner un modèle. L’Amazon Resource Name (ARN) de votre projet doit se trouver dans la zone d’édition Choisir un projet. Dans le cas contraire, saisissez l’ARN de votre projet.
Dans la boîte de dialogue Voulez-vous entraîner votre modèle ?, choisissez Entraîner un modèle.
Dans la section Modèles de la page du projet, vous pouvez vérifier si l’entraînement est en cours dans la colonne Model Status. L’entraînement d’un modèle peut nécessiter un certain temps.
Une fois l’entraînement terminé, choisissez le nom du modèle. L’entraînement est terminé lorsque le statut du modèle est TRAINING_COMPLETED. En cas d’échec de l’entraînement, consultez Débogage d’un entraînement de modèle en échec.
Étape suivante : Évaluer votre modèle. Pour plus d’informations, consultez Amélioration d’un modèle entraîné Étiquettes personnalisées Amazon Rekognition.

Entraînement d’un modèle (kit SDK)

Vous entraînez un mannequin en appelant CreateProjectVersion. Pour entraîner un modèle, les informations suivantes sont nécessaires :

Nom : nom unique de la version du modèle.
ARN du projet : Amazon Resource Name (ARN) du projet qui gère le modèle.
Emplacement des résultats de l’entraînement : emplacement du compartiment Amazon S3 dans lequel les résultats de l’entraînement sont enregistrés. Vous pouvez utiliser l’emplacement du compartiment Amazon S3 de la console ou choisir un autre emplacement. Nous vous recommandons de choisir un autre emplacement, car cela vous permet de définir des autorisations et d’éviter d’éventuels conflits d’appellation avec les résultats d’entraînement obtenus à l’aide de la console Étiquettes personnalisées Amazon Rekognition.

L’entraînement utilise les jeux de données d’entraînement et de test associés au projet. Pour plus d’informations, consultez Gestion des jeux de données.

Note

Vous pouvez éventuellement spécifier des fichiers manifestes de jeux de données d’entraînement et de test qui sont externes à un projet. Si vous ouvrez la console après avoir entraîné un modèle avec des fichiers manifestes externes, Étiquettes personnalisées Amazon Rekognition crée les jeux de données pour vous en utilisant le dernier jeu de fichiers manifestes utilisé pour l’entraînement. Vous ne pouvez plus entraîner une version de modèle pour le projet en spécifiant des fichiers manifestes externes. Pour plus d'informations, consultez CreatePrjectVersion.

La réponse de CreateProjectVersion est un ARN que vous utilisez pour identifier la version du modèle dans les demandes ultérieures. Vous pouvez également utiliser l’ARN pour sécuriser la version du modèle. Pour plus d’informations, consultez Sécurisation des projets d'étiquettes personnalisées Amazon Rekognition.

L’entraînement d’une version de modèle peut nécessiter un certain temps. Les exemples Python et Java présentés dans cette section utilisent des programmes d’attente pour attendre la fin de l’entraînement. Un programme d’attente est un utilitaire qui attend qu’un statut particulier survienne. Vous pouvez également obtenir le statut actuel de l’entraînement en appelant DescribeProjectVersions. L’entraînement est terminé lorsque la valeur du champ Status est TRAINING_COMPLETED. Une fois l’entraînement terminé, vous pouvez évaluer la qualité du modèle en passant en revue les résultats de l’évaluation.

Entraînement d’un modèle (kit SDK)

L’exemple suivant explique comment entraîner un modèle en utilisant les jeux de données d’entraînement et de test associés à un projet.

Pour entraîner un modèle (kit SDK)

Si ce n'est pas déjà fait, installez et configurez les AWS CLI AWS SDK. Pour plus d’informations, consultez Étape 4 : Configuration des AWS SDK AWS CLI et.

Utilisez l’exemple de code suivant pour entraîner un projet.

AWS CLI

L’exemple suivant crée un modèle. Le jeu de données d’entraînement est divisé pour créer le jeu de données de test. Remplacez les éléments suivants :

my_project_arn par l’Amazon Resource Name (ARN) du projet.
version_name par un nom de version unique de votre choix.
output_bucket par le nom du compartiment Amazon S3 dans lequel Étiquettes personnalisées Amazon Rekognition enregistre les résultats de l’entraînement.
output_folder par le nom du dossier dans lequel les résultats de l’entraînement sont enregistrés.
(Paramètre facultatif) --kms-key-id par l’identifiant de votre clé principale client AWS Key Management Service.


aws rekognition create-project-version \
  --project-arn project_arn \
  --version-name version_name \
  --output-config '{"S3Bucket":"output_bucket", "S3KeyPrefix":"output_folder"}' \
  --profile custom-labels-access

Python

L’exemple suivant crée un modèle. Fournissez les arguments de ligne de commande suivants :

project_arn : Amazon Resource Name (ARN) du projet.
version_name : nom de version unique pour le modèle de votre choix.
output_bucket : nom du compartiment Amazon S3 dans lequel Étiquettes personnalisées Amazon Rekognition enregistre les résultats de l’entraînement.
output_folder : nom du dossier dans lequel les résultats de l’entraînement sont enregistrés.

Vous pouvez éventuellement fournir les paramètres de ligne de commande suivants pour associer une balise à votre modèle :

tag : nom de la balise que vous souhaitez associer au modèle.
tag_value : valeur de la balise.


#Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)


import argparse
import logging
import json
import boto3

from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)

def train_model(rek_client, project_arn, version_name, output_bucket, output_folder, tag_key, tag_key_value):
    """
    Trains an Amazon Rekognition Custom Labels model.
    :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
    :param project_arn: The ARN of the project in which you want to train a model.
    :param version_name: A version for the model.
    :param output_bucket: The S3 bucket that hosts training output.
    :param output_folder: The path for the training output within output_bucket
    :param tag_key: The name of a tag to attach to the model. Pass None to exclude
    :param tag_key_value: The value of the tag. Pass None to exclude

    """

    try:
        #Train the model

        status=""
        logger.info("training model version %s for project %s",
            version_name, project_arn)


        output_config = json.loads(
            '{"S3Bucket": "'
            + output_bucket
            + '", "S3KeyPrefix": "'
            + output_folder
            + '" }  '
        )

        tags={}

        if tag_key is not None and tag_key_value is not None:
            tags = json.loads(
                '{"' + tag_key + '":"' + tag_key_value + '"}'
            )


        response=rek_client.create_project_version(
            ProjectArn=project_arn, 
            VersionName=version_name,
            OutputConfig=output_config,
            Tags=tags
        )

        logger.info("Started training: %s", response['ProjectVersionArn'])

        # Wait for the project version training to complete.

        project_version_training_completed_waiter = rek_client.get_waiter('project_version_training_completed')
        project_version_training_completed_waiter.wait(ProjectArn=project_arn,
        VersionNames=[version_name])
    

        # Get the completion status.
        describe_response=rek_client.describe_project_versions(ProjectArn=project_arn,
            VersionNames=[version_name])
        for model in describe_response['ProjectVersionDescriptions']:
            logger.info("Status: %s", model['Status'])
            logger.info("Message: %s", model['StatusMessage'])
            status=model['Status']


        logger.info("finished training")

        return response['ProjectVersionArn'], status
    
    except ClientError as err:
        logger.exception("Couldn't create model: %s", err.response['Error']['Message'] )
        raise

def add_arguments(parser):
    """
    Adds command line arguments to the parser.
    :param parser: The command line parser.
    """

    parser.add_argument(
        "project_arn", help="The ARN of the project in which you want to train a model"
    )

    parser.add_argument(
        "version_name", help="A version name of your choosing."
    )

    parser.add_argument(
        "output_bucket", help="The S3 bucket that receives the training results."
    )

    parser.add_argument(
        "output_folder", help="The folder in the S3 bucket where training results are stored."
    )

    parser.add_argument(
        "--tag_name",  help="The name of a tag to attach to the model", required=False
    )

    parser.add_argument(
        "--tag_value",  help="The value for the tag.", required=False
    )




def main():

    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")

    try:

        # Get command line arguments.
        parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
        add_arguments(parser)
        args = parser.parse_args()

        print(f"Training model version {args.version_name} for project {args.project_arn}")

        # Train the model.
        session = boto3.Session(profile_name='custom-labels-access')
        rekognition_client = session.client("rekognition")

        model_arn, status=train_model(rekognition_client, 
            args.project_arn,
            args.version_name,
            args.output_bucket,
            args.output_folder,
            args.tag_name,
            args.tag_value)


        print(f"Finished training model: {model_arn}")
        print(f"Status: {status}")


    except ClientError as err:
        logger.exception("Problem training model: %s", err)
        print(f"Problem training model: {err}")
    except Exception as err:
        logger.exception("Problem training model: %s", err)
        print(f"Problem training model: {err}")


if __name__ == "__main__":
    main()

Java V2

L’exemple suivant entraîne un modèle. Fournissez les arguments de ligne de commande suivants :

project_arn : Amazon Resource Name (ARN) du projet.
version_name : nom de version unique pour le modèle de votre choix.
output_bucket : nom du compartiment Amazon S3 dans lequel Étiquettes personnalisées Amazon Rekognition enregistre les résultats de l’entraînement.
output_folder : nom du dossier dans lequel les résultats de l’entraînement sont enregistrés.


/*
   Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;

import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CreateProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;

import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;

public class TrainModel {

    public static final Logger logger = Logger.getLogger(TrainModel.class.getName());

    public static String trainMyModel(RekognitionClient rekClient, String projectArn, String versionName,
            String outputBucket, String outputFolder) {

        try {

            OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();

            logger.log(Level.INFO, "Training Model for project {0}", projectArn);
            CreateProjectVersionRequest createProjectVersionRequest = CreateProjectVersionRequest.builder()
                    .projectArn(projectArn).versionName(versionName).outputConfig(outputConfig).build();

            CreateProjectVersionResponse response = rekClient.createProjectVersion(createProjectVersionRequest);

            logger.log(Level.INFO, "Model ARN: {0}", response.projectVersionArn());
            logger.log(Level.INFO, "Training model...");

            // wait until training completes

            DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
                    .versionNames(versionName)
                    .projectArn(projectArn)
                    .build();

            RekognitionWaiter waiter = rekClient.waiter();

            WaiterResponse<DescribeProjectVersionsResponse> waiterResponse = waiter
                    .waitUntilProjectVersionTrainingCompleted(describeProjectVersionsRequest);

            Optional<DescribeProjectVersionsResponse> optionalResponse = waiterResponse.matched().response();

            DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();

            for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
                    .projectVersionDescriptions()) {
                System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
                System.out.println("Status: " + projectVersionDescription.statusAsString());
                System.out.println("Message: " + projectVersionDescription.statusMessage());
            }

            return response.projectVersionArn();

        } catch (RekognitionException e) {
            logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
            throw e;
        }

    }

    public static void main(String args[]) {

        String versionName = null;
        String projectArn = null;
        String projectVersionArn = null;
        String bucket = null;
        String location = null;

        final String USAGE = "\n" + "Usage: " + "<project_name> <version_name> <output_bucket> <output_folder>\n\n" + "Where:\n"
                + "   project_arn - The ARN of the project that you want to use. \n\n"
                + "   version_name - A version name for the model.\n\n"
                + "   output_bucket - The S3 bucket in which to place the training output. \n\n"
                + "   output_folder - The folder within the bucket that the training output is stored in. \n\n";

        if (args.length != 4) {
            System.out.println(USAGE);
            System.exit(1);
        }

        projectArn = args[0];
        versionName = args[1];
        bucket = args[2];
        location = args[3];

        try {

            // Get the Rekognition client.
            RekognitionClient rekClient = RekognitionClient.builder()
            .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
            .region(Region.US_WEST_2)
            .build();


            // Train model
            projectVersionArn = trainMyModel(rekClient, projectArn, versionName, bucket, location);

            System.out.println(String.format("Created model: %s for Project ARN: %s", projectVersionArn, projectArn));

            rekClient.close();

        } catch (RekognitionException rekError) {
            logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
            System.exit(1);
        }

    }

}

En cas d’échec de l’entraînement, consultez Débogage d’un entraînement de modèle en échec.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Erreurs non définitives

Débogage d’un entraînement de modèle