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

Entraînement de votre modèle

Après avoir créé vos ensembles de données et étiqueté les images, vous pouvez entraîner votre modèle. Dans le cadre du processus de formation, un ensemble de données de test est utilisé. Si vous avez un seul projet de jeu de données, les images du jeu de données sont automatiquement divisées en un ensemble de données de test et un ensemble de données d'apprentissage dans le cadre du processus de formation. Si votre projet comporte un ensemble de données d'entraînement et un ensemble de données de test, ils sont utilisés pour entraîner et tester séparément l'ensemble de données.

Une fois l'entraînement terminé, vous pouvez évaluer les performances du modèle et apporter les améliorations nécessaires. Pour de plus amples informations, veuillez consulter Amélioration de votre modèle Amazon Lookout for Vision.

Pour entraîner votre modèle, Amazon Lookout for Vision crée une copie de vos images d'entraînement et de test source. Par défaut, les images copiées sont chiffrées à l'aide d'une clé qui les AWS possède et les gère. Vous pouvez également choisir d'utiliser votre propre AWS clé de service de gestion des clés (KMS). Pour plus d'informations, consultez la section Concepts du service de gestion des AWS clés. Vos images sources ne sont pas affectées.

Vous pouvez attribuer des métadonnées à votre modèle sous forme de balises. Pour de plus amples informations, veuillez consulter Modèles de balisage.

Chaque fois que vous entraînez un modèle, une nouvelle version du modèle est créée. Si vous n'avez plus besoin de la version d'un modèle, vous pouvez le supprimer. Pour de plus amples informations, veuillez consulter Suppression d'un modèle.

Le temps nécessaire pour entraîner avec succès votre modèle vous est facturé. Pour plus d'informations, consultez la section Heures de formation.

Pour afficher les modèles existants dans un projet,Visualisation de vos modèles.

Note

Si vous venez de terminer Création de votre jeu de données ouAjouter des images à votre jeu de données. La console devrait actuellement afficher le tableau de bord de votre modèle et vous n'avez pas besoin de suivre les étapes 1 à 4.

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

La procédure suivante explique comment entraîner votre modèle à l'aide de la console.

Pour entraîner votre modèle (console)

Ouvrez la console Amazon Lookout for Vision à l'adresse. https://console.aws.amazon.com/lookoutvision/
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 des détails du projet, choisissez Train model. Le bouton Train model est disponible si vous disposez de suffisamment d'images étiquetées pour entraîner le modèle. Si le bouton n'est pas disponible, ajoutez d'autres images jusqu'à ce que vous ayez suffisamment d'images étiquetées.
(Facultatif) Si vous souhaitez utiliser votre propre clé de AWS KMS chiffrement, 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, entrez le nom de ressource Amazon ARN () de votre clé ou choisissez une clé existante. AWS KMS Pour créer une nouvelle clé, choisissez Créer une AWS IMS clé.
(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.
Choisissez Train model (Entraîner un modèle).
Dans la boîte de dialogue Voulez-vous entraîner votre modèle ?, choisissez Entraîner un modèle.
Dans la vue Modèles, vous pouvez voir que l'entraînement a commencé et vous pouvez vérifier l'état actuel en consultant la Status colonne correspondant à la version du modèle. L’entraînement d’un modèle peut nécessiter un certain temps.
Lorsque l'entraînement est terminé, vous pouvez évaluer ses performances. Pour de plus amples informations, veuillez consulter Amélioration de votre modèle Amazon Lookout for Vision.

Entraînement d'un modèle (SDK)

Vous utilisez cette CreateModelopération pour démarrer l'entraînement, le test et l'évaluation d'un modèle. Amazon Lookout for Vision entraîne le modèle à l'aide de l'ensemble de données de formation et de test associé au projet. Pour de plus amples informations, veuillez consulter Création d'un projet (SDK).

Chaque fois que vous appelezCreateModel, une nouvelle version du modèle est créée. Le formulaire de réponse CreateModel inclut la version du modèle.

Vous êtes facturé pour chaque modèle de formation réussie. Utilisez le paramètre ClientToken d'entrée pour éviter les frais dus à des répétitions inutiles ou accidentelles de l'entraînement du modèle par vos utilisateurs. ClientTokenest un paramètre d'entrée idempotent qui garantit que l'entraînement n'est pas terminé une CreateModel seule fois pour un ensemble spécifique de paramètres. Un appel répété CreateModel avec la même ClientToken valeur garantit que l'entraînement n'est pas répété. Si vous ne fournissez aucune valeur pourClientToken, le fichier AWS SDK que vous utilisez insère une valeur pour vous. Cela empêche les nouvelles tentatives après une erreur réseau de démarrer plusieurs tâches de formation, mais vous devrez fournir votre propre valeur pour vos propres cas d'utilisation. Pour plus d'informations, consultez CreateModel.

L’entraînement prend un certain temps. Pour vérifier l'état actuel, appelez DescribeModel et transmettez le nom du projet (spécifié dans l'appel àCreateProject) et la version du modèle. Le status champ indique l'état actuel de l'entraînement du modèle. Pour obtenir un exemple de code, consultez Affichage de vos modèles (SDK).

Si la formation est réussie, vous pouvez évaluer le modèle. Pour de plus amples informations, veuillez consulter Amélioration de votre modèle Amazon Lookout for Vision.

Pour afficher les modèles que vous avez créés dans un projet, appelezListModels. Pour obtenir un exemple de code, consultez Visualisation de vos modèles.

Pour entraîner un modèle (SDK)

Si ce n'est pas déjà fait, installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter Étape 4 : Configuration des AWS SDK AWS CLI et.

Utilisez l'exemple de code suivant pour entraîner un modèle.

CLI

Remplacez les valeurs suivantes :

project-nameau nom du projet qui contient le modèle que vous souhaitez créer.
output-configà l'endroit où vous souhaitez enregistrer les résultats de l'entraînement. Remplacez les valeurs suivantes :
- output bucketavec le nom du compartiment Amazon S3 dans lequel Amazon Lookout for Vision enregistre les résultats de formation.
- output folderavec le nom du dossier dans lequel vous souhaitez enregistrer les résultats de l'entraînement.
- Keyavec le nom d'une clé de tag.
- Valueavec une valeur à associertag_key.


aws lookoutvision create-model --project-name "project name"\
  --output-config '{ "S3Location": { "Bucket": "output bucket", "Prefix":  "output folder" } }'\
  --tags '[{"Key":"Key","Value":"Value"}]' \
  --profile lookoutvision-access

Python

Ce code est extrait du GitHub référentiel d'SDKexemples de AWS documentation. Voir l’exemple complet ici.


    @staticmethod
    def create_model(
        lookoutvision_client,
        project_name,
        training_results,
        tag_key=None,
        tag_key_value=None,
    ):
        """
        Creates a version of a Lookout for Vision model.

        :param lookoutvision_client: A Boto3 Lookout for Vision client.
        :param project_name: The name of the project in which you want to create a
                             model.
        :param training_results: The Amazon S3 location where training results are stored.
        :param tag_key: The key for a tag to add to the model.
        :param tag_key_value - A value associated with the tag_key.
        return: The model status and version.
        """
        try:
            logger.info("Training model...")
            output_bucket, output_folder = training_results.replace("s3://", "").split(
                "/", 1
            )
            output_config = {
                "S3Location": {"Bucket": output_bucket, "Prefix": output_folder}
            }
            tags = []
            if tag_key is not None:
                tags = [{"Key": tag_key, "Value": tag_key_value}]

            response = lookoutvision_client.create_model(
                ProjectName=project_name, OutputConfig=output_config, Tags=tags
            )

            logger.info("ARN: %s", response["ModelMetadata"]["ModelArn"])
            logger.info("Version: %s", response["ModelMetadata"]["ModelVersion"])
            logger.info("Started training...")

            print("Training started. Training might take several hours to complete.")

            # Wait until training completes.
            finished = False
            status = "UNKNOWN"
            while finished is False:
                model_description = lookoutvision_client.describe_model(
                    ProjectName=project_name,
                    ModelVersion=response["ModelMetadata"]["ModelVersion"],
                )
                status = model_description["ModelDescription"]["Status"]

                if status == "TRAINING":
                    logger.info("Model training in progress...")
                    time.sleep(600)
                    continue

                if status == "TRAINED":
                    logger.info("Model was successfully trained.")
                else:
                    logger.info(
                        "Model training failed: %s ",
                        model_description["ModelDescription"]["StatusMessage"],
                    )
                finished = True
        except ClientError:
            logger.exception("Couldn't train model.")
            raise
        else:
            return status, response["ModelMetadata"]["ModelVersion"]

Java V2

Ce code est extrait du GitHub référentiel d'SDKexemples de AWS documentation. Voir l’exemple complet ici.


/**
 * Creates an Amazon Lookout for Vision model. The function returns after model
 * training completes. Model training can take multiple hours to complete.
 * You are charged for the amount of time it takes to successfully train a model.
 * Returns after Lookout for Vision creates the dataset.
 * 
 * @param lfvClient   An Amazon Lookout for Vision client.
 * @param projectName The name of the project in which you want to create a
 *                    model.
 * @param description A description for the model.
 * @param bucket      The S3 bucket in which Lookout for Vision stores the
 *                    training results.
 * @param folder      The location of the training results within the S3
 *                    bucket.
 * @return ModelDescription The description of the created model.
 */
public static ModelDescription createModel(LookoutVisionClient lfvClient, String projectName,
                String description, String bucket, String folder)
                throws LookoutVisionException, InterruptedException {

        logger.log(Level.INFO, "Creating model for project: {0}.", new Object[] { projectName });

        // Setup input parameters.
        S3Location s3Location = S3Location.builder()
                        .bucket(bucket)
                        .prefix(folder)
                        .build();

        OutputConfig config = OutputConfig.builder()
                        .s3Location(s3Location)
                        .build();

        CreateModelRequest createModelRequest = CreateModelRequest.builder()
                        .projectName(projectName)
                        .description(description)
                        .outputConfig(config)
                        .build();

        // Create and train the model.
        CreateModelResponse response = lfvClient.createModel(createModelRequest);

        String modelVersion = response.modelMetadata().modelVersion();
        boolean finished = false;
        DescribeModelResponse descriptionResponse = null;

        // Wait until training finishes or fails.

        do {
                DescribeModelRequest describeModelRequest = DescribeModelRequest.builder()
                                .projectName(projectName)
                                .modelVersion(modelVersion)
                                .build();

                descriptionResponse = lfvClient.describeModel(describeModelRequest);

                switch (descriptionResponse.modelDescription().status()) {
                        case TRAINED:
                                logger.log(Level.INFO, "Model training completed for project {0} version {1}.",
                                                new Object[] { projectName, modelVersion });
                                finished = true;
                                break;

                        case TRAINING:
                                logger.log(Level.INFO,
                                                "Model training in progress for project {0} version {1}.",
                                                new Object[] { projectName, modelVersion });
                                TimeUnit.SECONDS.sleep(60);

                                break;

                        case TRAINING_FAILED:
                                logger.log(Level.SEVERE,
                                                "Model training failed for for project {0} version {1}.",
                                                new Object[] { projectName, modelVersion });
                                finished = true;
                                break;

                        default:
                                logger.log(Level.SEVERE,
                                                "Unexpected error when training model project {0} version {1}: {2}.",
                                                new Object[] { projectName, modelVersion,
                                                                descriptionResponse.modelDescription()
                                                                                .status() });
                                finished = true;
                                break;

                }
        } while (!finished);

        return descriptionResponse.modelDescription();

}

Lorsque l'entraînement est terminé, vous pouvez évaluer ses performances. Pour de plus amples informations, veuillez consulter Amélioration de votre modèle Amazon Lookout for Vision.

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

Segmentation d'images (console)

Modèle de résolution des problèmes