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. # Exécution d’un modèle Étiquettes personnalisées Amazon Rekognition entraîné Lorsque vous êtes satisfait des performances du modèle, vous pouvez commencer à l’utiliser. Vous pouvez démarrer et arrêter un modèle à l'aide de la console ou du AWS SDK. La console inclut également des exemples d’opérations du kit SDK que vous pouvez utiliser. **Topics** + [Unités d’inférence](#running-model-inference-units) + [Zones de disponibilité](#running-model-availability-zones) + [Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition](rm-start.md) + [Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition](rm-stop.md) + [Rapport sur la durée d’exécution et les unités d’inférence utilisées](rm-model-usage.md) ## Unités d’inférence Lorsque vous démarrez votre modèle, vous spécifiez le nombre de ressources de calcul, appelées unités d’inférence, utilisées par le modèle. **Important** Vous êtes facturé en fonction du nombre d’heures d’exécution de votre modèle et du nombre d’unités d’inférence qu’il utilise pendant son exécution, en fonction de la façon dont vous configurez l’exécution de votre modèle. Par exemple, si vous démarrez le modèle avec deux unités d’inférence et que vous l’utilisez pendant 8 heures, 16 heures d’inférence vous sont facturées (8 heures d’exécution \$1 deux unités d’inférence). Pour plus d’informations, consultez [Heures d’inférence](https://aws.amazon.com/rekognition/pricing/#Amazon_Rekognition_Custom_Labels_pricing). Si vous n’[arrêtez pas explicitement votre modèle](rm-stop.md), des frais vous seront facturés même si vous n’analysez pas activement les images avec votre modèle. Les transactions par seconde (TPS) prises en charge par une seule unité d’inférence sont affectées par les facteurs suivants. + Un modèle qui détecte des étiquettes au niveau de l’image (classification) a généralement un nombre TPS plus élevé qu’un modèle qui détecte et localise des objets à l’aide de cadres de délimitation (détection d’objets). + La complexité du modèle. + Une image avec une résolution plus élevée nécessite plus de temps pour l’analyse. + Un plus grand nombre d’objets dans une image nécessite plus de temps pour l’analyse. + Les petites images sont analysées plus rapidement que les images plus grandes. + Une image transmise sous forme d’octets d’image est analysée plus rapidement que lorsque vous l’avez d’abord téléchargée dans un compartiment Amazon S3, puis que vous la référencez. Les images transmises sous forme d’octets d’image doivent avoir une taille inférieure à 4 Mo. Nous vous recommandons d’utiliser des octets d’image pour le traitement des images en temps quasi réel et lorsque la taille de l’image est inférieure à 4 Mo. Par exemple, des images capturées par une caméra IP. + Le traitement des images stockées dans un compartiment Amazon S3 est plus rapide que de télécharger des images, les convertir en octets d’image, puis les transmettre à des fins d’analyse. + L’analyse d’une image déjà stockée dans un compartiment Amazon S3 est probablement plus rapide que d’analyser la même image transmise sous forme d’octets d’image. Cela est particulièrement vrai si la taille de l’image est plus grande. Si le nombre d’appels à `DetectCustomLabels` dépasse le nombre TPS maximum pris en charge par la somme des unités d’inférence utilisées par un modèle, Étiquettes personnalisées Amazon Rekognition renvoie une exception `ProvisionedThroughputExceededException`. ### Gestion du débit à l’aide d’unités d’inférence Vous pouvez augmenter ou diminuer le débit de votre modèle en fonction des exigences de votre application. Pour augmenter le débit, utilisez des unités d’inférence supplémentaires. Chaque unité d’inférence supplémentaire augmente votre vitesse de traitement d’une unité d’inférence. Pour plus d’informations sur le calcul du nombre d’unités d’inférence dont vous avez besoin, consultez [Calculate inference units for Amazon Rekognition Custom Labels and Amazon Lookout for Vision models](https://aws.amazon.com/blogs/machine-learning/calculate-inference-units-for-an-amazon-rekognition-custom-labels-model/). Si vous souhaitez modifier le débit pris en charge par votre modèle, deux options s’offrent à vous : #### Ajout ou suppression des unités d’inférence manuellement [Arrêtez](rm-stop.md) le modèle, puis [redémarrez-le](rm-start.md) avec le nombre d’unités d’inférence requis. L’inconvénient de cette approche est que le modèle ne peut pas recevoir de demandes pendant le redémarrage et qu’il ne peut pas être utilisé pour gérer les pics de demande. Utilisez cette approche si le débit de votre modèle est stable et que votre cas d’utilisation peut tolérer 10 à 20 minutes d’indisponibilité. Par exemple, si vous souhaitez effectuer des appels groupés vers votre modèle selon un calendrier hebdomadaire. #### Mise à l’échelle automatique d’unités d’inférence Si votre modèle doit faire face à des pics de demande, la fonctionnalité Étiquettes personnalisées Amazon Rekognition peut automatiquement mettre à l’échelle le nombre d’unités d’inférence utilisées par votre modèle. À mesure que la demande augmente, la fonctionnalité Étiquettes personnalisées Amazon Rekognition ajoute des unités d’inférence supplémentaires au modèle et les supprime lorsque la demande diminue. Pour permettre à Étiquettes personnalisées Amazon Rekognition de mettre à l’échelle automatiquement les unités d’inférence d’un modèle, [démarrez](rm-start.md) le modèle et définissez le nombre maximum d’unités d’inférence qu’il peut utiliser à l’aide du paramètre `MaxInferenceUnits`. La définition d’un nombre maximum d’unités d’inférence vous permet de gérer le coût d’exécution du modèle en limitant le nombre d’unités d’inférence disponibles. Si vous ne spécifiez pas de nombre maximum d’unités, la fonctionnalité Étiquettes personnalisées Amazon Rekognition ne mettra pas automatiquement à l’échelle votre modèle, mais utilisera uniquement le nombre d’unités d’inférence avec lequel vous avez commencé. Pour plus d’informations concernant le nombre maximum d’unités d’inférence, consultez [Service Quotas](https://docs.aws.amazon.com/general/latest/gr/rekognition.html#limits_rekognition). Vous pouvez également spécifier un nombre minimum d’unités d’inférence à l’aide du paramètre `MinInferenceUnits`. Cela vous permet de spécifier le débit minimum pour votre modèle, où une seule unité d’inférence représente 1 heure de traitement. **Note** Vous ne pouvez pas définir le nombre maximum d’unités d’inférence avec la console Étiquettes personnalisées Amazon Rekognition. Spécifiez plutôt le paramètre d’entrée `MaxInferenceUnits` de l’opération `StartProjectVersion`. Les étiquettes personnalisées Amazon Rekognition fournissent les métriques CloudWatch Amazon Logs suivantes que vous pouvez utiliser pour déterminer l'état actuel du dimensionnement automatique d'un modèle. | Métrique | Description | | --- | --- | | `DesiredInferenceUnits` | Le nombre d’unités d’inférence par rapport auxquelles la fonctionnalité Étiquettes personnalisées Amazon Rekognition est augmentée ou réduite. | | `InServiceInferenceUnits` | Le nombre d’unités d’inférence utilisées par le modèle. | Si `DesiredInferenceUnits` = `InServiceInferenceUnits`, la fonctionnalité Étiquettes personnalisées Amazon Rekognition ne met pas actuellement à l’échelle le nombre d’unités d’inférence. Si `DesiredInferenceUnits` > `InServiceInferenceUnits`, la fonctionnalité Étiquettes personnalisées Amazon Rekognition augmente à la valeur de `DesiredInferenceUnits`. Si `DesiredInferenceUnits` < `InServiceInferenceUnits`, la fonctionnalité Étiquettes personnalisées Amazon Rekognition est réduite à la valeur de `DesiredInferenceUnits`. [Pour plus d'informations concernant les métriques renvoyées par les étiquettes personnalisées Amazon Rekognition et les dimensions de filtrage, CloudWatch consultez les métriques pour Rekognition.](https://docs.aws.amazon.com/rekognition/latest/dg/cloudwatch-metricsdim.html) Pour connaître le nombre maximum d’unités d’inférence que vous avez demandées pour un modèle, appelez `DescribeProjectsVersion` et vérifiez le champ `MaxInferenceUnits` dans la réponse. Pour obtenir un exemple de code, consultez [Description d’un modèle (kit SDK)](md-describing-model-sdk.md). ## Zones de disponibilité La fonctionnalité Étiquettes personnalisées Amazon Rekognition distribue les unités d’inférence dans plusieurs zones de disponibilité au sein d’une région AWS afin d’augmenter la disponibilité. Pour plus d’informations, consultez [Zones de disponibilité](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/#Availability_Zones). Pour protéger vos modèles de production contre les pannes de zone de disponibilité et les défaillances des unités d’inférence, démarrez vos modèles de production avec au moins deux unités d’inférence. En cas de panne de la zone de disponibilité, toutes les unités d’inférence de la zone de disponibilité ne sont pas disponibles et la capacité du modèle est réduite. Les appels à [DetectCustomLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectCustomLabels)sont redistribués entre les unités d'inférence restantes. Ces appels réussissent s’ils ne dépassent pas les transactions par seconde (TPS) prises en charge par les unités d’inférence restantes. Une fois qu’AWS a réparé la zone de disponibilité, les unités d’inférence sont redémarrées et leur capacité maximum est rétablie. Si une seule unité d’inférence échoue, la fonctionnalité Étiquettes personnalisées Amazon Rekognition lance automatiquement une nouvelle unité d’inférence dans la même zone de disponibilité. La capacité du modèle est réduite jusqu’au démarrage de la nouvelle unité d’inférence. # Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition Vous pouvez commencer à exécuter un modèle d'étiquettes personnalisées Amazon Rekognition à l'aide de la console ou à l'aide de l'opération. [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion) **Important** Vous êtes facturé en fonction du nombre d’heures d’exécution de votre modèle et du nombre d’unités d’inférence qu’il utilise pendant son exécution. Pour plus d’informations, consultez [Exécution d’un modèle Étiquettes personnalisées Amazon Rekognition entraîné](running-model.md). Le démarrage d’un modèle peut prendre quelques minutes. Pour vérifier l'état actuel de préparation du modèle, consultez la page de détails du projet ou de l'utilisation [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions). Une fois le modèle démarré, vous utilisez [DetectCustomLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectCustomLabels), pour analyser les images à l'aide du modèle. Pour de plus amples informations, veuillez consulter [Analyse d’une image avec un modèle entraîné](detecting-custom-labels.md). La console fournit également un exemple de code pour appeler `DetectCustomLabels`. **Topics** + [Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition (Console)](#rm-start-console) + [Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition (kit SDK)](#rm-start-sdk) ## Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition (Console) Utilisez la procédure suivante pour commencer à exécuter un modèle Étiquettes personnalisées Amazon Rekognition avec la console. Vous pouvez démarrer le modèle directement depuis la console ou utiliser le code AWS SDK fourni par la console. **Pour démarrer un modèle (console)** 1. Ouvrez la console Amazon Rekognition à l'adresse. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) 1. Choisissez **Utiliser Custom Labels**. 1. Choisissez **Démarrer**. 1. Dans le volet de navigation de gauche, choisissez **Projets**. 1. Sur la page des ressources **Projets**, choisissez le projet qui contient le modèle entraîné que vous souhaitez démarrer. 1. Dans la section **Modèles**, choisissez le modèle que vous souhaitez démarrer. 1. Choisissez l’onglet **Utiliser le modèle**. 1. Effectuez l’une des actions suivantes : ------ #### [ Start model using the console ] Dans la section **Démarrer ou arrêter le modèle**, procédez comme suit : 1. Sélectionnez le nombre d’unités d’inférence que vous souhaitez utiliser. Pour plus d’informations, consultez [Exécution d’un modèle Étiquettes personnalisées Amazon Rekognition entraîné](running-model.md). 1. Sélectionnez **Démarrer**. 1. Dans la boîte de dialogue **Démarrer le modèle**, choisissez **Démarrer**. ------ #### [ Start model using the AWS SDK ] Dans la section **Utiliser votre modèle**, procédez comme suit : 1. Choisissez **Code de l’API**. 1. Choisissez **AWS CLI** ou **Python**. 1. Dans **Démarrer le modèle**, copiez l’exemple de code. 1. Utilisez l’exemple de code pour démarrer votre modèle. Pour plus d’informations, consultez [Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition (kit SDK)](#rm-start-sdk). ------ 1. Pour revenir à la page de présentation du projet, choisissez le nom de votre projet en haut de la page. 1. Dans la section **Modèle**, vérifiez le statut du modèle. Lorsque le statut du modèle est **EN COURS D’EXÉCUTION**, vous pouvez utiliser le modèle pour analyser des images. Pour plus d’informations, consultez [Analyse d’une image avec un modèle entraîné](detecting-custom-labels.md). ## Démarrage d’un modèle Étiquettes personnalisées Amazon Rekognition (kit SDK) Vous démarrez un modèle en appelant l'[StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion)API et en transmettant le nom de ressource Amazon (ARN) du modèle dans le paramètre `ProjectVersionArn` d'entrée. Vous spécifiez également le nombre d’unités d’inférence que vous souhaitez utiliser. Pour plus d’informations, consultez [Exécution d’un modèle Étiquettes personnalisées Amazon Rekognition entraîné](running-model.md). Le démarrage d’un modèle peut prendre un certain temps. Les exemples Python et Java présentés dans cette rubrique utilisent des programmes d’attente pour attendre le démarrage du modèle. Un programme d’attente est un utilitaire qui attend qu’un statut particulier survienne. Vous pouvez également vérifier l'état actuel en appelant [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions). **Pour démarrer un modèle (kit SDK)** 1. 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 : configurer le AWS CLI et AWS SDKs](su-awscli-sdk.md). 1. Utilisez l’exemple de code suivant pour démarrer un modèle. ------ #### [ CLI ] Remplacez la valeur de `project-version-arn` par l’ARN du modèle que vous souhaitez démarrer. Remplacez la valeur de `--min-inference-units` par le nombre d’unités d’inférence que vous souhaitez utiliser. (Facultatif) Modifiez `--max-inference-units` par le nombre maximum d’unités d’inférence que la fonctionnalité Étiquettes personnalisées Amazon Rekognition peut utiliser pour automatiquement mettre à l’échelle le modèle. ``` aws rekognition start-project-version --project-version-arn model_arn \ --min-inference-units minimum number of units \ --max-inference-units maximum number of units \ --profile custom-labels-access ``` ------ #### [ Python ] Fournissez les paramètres de ligne de commande suivants : + `project_arn` : l’ARN du projet contenant le modèle que vous souhaitez démarrer. + `model_arn` : l’ARN du modèle que vous souhaitez démarrer. + `min_inference_units` : le nombre d’unités d’inférence que vous souhaitez utiliser. + (Facultatif) `--max_inference_units` : le nombre maximum d’unités d’inférence que la fonctionnalité Étiquettes personnalisées Amazon Rekognition peut utiliser pour automatiquement mettre à l’échelle le modèle. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to start running an Amazon Lookout for Vision model. """ import argparse import logging import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) def get_model_status(rek_client, project_arn, model_arn): """ Gets the current status of an Amazon Rekognition Custom Labels model :param rek_client: The Amazon Rekognition Custom Labels Boto3 client. :param project_name: The name of the project that you want to use. :param model_arn: The name of the model that you want the status for. :return: The model status """ logger.info("Getting status for %s.", model_arn) # Extract the model version from the model arn. version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0] models = rek_client.describe_project_versions(ProjectArn=project_arn, VersionNames=[version_name]) for model in models['ProjectVersionDescriptions']: logger.info("Status: %s", model['StatusMessage']) return model["Status"] error_message = f"Model {model_arn} not found." logger.exception(error_message) raise Exception(error_message) def start_model(rek_client, project_arn, model_arn, min_inference_units, max_inference_units=None): """ Starts the hosting of an Amazon Rekognition Custom Labels model. :param rek_client: The Amazon Rekognition Custom Labels Boto3 client. :param project_name: The name of the project that contains the model that you want to start hosting. :param min_inference_units: The number of inference units to use for hosting. :param max_inference_units: The number of inference units to use for auto-scaling the model. If not supplied, auto-scaling does not happen. """ try: # Start the model logger.info(f"Starting model: {model_arn}. Please wait....") if max_inference_units is None: rek_client.start_project_version(ProjectVersionArn=model_arn, MinInferenceUnits=int(min_inference_units)) else: rek_client.start_project_version(ProjectVersionArn=model_arn, MinInferenceUnits=int( min_inference_units), MaxInferenceUnits=int(max_inference_units)) # Wait for the model to be in the running state version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0] project_version_running_waiter = rek_client.get_waiter( 'project_version_running') project_version_running_waiter.wait( ProjectArn=project_arn, VersionNames=[version_name]) # Get the running status return get_model_status(rek_client, project_arn, model_arn) except ClientError as err: logger.exception("Client error: Problem starting model: %s", err) 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 that contains that the model you want to start." ) parser.add_argument( "model_arn", help="The ARN of the model that you want to start." ) parser.add_argument( "min_inference_units", help="The minimum number of inference units to use." ) parser.add_argument( "--max_inference_units", help="The maximum number of inference units to use for auto-scaling the model.", 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() # Start the model. session = boto3.Session(profile_name='custom-labels-access') rekognition_client = session.client("rekognition") status = start_model(rekognition_client, args.project_arn, args.model_arn, args.min_inference_units, args.max_inference_units) print(f"Finished starting model: {args.model_arn}") print(f"Status: {status}") except ClientError as err: error_message = f"Client error: Problem starting model: {err}" logger.exception(error_message) print(error_message) except Exception as err: error_message = f"Problem starting model:{err}" logger.exception(error_message) print(error_message) if __name__ == "__main__": main() ``` ------ #### [ Java V2 ] Fournissez les paramètres de ligne de commande suivants : + `project_arn` : l’ARN du projet contenant le modèle que vous souhaitez démarrer. + `model_arn` : l’ARN du modèle que vous souhaitez démarrer. + `min_inference_units` : le nombre d’unités d’inférence que vous souhaitez utiliser. + (Facultatif) `max_inference_units` : le nombre maximum d’unités d’inférence que la fonctionnalité Étiquettes personnalisées Amazon Rekognition peut utiliser pour automatiquement mettre à l’échelle le modèle. Si vous ne spécifiez pas de valeur, la mise à l’échelle automatique ne se produit pas. ``` /* 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.DescribeProjectVersionsRequest; import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse; import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription; import software.amazon.awssdk.services.rekognition.model.ProjectVersionStatus; import software.amazon.awssdk.services.rekognition.model.RekognitionException; import software.amazon.awssdk.services.rekognition.model.StartProjectVersionRequest; import software.amazon.awssdk.services.rekognition.model.StartProjectVersionResponse; import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter; import java.util.Optional; import java.util.logging.Level; import java.util.logging.Logger; public class StartModel { public static final Logger logger = Logger.getLogger(StartModel.class.getName()); public static int findForwardSlash(String modelArn, int n) { int start = modelArn.indexOf('/'); while (start >= 0 && n > 1) { start = modelArn.indexOf('/', start + 1); n -= 1; } return start; } public static void startMyModel(RekognitionClient rekClient, String projectArn, String modelArn, Integer minInferenceUnits, Integer maxInferenceUnits ) throws Exception, RekognitionException { try { logger.log(Level.INFO, "Starting model: {0}", modelArn); StartProjectVersionRequest startProjectVersionRequest = null; if (maxInferenceUnits == null) { startProjectVersionRequest = StartProjectVersionRequest.builder() .projectVersionArn(modelArn) .minInferenceUnits(minInferenceUnits) .build(); } else { startProjectVersionRequest = StartProjectVersionRequest.builder() .projectVersionArn(modelArn) .minInferenceUnits(minInferenceUnits) .maxInferenceUnits(maxInferenceUnits) .build(); } StartProjectVersionResponse response = rekClient.startProjectVersion(startProjectVersionRequest); logger.log(Level.INFO, "Status: {0}", response.statusAsString() ); // Get the model version int start = findForwardSlash(modelArn, 3) + 1; int end = findForwardSlash(modelArn, 4); String versionName = modelArn.substring(start, end); // wait until model starts DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder() .versionNames(versionName) .projectArn(projectArn) .build(); RekognitionWaiter waiter = rekClient.waiter(); WaiterResponse waiterResponse = waiter .waitUntilProjectVersionRunning(describeProjectVersionsRequest); Optional optionalResponse = waiterResponse.matched().response(); DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get(); for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse .projectVersionDescriptions()) { if(projectVersionDescription.status() == ProjectVersionStatus.RUNNING) { logger.log(Level.INFO, "Model is running" ); } else { String error = "Model training failed: " + projectVersionDescription.statusAsString() + " " + projectVersionDescription.statusMessage() + " " + modelArn; logger.log(Level.SEVERE, error); throw new Exception(error); } } } catch (RekognitionException e) { logger.log(Level.SEVERE, "Could not start model: {0}", e.getMessage()); throw e; } } public static void main(String[] args) { String modelArn = null; String projectArn = null; Integer minInferenceUnits = null; Integer maxInferenceUnits = null; final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n" + " project_arn - The ARN of the project that contains the model that you want to start. \n\n" + " model_arn - The ARN of the model version that you want to start.\n\n" + " min_inference_units - The number of inference units to start the model with.\n\n" + " max_inference_units - The maximum number of inference units that Custom Labels can use to " + " automatically scale the model. If the value is null, automatic scaling doesn't happen.\n\n"; if (args.length < 3 || args.length >4) { System.out.println(USAGE); System.exit(1); } projectArn = args[0]; modelArn = args[1]; minInferenceUnits=Integer.parseInt(args[2]); if (args.length == 4) { maxInferenceUnits = Integer.parseInt(args[3]); } try { // Get the Rekognition client. RekognitionClient rekClient = RekognitionClient.builder() .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access")) .region(Region.US_WEST_2) .build(); // Start the model. startMyModel(rekClient, projectArn, modelArn, minInferenceUnits, maxInferenceUnits); System.out.println(String.format("Model started: %s", modelArn)); rekClient.close(); } catch (RekognitionException rekError) { logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage()); System.exit(1); } catch (Exception rekError) { logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage()); System.exit(1); } } } ``` ------ # Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition Vous pouvez arrêter d'exécuter un modèle d'étiquettes personnalisées Amazon Rekognition en utilisant la console ou en utilisant l'opération. [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion) **Topics** + [Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition (console)](#rm-stop-console) + [Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition (kit SDK)](#rm-stop-sdk) ## Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition (console) Utilisez la procédure suivante pour arrêter d’exécuter un modèle Étiquettes personnalisées Amazon Rekognition avec la console. Vous pouvez arrêter le modèle directement depuis la console ou utiliser le code AWS SDK fourni par la console. **Pour arrêter un modèle (console)** 1. Ouvrez la console Amazon Rekognition à l'adresse. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/) 1. Choisissez **Utiliser Custom Labels**. 1. Choisissez **Démarrer**. 1. Dans le volet de navigation de gauche, choisissez **Projets**. 1. Sur la page des ressources **Projets**, choisissez le projet qui contient le modèle entraîné que vous souhaitez arrêter. 1. Dans la section **Modèles**, choisissez le modèle que vous souhaitez arrêter. 1. Choisissez l’onglet **Utiliser le modèle**. 1. ------ #### [ Stop model using the console ] 1. Dans la section **Démarrer ou arrêter le modèle**, choisissez **Arrêter**. 1. Dans la boîte de dialogue **Arrêter le modèle**, entrez **stop** pour confirmer que vous souhaitez arrêter le modèle. 1. Choisissez **Arrêter** pour arrêter votre modèle. ------ #### [ Stop model using the AWS SDK ] Dans la section **Utiliser votre modèle**, procédez comme suit : 1. Choisissez **Code de l’API**. 1. Choisissez **AWS CLI** ou **Python**. 1. Dans **Arrêter le modèle**, copiez l’exemple de code. 1. Utilisez l’exemple de code pour arrêter votre modèle. Pour plus d’informations, consultez [Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition (kit SDK)](#rm-stop-sdk). ------ 1. Choisissez le nom de votre projet en haut de la page pour revenir à la page de présentation du projet. 1. Dans la section **Modèle**, vérifiez le statut du modèle. Le modèle s’arrête lorsque le statut du modèle est **ARRÊTÉ**. ## Arrêt d’un modèle Étiquettes personnalisées Amazon Rekognition (kit SDK) Vous arrêtez un modèle en appelant l'[StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API et en transmettant le nom de ressource Amazon (ARN) du modèle dans le paramètre `ProjectVersionArn` d'entrée. L’arrêt d’un modèle peut prendre un certain temps. Pour vérifier le statut actuel, utilisez `DescribeProjectVersions`. **Pour arrêter un modèle (kit SDK)** 1. 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 : configurer le AWS CLI et AWS SDKs](su-awscli-sdk.md). 1. Utilisez l’exemple de code suivant pour arrêter un modèle en cours d’exécution. ------ #### [ CLI ] Remplacez la valeur de `project-version-arn` par l’ARN de la version du modèle que vous souhaitez arrêter. ``` aws rekognition stop-project-version --project-version-arn "model arn" \ --profile custom-labels-access ``` ------ #### [ Python ] L’exemple suivant arrête un modèle déjà en cours d’exécution. Fournissez les paramètres de ligne de commande suivants : + `project_arn` : l’ARN du projet contenant le modèle que vous souhaitez arrêter. + `model_arn` : l’ARN du modèle que vous souhaitez arrêter. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Purpose Shows how to stop a running Amazon Lookout for Vision model. """ import argparse import logging import time import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) def get_model_status(rek_client, project_arn, model_arn): """ Gets the current status of an Amazon Rekognition Custom Labels model :param rek_client: The Amazon Rekognition Custom Labels Boto3 client. :param project_name: The name of the project that you want to use. :param model_arn: The name of the model that you want the status for. """ logger.info ("Getting status for %s.", model_arn) # Extract the model version from the model arn. version_name=(model_arn.split("version/",1)[1]).rpartition('/')[0] # Get the model status. models=rek_client.describe_project_versions(ProjectArn=project_arn, VersionNames=[version_name]) for model in models['ProjectVersionDescriptions']: logger.info("Status: %s",model['StatusMessage']) return model["Status"] # No model found. logger.exception("Model %s not found.", model_arn) raise Exception("Model %s not found.", model_arn) def stop_model(rek_client, project_arn, model_arn): """ Stops a running Amazon Rekognition Custom Labels Model. :param rek_client: The Amazon Rekognition Custom Labels Boto3 client. :param project_arn: The ARN of the project that you want to stop running. :param model_arn: The ARN of the model (ProjectVersion) that you want to stop running. """ logger.info("Stopping model: %s", model_arn) try: # Stop the model. response=rek_client.stop_project_version(ProjectVersionArn=model_arn) logger.info("Status: %s", response['Status']) # stops when hosting has stopped or failure. status = "" finished = False while finished is False: status=get_model_status(rek_client, project_arn, model_arn) if status == "STOPPING": logger.info("Model stopping in progress...") time.sleep(10) continue if status == "STOPPED": logger.info("Model is not running.") finished = True continue error_message = f"Error stopping model. Unexepected state: {status}" logger.exception(error_message) raise Exception(error_message) logger.info("finished. Status %s", status) return status except ClientError as err: logger.exception("Couldn't stop model - %s: %s", model_arn,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 that contains the model that you want to stop." ) parser.add_argument( "model_arn", help="The ARN of the model that you want to stop." ) 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() # Stop the model. session = boto3.Session(profile_name='custom-labels-access') rekognition_client = session.client("rekognition") status=stop_model(rekognition_client, args.project_arn, args.model_arn) print(f"Finished stopping model: {args.model_arn}") print(f"Status: {status}") except ClientError as err: logger.exception("Problem stopping model:%s",err) print(f"Failed to stop model: {err}") except Exception as err: logger.exception("Problem stopping model:%s", err) print(f"Failed to stop model: {err}") if __name__ == "__main__": main() ``` ------ #### [ Java V2 ] Fournissez les paramètres de ligne de commande suivants : + `project_arn` : l’ARN du projet contenant le modèle que vous souhaitez arrêter. + `model_arn` : l’ARN du modèle que vous souhaitez arrêter. ``` /* 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.regions.Region; import software.amazon.awssdk.services.rekognition.RekognitionClient; import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest; import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse; import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription; import software.amazon.awssdk.services.rekognition.model.ProjectVersionStatus; import software.amazon.awssdk.services.rekognition.model.RekognitionException; import software.amazon.awssdk.services.rekognition.model.StopProjectVersionRequest; import software.amazon.awssdk.services.rekognition.model.StopProjectVersionResponse; import java.util.logging.Level; import java.util.logging.Logger; public class StopModel { public static final Logger logger = Logger.getLogger(StopModel.class.getName()); public static int findForwardSlash(String modelArn, int n) { int start = modelArn.indexOf('/'); while (start >= 0 && n > 1) { start = modelArn.indexOf('/', start + 1); n -= 1; } return start; } public static void stopMyModel(RekognitionClient rekClient, String projectArn, String modelArn) throws Exception, RekognitionException { try { logger.log(Level.INFO, "Stopping {0}", modelArn); StopProjectVersionRequest stopProjectVersionRequest = StopProjectVersionRequest.builder() .projectVersionArn(modelArn).build(); StopProjectVersionResponse response = rekClient.stopProjectVersion(stopProjectVersionRequest); logger.log(Level.INFO, "Status: {0}", response.statusAsString()); // Get the model version int start = findForwardSlash(modelArn, 3) + 1; int end = findForwardSlash(modelArn, 4); String versionName = modelArn.substring(start, end); // wait until model stops DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder() .projectArn(projectArn).versionNames(versionName).build(); boolean stopped = false; // Wait until create finishes do { DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient .describeProjectVersions(describeProjectVersionsRequest); for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse .projectVersionDescriptions()) { ProjectVersionStatus status = projectVersionDescription.status(); logger.log(Level.INFO, "stopping model: {0} ", modelArn); switch (status) { case STOPPED: logger.log(Level.INFO, "Model stopped"); stopped = true; break; case STOPPING: Thread.sleep(5000); break; case FAILED: String error = "Model stopping failed: " + projectVersionDescription.statusAsString() + " " + projectVersionDescription.statusMessage() + " " + modelArn; logger.log(Level.SEVERE, error); throw new Exception(error); default: String unexpectedError = "Unexpected stopping state: " + projectVersionDescription.statusAsString() + " " + projectVersionDescription.statusMessage() + " " + modelArn; logger.log(Level.SEVERE, unexpectedError); throw new Exception(unexpectedError); } } } while (stopped == false); } catch (RekognitionException e) { logger.log(Level.SEVERE, "Could not stop model: {0}", e.getMessage()); throw e; } } public static void main(String[] args) { String modelArn = null; String projectArn = null; final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n" + " project_arn - The ARN of the project that contains the model that you want to stop. \n\n" + " model_arn - The ARN of the model version that you want to stop.\n\n"; if (args.length != 2) { System.out.println(USAGE); System.exit(1); } projectArn = args[0]; modelArn = args[1]; try { // Get the Rekognition client. RekognitionClient rekClient = RekognitionClient.builder() .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access")) .region(Region.US_WEST_2) .build(); // Stop model stopMyModel(rekClient, projectArn, modelArn); System.out.println(String.format("Model stopped: %s", modelArn)); rekClient.close(); } catch (RekognitionException rekError) { logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage()); System.exit(1); } catch (Exception rekError) { logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage()); System.exit(1); } } } ``` ------ # Rapport sur la durée d’exécution et les unités d’inférence utilisées Si vous avez entraîné et démarré votre modèle après août 2022, vous pouvez utiliser la CloudWatch métrique `InServiceInferenceUnits` Amazon pour déterminer le nombre d'heures pendant lesquelles un modèle a fonctionné et le nombre d'[unités d'inférence](running-model.md#running-model-inference-units) utilisées pendant ces heures. **Note** Si vous ne possédez qu'un seul modèle dans une AWS région, vous pouvez également connaître la durée de fonctionnement du modèle en effectuant le suivi des appels entrants `StartprojectVersion` et entrants `StopProjectVersion` réussis CloudWatch. Cette approche ne fonctionne pas si vous exécutez plusieurs modèles dans la AWS région, car les métriques n'incluent pas d'informations sur le modèle. Vous pouvez également l'utiliser AWS CloudTrail pour suivre les appels vers `StartProjectVersion` et `StopProjectVersion` (ce qui inclut l'ARN du modèle dans le `requestParameters` champ de l'[historique des événements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html?icmpid=docs_console_unmapped)). CloudTrail les événements sont limités à 90 jours, mais vous pouvez les stocker pendant une période maximale de 7 ans dans un [CloudTraillac](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html). La procédure suivante permet de créer des graphiques pour ce qui suit : + Le nombre d’heures pendant lequel un modèle a été exécuté. + Le nombre d’unités d’inférence utilisées par le modèle. Vous pouvez choisir une période remontant jusqu’aux 15 derniers mois. Pour plus d’informations sur la conservation des métriques, consultez [Conservation des métriques](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#metrics-retention). **Pour déterminer la durée du modèle et les unités d’inférence utilisées pour un modèle** 1. Connectez-vous à la CloudWatch console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Dans le volet de navigation de gauche, choisissez **Toutes les métriques** sous **Métriques**. 1. Dans le volet de contenu, choisissez l’onglet **Source**. 1. Assurez-vous que le bouton **Tableau de bord** est sélectionné. 1. Dans la zone d’édition, remplacez le fichier JSON existant par le fichier JSON suivant. Remplacez les valeurs suivantes : + `Project_Name` : le projet contenant le modèle que vous souhaitez représenter graphiquement. + `Version_Name` : la version du modèle que vous souhaitez représenter graphiquement. + `AWS_Region`— La AWS région qui contient le modèle. Assurez-vous que la CloudWatch console se trouve dans la même AWS région en cochant le sélecteur de région dans la barre de navigation en haut de la page. Mettez à jour si nécessaire. ``` { "sparkline": true, "metrics": [ [ { "expression": "SUM(m1)*m1", "label": "Inference units used", "id": "e1" } ], [ { "expression": "DATAPOINT_COUNT(m1)*m1/m1", "label": "Hours running", "id": "e2" } ], [ "AWS/Rekognition", "InServiceInferenceUnits", "ProjectName", "Project_Name", "VersionName", "Version_Name", { "id": "m1", "visible": false } ] ], "view": "singleValue", "stacked": false, "region": "AWS_Region", "stat": "Average", "period": 3600, "title": "Hours run and inference units used" } ``` 1. Choisissez **Mettre à jour**. 1. Dans le haut de la page, choisissez une chronologie. Vous devriez voir les chiffres des unités d’inférence utilisées et les heures écoulées au cours de la chronologie. Les lacunes dans le graphique indiquent les moments où le modèle ne s’exécutait pas. La capture d'écran de la console ci-dessous montre les unités d'inférence utilisées et les heures réparties sur des périodes, avec une durée personnalisée de 2 semaines définie, avec les valeurs les plus élevées de 214 unités d'inférence et 209 heures de fonctionnement. ![\[Graphique montrant les unités d'inférence.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/customlabels-dg/images/model-duration.png) 1. (Facultatif) Ajoutez le graphique à un tableau de bord en choisissant **Actions**, puis **Ajouter au tableau de bord - amélioré**.