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.

# Reconnaissance de célébrités dans une vidéo stockée
<a name="celebrities-video-sqs"></a>

La reconnaissance de célébrités Vidéo Amazon Rekognition dans des vidéos stockées est une opération asynchrone. Pour reconnaître des célébrités dans une vidéo enregistrée, utilisez cette option [StartCelebrityRecognition](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartCelebrityRecognition.html)pour démarrer l'analyse vidéo. Vidéo Amazon Rekognition publie l’état d’achèvement de l’opération d’analyse vidéo dans une rubrique Amazon Simple Notification Service. Si l'analyse vidéo aboutit, appelez [GetCelebrityRecognition](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetCelebrityRecognition.html) pour obtenir les résultats de cette opération. Pour plus d’informations sur le démarrage de l’analyse vidéo et l’obtention des résultats, consultez [Appeler les opérations de Vidéo Amazon Rekognition](api-video.md). 

Cette procédure s’appuie sur le code figurant dans [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md), qui utilise une file d’attente Amazon SQS pour obtenir le statut d’achèvement d’une demande d’analyse vidéo. Pour exécuter cette procédure, vous avez besoin d’un fichier vidéo qui contient un ou plusieurs visages de célébrités.

**Pour détecter des célébrités dans une vidéo stockée dans un compartiment S3 (SDK)**

1. Effectuez une [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md).

1. Ajoutez le code suivant à la classe `VideoDetect` que vous avez créée à l’étape 1.

------
#### [ Java ]

   ```
           //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
           //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
         // Celebrities=====================================================================
         private static void StartCelebrityDetection(String bucket, String video) throws Exception{
       	  
               NotificationChannel channel= new NotificationChannel()
                       .withSNSTopicArn(snsTopicArn)
                       .withRoleArn(roleArn);
     
              StartCelebrityRecognitionRequest req = new StartCelebrityRecognitionRequest()
                    .withVideo(new Video()
                          .withS3Object(new S3Object()
                                .withBucket(bucket)
                                .withName(video)))
                    .withNotificationChannel(channel);
     
     
     
              StartCelebrityRecognitionResult startCelebrityRecognitionResult = rek.startCelebrityRecognition(req);
              startJobId=startCelebrityRecognitionResult.getJobId();
     
           } 
     
           private static void GetCelebrityDetectionResults() throws Exception{
     
              int maxResults=10;
              String paginationToken=null;
              GetCelebrityRecognitionResult celebrityRecognitionResult=null;
     
              do{
                 if (celebrityRecognitionResult !=null){
                    paginationToken = celebrityRecognitionResult.getNextToken();
                 }
                 celebrityRecognitionResult = rek.getCelebrityRecognition(new GetCelebrityRecognitionRequest()
                       .withJobId(startJobId)
                       .withNextToken(paginationToken)
                       .withSortBy(CelebrityRecognitionSortBy.TIMESTAMP)
                       .withMaxResults(maxResults));
     
     
                 System.out.println("File info for page");
                 VideoMetadata videoMetaData=celebrityRecognitionResult.getVideoMetadata();
     
                 System.out.println("Format: " + videoMetaData.getFormat());
                 System.out.println("Codec: " + videoMetaData.getCodec());
                 System.out.println("Duration: " + videoMetaData.getDurationMillis());
                 System.out.println("FrameRate: " + videoMetaData.getFrameRate());
     
                 System.out.println("Job");
     
                 System.out.println("Job status: " + celebrityRecognitionResult.getJobStatus());
     
     
                 //Show celebrities
                 List<CelebrityRecognition> celebs= celebrityRecognitionResult.getCelebrities();
     
                 for (CelebrityRecognition celeb: celebs) { 
                    long seconds=celeb.getTimestamp()/1000;
                    System.out.print("Sec: " + Long.toString(seconds) + " ");
                    CelebrityDetail details=celeb.getCelebrity();
                    System.out.println("Name: " + details.getName());
                    System.out.println("Id: " + details.getId());
                    System.out.println(); 
                 }
              } while (celebrityRecognitionResult !=null && celebrityRecognitionResult.getNextToken() != null);
     
           }
   ```

   Dans la fonction `main`, remplacez la ligne : 

   ```
           StartLabelDetection(amzn-s3-demo-bucket, video);
   
           if (GetSQSMessageSuccess()==true)
           	GetLabelDetectionResults();
   ```

   avec :

   ```
           StartCelebrityDetection(amzn-s3-demo-bucket, video);
   
           if (GetSQSMessageSuccess()==true)
           	GetCelebrityDetectionResults();
   ```

------
#### [ Java V2 ]

   Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/VideoCelebrityDetection.java).

   ```
   //snippet-start:[rekognition.java2.recognize_video_celebrity.import]
   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.S3Object;
   import software.amazon.awssdk.services.rekognition.model.NotificationChannel;
   import software.amazon.awssdk.services.rekognition.model.Video;
   import software.amazon.awssdk.services.rekognition.model.StartCelebrityRecognitionResponse;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.rekognition.model.CelebrityRecognitionSortBy;
   import software.amazon.awssdk.services.rekognition.model.VideoMetadata;
   import software.amazon.awssdk.services.rekognition.model.CelebrityRecognition;
   import software.amazon.awssdk.services.rekognition.model.CelebrityDetail;
   import software.amazon.awssdk.services.rekognition.model.StartCelebrityRecognitionRequest;
   import software.amazon.awssdk.services.rekognition.model.GetCelebrityRecognitionRequest;
   import software.amazon.awssdk.services.rekognition.model.GetCelebrityRecognitionResponse;
   import java.util.List;
   //snippet-end:[rekognition.java2.recognize_video_celebrity.import]
   
   /**
   *  To run this code example, ensure that you perform the Prerequisites as stated in the Amazon Rekognition Guide:
   *  https://docs.aws.amazon.com/rekognition/latest/dg/video-analyzing-with-sqs.html
   *
   * Also, ensure that set up your development environment, including your credentials.
   *
   * For information, see this documentation topic:
   *
   * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
   */
   
   public class RecognizeCelebritiesVideo {
   
   private static String startJobId ="";
   
   public static void main(String[] args) {
   
      final String usage = "\n" +
          "Usage: " +
          "   <bucket> <video> <topicArn> <roleArn>\n\n" +
          "Where:\n" +
          "   bucket - The name of the bucket in which the video is located (for example, (for example, amzn-s3-demo-bucket). \n\n"+
          "   video - The name of video (for example, people.mp4). \n\n" +
          "   topicArn - The ARN of the Amazon Simple Notification Service (Amazon SNS) topic. \n\n" +
          "   roleArn - The ARN of the AWS Identity and Access Management (IAM) role to use. \n\n" ;
   
      if (args.length != 4) {
          System.out.println(usage);
          System.exit(1);
      }
   
      String bucket = args[0];
      String video = args[1];
      String topicArn = args[2];
      String roleArn = args[3];
      Region region = Region.US_EAST_1;
      RekognitionClient rekClient = RekognitionClient.builder()
          .region(region)
          .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
          .build();
   
     NotificationChannel channel = NotificationChannel.builder()
          .snsTopicArn(topicArn)
          .roleArn(roleArn)
          .build();
   
     StartCelebrityDetection(rekClient, channel, bucket, video);
     GetCelebrityDetectionResults(rekClient);
     System.out.println("This example is done!");
     rekClient.close();
   }
   
   // snippet-start:[rekognition.java2.recognize_video_celebrity.main]
   public static void StartCelebrityDetection(RekognitionClient rekClient,
                                              NotificationChannel channel,
                                              String bucket,
                                              String video){
      try {
          S3Object s3Obj = S3Object.builder()
              .bucket(bucket)
              .name(video)
              .build();
   
          Video vidOb = Video.builder()
              .s3Object(s3Obj)
              .build();
   
          StartCelebrityRecognitionRequest recognitionRequest = StartCelebrityRecognitionRequest.builder()
              .jobTag("Celebrities")
              .notificationChannel(channel)
              .video(vidOb)
              .build();
   
          StartCelebrityRecognitionResponse startCelebrityRecognitionResult = rekClient.startCelebrityRecognition(recognitionRequest);
          startJobId = startCelebrityRecognitionResult.jobId();
   
      } catch(RekognitionException e) {
          System.out.println(e.getMessage());
          System.exit(1);
      }
   }
   
   public static void GetCelebrityDetectionResults(RekognitionClient rekClient) {
   
      try {
          String paginationToken=null;
          GetCelebrityRecognitionResponse recognitionResponse = null;
          boolean finished = false;
          String status;
          int yy=0 ;
   
          do{
              if (recognitionResponse !=null)
                  paginationToken = recognitionResponse.nextToken();
   
              GetCelebrityRecognitionRequest recognitionRequest = GetCelebrityRecognitionRequest.builder()
                  .jobId(startJobId)
                  .nextToken(paginationToken)
                  .sortBy(CelebrityRecognitionSortBy.TIMESTAMP)
                  .maxResults(10)
                  .build();
   
              // Wait until the job succeeds
              while (!finished) {
                  recognitionResponse = rekClient.getCelebrityRecognition(recognitionRequest);
                  status = recognitionResponse.jobStatusAsString();
   
                  if (status.compareTo("SUCCEEDED") == 0)
                      finished = true;
                  else {
                      System.out.println(yy + " status is: " + status);
                      Thread.sleep(1000);
                  }
                  yy++;
              }
   
              finished = false;
   
              // Proceed when the job is done - otherwise VideoMetadata is null.
              VideoMetadata videoMetaData=recognitionResponse.videoMetadata();
              System.out.println("Format: " + videoMetaData.format());
              System.out.println("Codec: " + videoMetaData.codec());
              System.out.println("Duration: " + videoMetaData.durationMillis());
              System.out.println("FrameRate: " + videoMetaData.frameRate());
              System.out.println("Job");
   
              List<CelebrityRecognition> celebs= recognitionResponse.celebrities();
              for (CelebrityRecognition celeb: celebs) {
                  long seconds=celeb.timestamp()/1000;
                  System.out.print("Sec: " + seconds + " ");
                  CelebrityDetail details=celeb.celebrity();
                  System.out.println("Name: " + details.name());
                  System.out.println("Id: " + details.id());
                  System.out.println();
              }
   
          } while (recognitionResponse.nextToken() != null);
   
      } catch(RekognitionException | InterruptedException e) {
          System.out.println(e.getMessage());
          System.exit(1);
      }
   }
   // snippet-end:[rekognition.java2.recognize_video_celebrity.main]
   }
   ```

------
#### [ Python ]

   ```
   #Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   #PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
       # ============== Celebrities ===============
       def StartCelebrityDetection(self):
           response=self.rek.start_celebrity_recognition(Video={'S3Object': {'Bucket': self.bucket, 'Name': self.video}},
               NotificationChannel={'RoleArn': self.roleArn, 'SNSTopicArn': self.snsTopicArn})
   
           self.startJobId=response['JobId']
           print('Start Job Id: ' + self.startJobId)
   
       def GetCelebrityDetectionResults(self):
           maxResults = 10
           paginationToken = ''
           finished = False
   
           while finished == False:
               response = self.rek.get_celebrity_recognition(JobId=self.startJobId,
                                                       MaxResults=maxResults,
                                                       NextToken=paginationToken)
   
               print(response['VideoMetadata']['Codec'])
               print(str(response['VideoMetadata']['DurationMillis']))
               print(response['VideoMetadata']['Format'])
               print(response['VideoMetadata']['FrameRate'])
   
               for celebrityRecognition in response['Celebrities']:
                   print('Celebrity: ' +
                       str(celebrityRecognition['Celebrity']['Name']))
                   print('Timestamp: ' + str(celebrityRecognition['Timestamp']))
                   print()
   
               if 'NextToken' in response:
                   paginationToken = response['NextToken']
               else:
                   finished = True
   ```

   Dans la fonction `main`, remplacez les lignes :

   ```
       analyzer.StartLabelDetection()
       if analyzer.GetSQSMessageSuccess()==True:
           analyzer.GetLabelDetectionResults()
   ```

   avec :

   ```
       analyzer.StartCelebrityDetection()
       if analyzer.GetSQSMessageSuccess()==True:
           analyzer.GetCelebrityDetectionResults()
   ```

------
#### [ Node.JS ]

   Dans l'exemple de Node.Js code suivant, remplacez la valeur de `amzn-s3-demo-bucket` par le nom du compartiment S3 contenant votre vidéo et la valeur de `videoName` par le nom du fichier vidéo. Vous devez également remplacer la valeur de `roleArn` par l’ARN associé à votre fonction du service IAM. Enfin, remplacez la valeur de `region` par le nom de la région d’exploitation associée à votre compte. Remplacez la valeur de `profile_name` dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur.

   ```
   //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
   
   // Import required AWS SDK clients and commands for Node.js
   import { CreateQueueCommand, GetQueueAttributesCommand, GetQueueUrlCommand, 
     SetQueueAttributesCommand, DeleteQueueCommand, ReceiveMessageCommand, DeleteMessageCommand } from  "@aws-sdk/client-sqs";
   import {CreateTopicCommand, SubscribeCommand, DeleteTopicCommand } from "@aws-sdk/client-sns";
   import  { SQSClient } from "@aws-sdk/client-sqs";
   import  { SNSClient } from "@aws-sdk/client-sns";
   import  { RekognitionClient, StartLabelDetectionCommand, GetLabelDetectionCommand, 
     StartCelebrityRecognitionCommand, GetCelebrityRecognitionCommand} from "@aws-sdk/client-rekognition";
   import { stdout } from "process";
   import {fromIni} from '@aws-sdk/credential-providers';
   
   // Set the AWS Region.
   const REGION = "region-name"; //e.g. "us-east-1"
   // Set the profile name
   const profileName = "profile-name"
   // Name the collection
   // Create SNS service object.
   const sqsClient = new SQSClient({ region: REGION, 
     credentials: fromIni({profile: profileName,}), });
   const snsClient = new SNSClient({ region: REGION, 
     credentials: fromIni({profile: profileName,}), });
   const rekClient = new RekognitionClient({region: REGION, 
     credentials: fromIni({profile: profileName,}), 
   });
   
   // Set bucket and video variables
   const bucket = "bucket-name";
   const videoName = "video-name";
   const roleArn = "role-arn"
   var startJobId = ""
   
   var ts = Date.now();
   const snsTopicName = "AmazonRekognitionExample" + ts;
   const snsTopicParams = {Name: snsTopicName}
   const sqsQueueName = "AmazonRekognitionQueue-" + ts;
   
    // Set the parameters
    const sqsParams = {
     QueueName: sqsQueueName, //SQS_QUEUE_URL
     Attributes: {
       DelaySeconds: "60", // Number of seconds delay.
       MessageRetentionPeriod: "86400", // Number of seconds delay.
     },
   };
   
   const createTopicandQueue = async () => {
     try {
       // Create SNS topic
       const topicResponse = await snsClient.send(new CreateTopicCommand(snsTopicParams));
       const topicArn = topicResponse.TopicArn
       console.log("Success", topicResponse);
       // Create SQS Queue
       const sqsResponse = await sqsClient.send(new CreateQueueCommand(sqsParams));
       console.log("Success", sqsResponse);
       const sqsQueueCommand = await sqsClient.send(new GetQueueUrlCommand({QueueName: sqsQueueName}))
       const sqsQueueUrl = sqsQueueCommand.QueueUrl
       const attribsResponse = await sqsClient.send(new GetQueueAttributesCommand({QueueUrl: sqsQueueUrl, AttributeNames: ['QueueArn']}))
       const attribs = attribsResponse.Attributes
       console.log(attribs)
       const queueArn = attribs.QueueArn
       // subscribe SQS queue to SNS topic
       const subscribed = await snsClient.send(new SubscribeCommand({TopicArn: topicArn, Protocol:'sqs', Endpoint: queueArn}))
       const policy = {
         Version: "2012-10-17",&TCX5-2025-waiver;
         Statement: [
           {
             Sid: "MyPolicy",
             Effect: "Allow",
             Principal: {AWS: "*"},
             Action: "SQS:SendMessage",
             Resource: queueArn,
             Condition: {
               ArnEquals: {
                 'aws:SourceArn': topicArn
               }
             }
           }
         ]
       };
   
       const response = sqsClient.send(new SetQueueAttributesCommand({QueueUrl: sqsQueueUrl, Attributes: {Policy: JSON.stringify(policy)}}))
       console.log(response)
       console.log(sqsQueueUrl, topicArn)
       return [sqsQueueUrl, topicArn]
   
     } catch (err) {
       console.log("Error", err);
     }
   };
   
   const startCelebrityDetection = async(roleArn, snsTopicArn) =>{
     try {
         //Initiate label detection and update value of startJobId with returned Job ID
         const response = await rekClient.send(new StartCelebrityRecognitionCommand({Video:{S3Object:{Bucket:bucket, Name:videoName}},
             NotificationChannel:{RoleArn: roleArn, SNSTopicArn: snsTopicArn}}))
             startJobId = response.JobId
             console.log(`Start Job ID: ${startJobId}`)
             return startJobId
       } catch (err) {
         console.log("Error", err);
       }
     };
   
   const getCelebrityRecognitionResults = async(startJobId) =>{
     try {
         //Initiate label detection and update value of startJobId with returned Job ID
         var maxResults = 10
         var paginationToken = ''
         var finished = false
   
         while (finished == false){
             var response = await rekClient.send(new GetCelebrityRecognitionCommand({JobId: startJobId, MaxResults: maxResults, 
                 NextToken: paginationToken}))
             console.log(response.VideoMetadata.Codec)
             console.log(response.VideoMetadata.DurationMillis)
             console.log(response.VideoMetadata.Format)
             console.log(response.VideoMetadata.FrameRate)
             response.Celebrities.forEach(celebrityRecognition => {
                 console.log(`Celebrity: ${celebrityRecognition.Celebrity.Name}`)
                 console.log(`Timestamp: ${celebrityRecognition.Timestamp}`)
                 console.log()
             })
             // Searh for pagination token, if found, set variable to next token
             if (String(response).includes("NextToken")){
                 paginationToken = response.NextToken
         
             }else{
                 finished = true
             }
         }
       } catch (err) {
         console.log("Error", err);
       }
     };
   
   // Checks for status of job completion
   const getSQSMessageSuccess = async(sqsQueueUrl, startJobId) => {
     try {
       // Set job found and success status to false initially
       var jobFound = false
       var succeeded = false
       var dotLine = 0
       // while not found, continue to poll for response
       while (jobFound == false){
         var sqsReceivedResponse = await sqsClient.send(new ReceiveMessageCommand({QueueUrl:sqsQueueUrl, 
           MaxNumberOfMessages:'ALL', MaxNumberOfMessages:10}));
         if (sqsReceivedResponse){
           var responseString = JSON.stringify(sqsReceivedResponse)
           if (!responseString.includes('Body')){
             if (dotLine < 40) {
               console.log('.')
               dotLine = dotLine + 1
             }else {
               console.log('')
               dotLine = 0 
             };
             stdout.write('', () => {
               console.log('');
             });
             await new Promise(resolve => setTimeout(resolve, 5000));
             continue
           }
         }
   
         // Once job found, log Job ID and return true if status is succeeded
         for (var message of sqsReceivedResponse.Messages){
           console.log("Retrieved messages:")
           var notification = JSON.parse(message.Body)
           var rekMessage = JSON.parse(notification.Message)
           var messageJobId = rekMessage.JobId
           if (String(rekMessage.JobId).includes(String(startJobId))){
             console.log('Matching job found:')
             console.log(rekMessage.JobId)
             jobFound = true
             console.log(rekMessage.Status)
             if (String(rekMessage.Status).includes(String("SUCCEEDED"))){
               succeeded = true
               console.log("Job processing succeeded.")
               var sqsDeleteMessage = await sqsClient.send(new DeleteMessageCommand({QueueUrl:sqsQueueUrl, ReceiptHandle:message.ReceiptHandle}));
             }
           }else{
             console.log("Provided Job ID did not match returned ID.")
             var sqsDeleteMessage = await sqsClient.send(new DeleteMessageCommand({QueueUrl:sqsQueueUrl, ReceiptHandle:message.ReceiptHandle}));
           }
         }
       }
     return succeeded
     } catch(err) {
       console.log("Error", err);
     }
   };
   
   // Start label detection job, sent status notification, check for success status
   // Retrieve results if status is "SUCEEDED", delete notification queue and topic
   const runCelebRecognitionAndGetResults = async () => {
     try {
       const sqsAndTopic = await createTopicandQueue();
       //const startLabelDetectionRes = await startLabelDetection(roleArn, sqsAndTopic[1]);
       //const getSQSMessageStatus = await getSQSMessageSuccess(sqsAndTopic[0], startLabelDetectionRes)
       const startCelebrityDetectionRes = await startCelebrityDetection(roleArn, sqsAndTopic[1]);
       const getSQSMessageStatus = await getSQSMessageSuccess(sqsAndTopic[0], startCelebrityDetectionRes)
       console.log(getSQSMessageSuccess)
       if (getSQSMessageSuccess){
         console.log("Retrieving results:")
         const results = await getCelebrityRecognitionResults(startCelebrityDetectionRes)
       }
       const deleteQueue = await sqsClient.send(new DeleteQueueCommand({QueueUrl: sqsAndTopic[0]}));
       const deleteTopic = await snsClient.send(new DeleteTopicCommand({TopicArn: sqsAndTopic[1]}));
       console.log("Successfully deleted.")
     } catch (err) {
       console.log("Error", err);
     }
   };
   
   runCelebRecognitionAndGetResults()
   ```

------
#### [ CLI ]

   Exécutez la AWS CLI commande suivante pour commencer à détecter des célébrités dans une vidéo.

   ```
   aws rekognition start-celebrity-recognition --video "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"video-name"}}" \
   --notification-channel "{"SNSTopicArn":"topic-arn","RoleArn":"role-arn"}" \
   --region region-name --profile profile-name
   ```

   Mettez à jour les valeurs suivantes :
   + Remplacez `amzn-s3-demo-bucket` et `video-name` par le nom du compartiment Amazon S3 et le nom du fichier que vous avez spécifiés à l’étape 2.
   + Remplacez `region-name` par la région AWS que vous utilisez.
   + Remplacez la valeur de `profile-name` par le nom de votre profil de développeur.
   + Remplacez `topic-ARN` par l’ARN de la rubrique Amazon SNS que vous avez créée à l’étape 3 de [Configuration de Vidéo Amazon Rekognition](api-video-roles.md).
   + Remplacez `role-ARN` par l’ARN de la fonction de service IAM que vous avez créé à l’étape 7 de [Configuration de Vidéo Amazon Rekognition](api-video-roles.md).

   Si vous accédez à la CLI sur un périphérique Windows, utilisez des guillemets doubles au lieu de guillemets simples et évitez les guillemets doubles internes par une barre oblique inverse (c’est-à-dire \\) pour corriger les erreurs d’analyse que vous pourriez rencontrer. Pour un exemple, voir ci-dessous : 

   ```
   aws rekognition start-celebrity-recognition --video "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"video-name\"}}" \
   --notification-channel "{\"SNSTopicArn\":\"topic-arn\",\"RoleArn\":\"role-arn\"}" \
   --region region-name --profile profile-name
   ```

   Après avoir exécuté l’exemple de code suivant, copiez l’`jobID` renvoyé et saisissez-le dans la commande suivante `GetCelebrityRecognition` pour obtenir vos résultats, en remplaçant `job-id-number` par `jobID` que vous avez reçu précédemment : 

   ```
   aws rekognition get-celebrity-recognition --job-id job-id-number --profile profile-name                               
   ```

------
**Note**  
Si vous avez déjà exécuté un exemple vidéo autre que [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md), le code à remplacer peut être différent.

1. Exécutez le code. Des informations concernant les célébrités reconnues dans la vidéo s’affichent.

## GetCelebrityRecognition réponse à l'opération
<a name="getcelebrityrecognition-operation-output"></a>

Voici un exemple de réponse JSON : La réponse inclut les éléments suivants :
+ **Célébrités reconnues** : `Celebrities` est un tableau des célébrités et des moments auxquels elles ont été reconnues dans une vidéo. Un objet [CelebrityRecognition](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CelebrityRecognition.html) existe pour chaque occurrence de reconnaissance de la célébrité dans la vidéo. Chaque `CelebrityRecognition` contient des informations sur une célébrité reconnue ([CelebrityDetail](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CelebrityDetail.html)) et l'heure (`Timestamp`) à laquelle elle a été reconnue dans la vidéo. `Timestamp` est mesurée en millisecondes à partir du début de la vidéo. 
+ **CelebrityDetail**— Contient des informations sur une célébrité reconnue. Cette partie comprend le nom de la célébrité (`Name`), un identifiant (`ID`) le genre connu de la célébrité (`KnownGender`), et une liste d’URL pointant vers du contenu associé (`Urls`). Cela inclut également le niveau de confiance d'Amazon Rekognition Video dans la précision de la reconnaissance, ainsi que des informations sur le visage de la célébrité. [FaceDetail](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_FaceDetail.html) Si vous avez besoin d'obtenir le contenu associé ultérieurement, vous pouvez l'utiliser `ID` avec [get CelebrityInfo](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetCelebrityInfo.html). 
+ **VideoMetadata**— Informations sur la vidéo analysée.

```
{
    "Celebrities": [
        {
            "Celebrity": {
                "Confidence": 0.699999988079071,
                "Face": {
                    "BoundingBox": {
                        "Height": 0.20555555820465088,
                        "Left": 0.029374999925494194,
                        "Top": 0.22333332896232605,
                        "Width": 0.11562500149011612
                    },
                    "Confidence": 99.89837646484375,
                    "Landmarks": [
                        {
                            "Type": "eyeLeft",
                            "X": 0.06857934594154358,
                            "Y": 0.30842265486717224
                        },
                        {
                            "Type": "eyeRight",
                            "X": 0.10396526008844376,
                            "Y": 0.300625205039978
                        },
                        {
                            "Type": "nose",
                            "X": 0.0966852456331253,
                            "Y": 0.34081998467445374
                        },
                        {
                            "Type": "mouthLeft",
                            "X": 0.075217105448246,
                            "Y": 0.3811396062374115
                        },
                        {
                            "Type": "mouthRight",
                            "X": 0.10744428634643555,
                            "Y": 0.37407416105270386
                        }
                    ],
                    "Pose": {
                        "Pitch": -0.9784082174301147,
                        "Roll": -8.808176040649414,
                        "Yaw": 20.28228759765625
                    },
                    "Quality": {
                        "Brightness": 43.312068939208984,
                        "Sharpness": 99.9305191040039
                    }
                },
                "Id": "XXXXXX",
                "KnownGender": {
                    "Type": "Female"
                },
                "Name": "Celeb A",
                "Urls": []
            },
            "Timestamp": 367
       },......
    ],
    "JobStatus": "SUCCEEDED",
    "NextToken": "XfXnZKiyMOGDhzBzYUhS5puM+g1IgezqFeYpv/H/+5noP/LmM57FitUAwSQ5D6G4AB/PNwolrw==",
    "VideoMetadata": {
        "Codec": "h264",
        "DurationMillis": 67301,
        "FileExtension": "mp4",
        "Format": "QuickTime / MOV",
        "FrameHeight": 1080,
        "FrameRate": 29.970029830932617,
        "FrameWidth": 1920
    }
}
```