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.
# 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);
}
}
}
```
------