

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.

# Détection d’objets et de concepts
<a name="labels"></a>

Cette section fournit des informations de détection d’étiquettes dans des images et des vidéos avec Image Amazon Rekognition et Vidéo Amazon Rekognition. 

 Une étiquette ou une balise constituent un objet ou un concept (y compris des scènes et des actions) détecté dans une image ou une vidéo, en fonction de son contenu. Par exemple, une photo de personnes sur une plage tropicale peut contenir les étiquettes « Palmier » (objet), « Plage » (scène), « Courir » (action) et « Extérieur » (concept). 

**Étiquettes prises en charge par les opérations de détection d'étiquettes Rekognition**
+ Pour télécharger la dernière liste des étiquettes et des encadrements d’objets compatibles avec Amazon Rekognition, cliquez [ici](samples/AmazonRekognitionLabels_v3.0.zip). 
+ Pour télécharger la liste précédente des étiquettes et des encadrés d’objets, cliquez [ici](samples/AmazonRekognitionLabels_v2.0.zip). 

**Note**  
Amazon Rekognition fait des prédictions binaires liées au genre (homme, femme, fille, etc.) sur la base de l’apparence physique d’une personne sur une image donnée. Ce type de prédiction n’est pas conçu pour catégoriser l’identité de genre d’une personne, et vous ne devez pas utiliser Amazon Rekognition pour effectuer une telle détermination. Par exemple, un acteur masculin portant une perruque aux cheveux longs et des boucles d’oreilles pour un rôle peut être prédit comme une femme.  
L’utilisation d’Amazon Rekognition pour établir des prédictions binaires entre les sexes convient parfaitement aux cas d’utilisation dans lesquels les statistiques agrégées de répartition par sexe doivent être analysées sans identifier d’utilisateurs spécifiques. Par exemple, le pourcentage d’utilisateurs qui sont des femmes par rapport aux hommes sur une plateforme de médias sociaux.  
Nous vous déconseillons d’utiliser des prédictions binaires de sexe pour prendre des décisions ayant un impact sur les droits, la confidentialité ou l’accès aux services d’une personne.

Amazon Rekognition renvoie des étiquettes en anglais. Vous pouvez utiliser [Amazon Translate](https://aws.amazon.com/translate/) pour traduire des étiquettes en anglais dans [d’autres langues](https://docs.aws.amazon.com/translate/latest/dg/what-is.html#language-pairs).

Le schéma suivant montre l'ordre des opérations d'appel, en fonction de vos objectifs d'utilisation des opérations Amazon Rekognition Image ou Amazon Rekognition Video : 



![\[Schéma illustrant les flux de travail d'analyse d'images et de vidéos avec traitement vidéo stocké et en streaming.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/LabelDetectionWorkflow.png)


## Étiqueter les objets de réponse
<a name="labels-details"></a>

### Cadres de délimitation
<a name="labels-details-bbox"></a>

Image Amazon Rekognition et Vidéo Amazon Rekognition peuvent renvoyer le cadre de délimitation pour des étiquettes d’objets courants tels que des voitures, des meubles, des appareils ou des animaux de compagnie. Les informations relatives au cadre de délimitation ne sont pas renvoyées pour les étiquettes d’objets moins courants. Vous pouvez utiliser des cadres de délimitation pour trouver les emplacements exacts des objets dans une image et le nombre d’instances d’objets détectés, ou pour mesurer la taille d’un objet à l’aide des dimensions de ces cadres. 

Par exemple, dans l’image suivante, Image Amazon Rekognition peut détecter la présence d’une personne, d’un skateboard, de voitures garées et d’autres informations. Image Amazon Rekognition renvoie également le cadre de délimitation pour une personne détectée, ainsi que d’autres objets détectés, tels que des voitures et des roues. 

![\[Personne faisant une cascade de skateboard entre des voitures garées dans une rue de la ville.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/detect-scenes.jpg)


### Score de fiabilité
<a name="labels-details-image-conf-score"></a>

Vidéo Amazon Rekognition et Image Amazon Rekognition fournissent un score en pourcentage indiquant le degré de confiance d’Amazon Rekognition dans l’exactitude de chaque étiquette détectée.

### Parents
<a name="labels-details-parents"></a>

Image Amazon Rekognition et Vidéo Amazon Rekognition utilisent une taxonomie hiérarchique des étiquettes d’ancêtres pour classer les étiquettes. Par exemple, une personne qui traverse une route peut être détectée en tant que *Pedestrian* (Piéton). L’étiquette parent de *Pedestrian* (Piéton) est *Person* (Personne). Les deux étiquettes sont renvoyées dans la réponse. Toutes les étiquettes d’ancêtre sont renvoyées et une étiquette donnée contient une liste de ses étiquettes parent et des autres étiquettes d’ancêtre. Par exemple, des étiquettes de grand-parent et d’arrière grand-parent, si elles existent. Vous pouvez utiliser des étiquettes parent pour créer des groupes d’étiquettes liées et autoriser l’interrogation des étiquettes similaires dans une ou plusieurs images. Par exemple, une requête pour tous les véhicules (*Vehicles*) peut renvoyer une voiture depuis une image et une moto depuis une autre image.

### Catégories
<a name="labels-details-image-categories"></a>

Image Amazon Rekognition et Vidéo Amazon Rekognition renvoient des informations sur les catégories d’étiquettes. Les étiquettes font partie de catégories qui regroupent des étiquettes individuelles selon des fonctions et des contextes communs, tels que « Véhicules et automobiles » et « Produits alimentaires et boissons ». Une catégorie d’étiquette peut être une sous-catégorie d’une catégorie parent. 

### les alias ;
<a name="labels-details-image-aliases"></a>

Outre le renvoi des étiquettes, Image Amazon Rekognition et Vidéo Amazon Rekognition renvoient tous les alias associés à l’étiquette. Les alias sont des étiquettes ayant la même signification ou des étiquettes visuellement interchangeables avec l’étiquette principale renvoyée. Par exemple, « téléphone cellulaire » est un alias de « téléphone portable ». 

Dans les versions précédentes, Image Amazon Rekognition renvoyait des alias tels que « téléphone cellulaire » dans la même liste de noms d’étiquette principale qui contenait « téléphone portable ». Image Amazon Rekognition renvoie désormais « Téléphone cellulaire » dans un champ appelé « alias » et « Téléphone portable » dans la liste des noms d’étiquette principaux. Si votre application repose sur les structures renvoyées par une version précédente de Rekognition, vous devrez peut-être transformer la réponse actuelle renvoyée par les opérations de détection d’étiquettes d’images ou de vidéos dans la structure de réponse précédente, dans laquelle toutes les étiquettes et alias sont renvoyés en tant qu’étiquettes principales.

Si vous devez transformer la réponse actuelle de l' DetectLabels API (pour la détection d'étiquettes dans les images) dans la structure de réponse précédente, consultez l'exemple de code dans[Transformation de la DetectLabels réponse](labels-detect-labels-image.md#detectlabels-transform-response). 

Si vous devez transformer la réponse actuelle de l' GetLabelDetection API (pour la détection d'étiquettes dans les vidéos stockées) dans la structure de réponse précédente, consultez l'exemple de code dans[Transformation de la GetLabelDetection réponse](labels-detecting-labels-video.md#getlabeldetection-transform-response).

### Propriétés de l’image
<a name="labels-details-image-properties"></a>

Image Amazon Rekognition renvoie des informations sur la qualité de l’image (netteté, luminosité et contraste) pour l’ensemble de l’image. La netteté et la luminosité sont également renvoyées pour le premier plan et l’arrière-plan de l’image. Les propriétés de l’image peuvent également être utilisées pour détecter les couleurs dominantes de l’ensemble de l’image, du premier plan, de l’arrière-plan et des objets dotés de cadres de délimitation.

![\[Image d'une voiture verte dans une rue de la ville, entourée d'un boîtier de délimitation.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/car_bb.png)


 Voici un exemple des ImageProperties données contenues dans la réponse d'une DetectLabels opération pour l'image suivante :

![\[Tableau présentant les couleurs dominantes et les mesures de qualité d'image pour une image entière, le premier plan, l'arrière-plan et un exemple d'objet avec cadre de sélection.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/image_properties_table.png)


Propriétés de l’image n’est pas disponible pour Vidéo Amazon Rekognition.

### Version de modèle
<a name="labels-details-image-model-version"></a>

Image Amazon Rekognition et Vidéo Amazon Rekognition renvoient la version du modèle de détection d’étiquette utilisé pour détecter les étiquettes dans une image ou une vidéo stockée. 

### Filtres d’inclusion et d’exclusion
<a name="labels-details-filters"></a>

Vous pouvez filtrer les résultats renvoyés par les opérations de détection d’étiquettes Image Amazon Rekognition et Vidéo Amazon Rekognition. Filtrez les résultats en fournissant des critères de filtrage pour les étiquettes et les catégories. Les filtres d’étiquette peuvent être inclusifs ou exclusifs. 

Voir [Détection des étiquettes dans une image](labels-detect-labels-image.md) pour plus d’informations concernant la filtration des résultats obtenus avec `DetectLabels`.

Voir [Détection des étiquettes dans une vidéo](labels-detecting-labels-video.md) pour plus d’informations concernant le filtrage des résultats obtenus par `GetLabelDetection`.

### Tri et agrégation des résultats
<a name="labels-details-sorting-aggregating"></a>

Les résultats obtenus à partir de certaines opérations Vidéo Amazon Rekognition peuvent être triés et agrégés en fonction des horodatages et des segments vidéo. Lorsque vous récupérez les résultats d’une tâche de détection d’étiquettes ou de modération de contenu, avec `GetLabelDetection` ou `GetContentModeration` respectivement, vous pouvez utiliser les arguments `SortBy` et `AggregateBy` pour spécifier la manière dont vous souhaitez que vos résultats soient renvoyés. Vous pouvez utiliser `SortBy` avec `TIMESTAMP` ou `NAME` (noms d'étiquettes) et utiliser `TIMESTAMPS` ou `SEGMENTS` avec l' AggregateByargument.

# Détection des étiquettes dans une image
<a name="labels-detect-labels-image"></a>

Vous pouvez utiliser cette [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)opération pour détecter des étiquettes (objets et concepts) dans une image et récupérer des informations sur les propriétés de l'image. Les propriétés de l’image incluent des attributs tels que la couleur du premier plan et de l’arrière-plan, ainsi que la netteté, la luminosité et le contraste de l’image. Vous pouvez récupérer uniquement les étiquettes d’une image, uniquement les propriétés de l’image, ou les deux. Pour obtenir un exemple, consultez [Analyse d’images stockées dans un compartiment Amazon S3](images-s3.md).

Les exemples suivants utilisent various AWS SDKs et AWS CLI to call`DetectLabels`. Pour en savoir plus sur la réponse d’opération `DetectLabels`, consultez [DetectLabels réponse](#detectlabels-response).

**Pour détecter des étiquettes dans une image**

1. Si vous ne l’avez pas déjà fait :

   1. Créez ou mettez à jour un utilisateur avec `AmazonRekognitionFullAccess` et autorisations `AmazonS3ReadOnlyAccess`. Pour de plus amples informations, veuillez consulter [Étape 1 : configurer un compte AWS et créer un utilisateur](setting-up.md#setting-up-iam).

   1. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI et AWS SDKs](setup-awscli-sdk.md).

1. Chargez une image qui contient un ou plusieurs objets - par exemple des arbres, des maisons et un bateau - dans votre compartiment S3. L’image doit être au format *.jpg* ou *.png*.

   Pour en savoir plus, consultez [Chargement d’objets dans Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.

1. Utilisez les exemples suivants pour appeler l’opération `DetectLabels`.

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

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. 

   ```
   package com.amazonaws.samples;
   import java.util.List;
   
   import com.amazonaws.services.rekognition.model.BoundingBox;
   import com.amazonaws.services.rekognition.model.DetectLabelsRequest;
   import com.amazonaws.services.rekognition.model.DetectLabelsResult;
   import com.amazonaws.services.rekognition.model.Image;
   import com.amazonaws.services.rekognition.model.Instance;
   import com.amazonaws.services.rekognition.model.Label;
   import com.amazonaws.services.rekognition.model.Parent;
   import com.amazonaws.services.rekognition.model.S3Object;
   import com.amazonaws.services.rekognition.AmazonRekognition;
   import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
   import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
   
   public class DetectLabels {
   
       public static void main(String[] args) throws Exception {
   
           String photo = "photo";
           String bucket = "bucket";
   
           AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
           DetectLabelsRequest request = new DetectLabelsRequest()
                   .withImage(new Image().withS3Object(new S3Object().withName(photo).withBucket(bucket)))
                   .withMaxLabels(10).withMinConfidence(75F);
   
           try {
               DetectLabelsResult result = rekognitionClient.detectLabels(request);
               List<Label> labels = result.getLabels();
   
               System.out.println("Detected labels for " + photo + "\n");
               for (Label label : labels) {
                   System.out.println("Label: " + label.getName());
                   System.out.println("Confidence: " + label.getConfidence().toString() + "\n");
   
                   List<Instance> instances = label.getInstances();
                   System.out.println("Instances of " + label.getName());
                   if (instances.isEmpty()) {
                       System.out.println("  " + "None");
                   } else {
                       for (Instance instance : instances) {
                           System.out.println("  Confidence: " + instance.getConfidence().toString());
                           System.out.println("  Bounding box: " + instance.getBoundingBox().toString());
                       }
                   }
                   System.out.println("Parent labels for " + label.getName() + ":");
                   List<Parent> parents = label.getParents();
                   if (parents.isEmpty()) {
                       System.out.println("  None");
                   } else {
                       for (Parent parent : parents) {
                           System.out.println("  " + parent.getName());
                       }
                   }
                   System.out.println("--------------------");
                   System.out.println();
                  
               }
           } catch (AmazonRekognitionException e) {
               e.printStackTrace();
           }
       }
   }
   ```

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

   Cet exemple affiche la sortie JSON de l’opération `detect-labels` de l’interface de ligne de commande (CLI). Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. Remplacez la valeur de `profile-name` par le nom de votre profil de développeur. 

   ```
   aws rekognition detect-labels --image '{ "S3Object": { "Bucket": "bucket-name", "Name": "file-name" } }' \
   --features GENERAL_LABELS IMAGE_PROPERTIES \
   --settings '{"ImageProperties": {"MaxDominantColors":1}, {"GeneralLabels":{"LabelInclusionFilters":["Cat"]}}}' \
   --profile profile-name \
   --region us-east-1
   ```

   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 \$1) pour corriger les erreurs d’analyse que vous pourriez rencontrer. Par exemple, consultez ce qui suit : 

   ```
   aws rekognition detect-labels --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"file-name\"}}" --features GENERAL_LABELS IMAGE_PROPERTIES \
   --settings "{\"GeneralLabels\":{\"LabelInclusionFilters\":[\"Car\"]}}" --profile profile-name --region us-east-1
   ```

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

   Cet exemple affiche les étiquettes qui ont été détectées dans l’image d’entrée. Dans la fonction `main`, remplacez les valeurs de `bucket` et `photo` par les noms du compartiment Amazon S3 et de l’image que vous avez utilisés à l’étape 2. 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 boto3
   
   def detect_labels(photo, bucket):
   
        session = boto3.Session(profile_name='profile-name')
        client = session.client('rekognition')
   
        response = client.detect_labels(Image={'S3Object':{'Bucket':bucket,'Name':photo}},
        MaxLabels=10,
        # Uncomment to use image properties and filtration settings
        #Features=["GENERAL_LABELS", "IMAGE_PROPERTIES"],
        #Settings={"GeneralLabels": {"LabelInclusionFilters":["Cat"]},
        # "ImageProperties": {"MaxDominantColors":10}}
        )
   
        print('Detected labels for ' + photo)
        print()
        for label in response['Labels']:
            print("Label: " + label['Name'])
            print("Confidence: " + str(label['Confidence']))
            print("Instances:")
   
            for instance in label['Instances']:
                print(" Bounding box")
                print(" Top: " + str(instance['BoundingBox']['Top']))
                print(" Left: " + str(instance['BoundingBox']['Left']))
                print(" Width: " + str(instance['BoundingBox']['Width']))
                print(" Height: " + str(instance['BoundingBox']['Height']))
                print(" Confidence: " + str(instance['Confidence']))
                print()
   
            print("Parents:")
            for parent in label['Parents']:
               print(" " + parent['Name'])
   
            print("Aliases:")
            for alias in label['Aliases']:
                print(" " + alias['Name'])
   
                print("Categories:")
            for category in label['Categories']:
                print(" " + category['Name'])
                print("----------")
                print()
   
        if "ImageProperties" in str(response):
            print("Background:")
            print(response["ImageProperties"]["Background"])
            print()
            print("Foreground:")
            print(response["ImageProperties"]["Foreground"])
            print()
            print("Quality:")
            print(response["ImageProperties"]["Quality"])
            print()
   
        return len(response['Labels'])
   
   def main():
       photo = 'photo-name'
       bucket = 'amzn-s3-demo-bucket'
       label_count = detect_labels(photo, bucket)
       print("Labels detected: " + str(label_count))
   
   if __name__ == "__main__":
       main()
   ```

------
#### [ .NET ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. 

   ```
   //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.)
   
   using System;
   using Amazon.Rekognition;
   using Amazon.Rekognition.Model;
   
   public class DetectLabels
   {
       public static void Example()
       {
           String photo = "input.jpg";
           String bucket = "amzn-s3-demo-bucket";
   
           AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
   
           DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
           {
               Image = new Image()
               {
                   S3Object = new S3Object()
                   {
                       Name = photo,
                       Bucket = bucket
                   },
               },
               MaxLabels = 10,
               MinConfidence = 75F
           };
   
           try
           {
               DetectLabelsResponse detectLabelsResponse = rekognitionClient.DetectLabels(detectlabelsRequest);
               Console.WriteLine("Detected labels for " + photo);
               foreach (Label label in detectLabelsResponse.Labels)
                   Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
       }
   }
   ```

------
#### [ Ruby ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. 

   ```
      # Add to your Gemfile
      # gem 'aws-sdk-rekognition'
      require 'aws-sdk-rekognition'
      credentials = Aws::Credentials.new(
         ENV['AWS_ACCESS_KEY_ID'],
         ENV['AWS_SECRET_ACCESS_KEY']
      )
      bucket = 'bucket' # the bucket name without s3://
      photo  = 'photo' # the name of file
      client   = Aws::Rekognition::Client.new credentials: credentials
      attrs = {
        image: {
          s3_object: {
            bucket: bucket,
            name: photo
          },
        },
        max_labels: 10
      }
     response = client.detect_labels attrs
     puts "Detected labels for: #{photo}"
     response.labels.each do |label|
       puts "Label:      #{label.name}"
       puts "Confidence: #{label.confidence}"
       puts "Instances:"
       label['instances'].each do |instance|
         box = instance['bounding_box']
         puts "  Bounding box:"
         puts "    Top:        #{box.top}"
         puts "    Left:       #{box.left}"
         puts "    Width:      #{box.width}"
         puts "    Height:     #{box.height}"
         puts "  Confidence: #{instance.confidence}"
       end
       puts "Parents:"
       label.parents.each do |parent|
         puts "  #{parent.name}"
       end
       puts "------------"
       puts ""
     end
   ```

------
#### [ Node.js ]

   Cet exemple affiche la liste des étiquettes qui ont été détectées dans l’image d’entrée. Remplacez les valeurs de `bucket` et `photo` par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. 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. 

   Si vous utilisez des TypeScript définitions, vous devrez peut-être utiliser à la `import AWS from 'aws-sdk'` place de`const AWS = require('aws-sdk')`, afin d'exécuter le programme avec Node.js. Vous pouvez consulter l’[AWS SDK pour Javascript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) pour plus de détails. Selon la façon dont vous avez configuré vos configurations, vous devrez peut-être également spécifier votre région avec `AWS.config.update({region:region});`.

   ```
                                   
   // Load the SDK
   var AWS = require('aws-sdk');
   const bucket = 'bucket-name' // the bucketname without s3://
   const photo  = 'image-name' // the name of file
   
   var credentials = new AWS.SharedIniFileCredentials({profile: 'profile-name'});
   AWS.config.credentials = credentials;
   AWS.config.update({region:'region-name'});
   
   const client = new AWS.Rekognition();
   const params = {
     Image: {
       S3Object: {
         Bucket: bucket,
         Name: photo
       },
     },
     MaxLabels: 10
   }
   client.detectLabels(params, function(err, response) {
     if (err) {
       console.log(err, err.stack); // if an error occurred
     } else {
       console.log(`Detected labels for: ${photo}`)
       response.Labels.forEach(label => {
         console.log(`Label:      ${label.Name}`)
         console.log(`Confidence: ${label.Confidence}`)
         console.log("Instances:")
         label.Instances.forEach(instance => {
           let box = instance.BoundingBox
           console.log("  Bounding box:")
           console.log(`    Top:        ${box.Top}`)
           console.log(`    Left:       ${box.Left}`)
           console.log(`    Width:      ${box.Width}`)
           console.log(`    Height:     ${box.Height}`)
           console.log(`  Confidence: ${instance.Confidence}`)
         })
         console.log("Parents:")
         label.Parents.forEach(parent => {
           console.log(`  ${parent.Name}`)
         })
         console.log("------------")
         console.log("")
       }) // for response.labels
     } // if
   });
   ```

------
#### [ 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/DetectLabels.java).

   ```
   //snippet-start:[rekognition.java2.detect_labels.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.Image;
   import software.amazon.awssdk.services.rekognition.model.DetectLabelsRequest;
   import software.amazon.awssdk.services.rekognition.model.DetectLabelsResponse;
   import software.amazon.awssdk.services.rekognition.model.Label;
   import software.amazon.awssdk.services.rekognition.model.RekognitionException;
   import software.amazon.awssdk.services.rekognition.model.S3Object;
   import java.util.List;
   
   /**
   * Before running this Java V2 code example, set up your development environment, including your credentials.
   *
   * For more information, see the following documentation topic:
   *
   * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
   */
   public class DetectLabels {
   
       public static void main(String[] args) {
   
           final String usage = "\n" +
               "Usage: " +
               "   <bucket> <image>\n\n" +
               "Where:\n" +
               "   bucket - The name of the Amazon S3 bucket that contains the image (for example, ,ImageBucket)." +
               "   image - The name of the image located in the Amazon S3 bucket (for example, Lake.png). \n\n";
   
           if (args.length != 2) {
               System.out.println(usage);
               System.exit(1);
           }
   
           String bucket = args[0];
           String image = args[1];
           Region region = Region.US_WEST_2;
           RekognitionClient rekClient = RekognitionClient.builder()
               .region(region)
               .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
               .build();
   
           getLabelsfromImage(rekClient, bucket, image);
           rekClient.close();
       }
   
       // snippet-start:[rekognition.java2.detect_labels_s3.main]
       public static void getLabelsfromImage(RekognitionClient rekClient, String bucket, String image) {
   
           try {
               S3Object s3Object = S3Object.builder()
                   .bucket(bucket)
                   .name(image)
                   .build() ;
   
               Image myImage = Image.builder()
                   .s3Object(s3Object)
                   .build();
   
               DetectLabelsRequest detectLabelsRequest = DetectLabelsRequest.builder()
                   .image(myImage)
                   .maxLabels(10)
                   .build();
   
               DetectLabelsResponse labelsResponse = rekClient.detectLabels(detectLabelsRequest);
               List<Label> labels = labelsResponse.labels();
               System.out.println("Detected labels for the given photo");
               for (Label label: labels) {
                   System.out.println(label.name() + ": " + label.confidence().toString());
               }
   
           } catch (RekognitionException e) {
               System.out.println(e.getMessage());
               System.exit(1);
           }
       }
    // snippet-end:[rekognition.java2.detect_labels.main]
   }
   ```

------

   

## DetectLabels demande d'opération
<a name="detectlabels-request"></a>

La valeur d’entrée de `DetectLabel` est une image. Dans cet exemple d’entrée JSON, l’image source est chargée à partir d’un compartiment Amazon S3. `MaxLabels` correspond au nombre maximal d’étiquettes à renvoyer dans la réponse. `MinConfidence` est le niveau de fiabilité minimum que doit avoir Image Amazon Rekognition en ce qui concerne la précision de l’étiquette détectée pour que celle-ci soit renvoyée dans la réponse.

Fonctionnalités vous permet de spécifier une ou plusieurs caractéristiques de l’image que vous souhaitez renvoyer, en vous permettant de sélectionner `GENERAL_LABELS` et `IMAGE_PROPERTIES`. L’inclusion `GENERAL_LABELS` renverra les étiquettes détectées dans l’image d’entrée, tandis que l’inclusion `IMAGE_PROPERTIES` vous permettra d’accéder à la couleur et à la qualité de l’image. 

Les paramètres vous permettent de filtrer les articles renvoyés à la fois pour les fonctionnalités `GENERAL_LABELS` et `IMAGE_PROPERTIES`. Pour les étiquettes, vous pouvez utiliser des filtres inclusifs et exclusifs. Vous pouvez également filtrer par étiquette spécifique, par étiquette individuelle ou par catégorie d’étiquette : 
+ LabelInclusionFilters - Vous permet de spécifier les libellés que vous souhaitez inclure dans la réponse.
+ LabelExclusionFilters - Vous permet de spécifier les libellés que vous souhaitez exclure de la réponse.
+ LabelCategoryInclusionFilters - Vous permet de spécifier les catégories d'étiquettes que vous souhaitez inclure dans la réponse.
+ LabelCategoryExclusionFilters - Vous permet de spécifier les catégories d'étiquettes que vous souhaitez exclure de la réponse.

 Vous pouvez également combiner des filtres inclusifs et exclusifs en fonction de vos besoins, en excluant certaines étiquettes ou catégories et en incluant d’autres. 

`IMAGE_PROPERTIES` font référence aux couleurs dominantes et aux attributs de qualité d’une image tels que la netteté, la luminosité et le contraste. Lors de la détection `IMAGE_PROPERTIES`, vous pouvez spécifier le nombre maximum de couleurs dominantes à renvoyer (10 par défaut) à l’aide du paramètre `MaxDominantColors`.

```
{
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "input.jpg"
        }
    },
    "MaxLabels": 10,
    "MinConfidence": 75,
    "Features": [ "GENERAL_LABELS", "IMAGE_PROPERTIES" ],
    "Settings": {
        "GeneralLabels": {
            "LabelInclusionFilters": [<Label(s)>],
            "LabelExclusionFilters": [<Label(s)>],
            "LabelCategoryInclusionFilters": [<Category Name(s)>],
            "LabelCategoryExclusionFilters": [<Category Name(s)>] 
        },
        "ImageProperties": {
            "MaxDominantColors":10
        }
    }
}
```

## DetectLabels réponse
<a name="detectlabels-response"></a>

La réponse de `DetectLabels` est un tableau qui recense les étiquettes détectées dans l’image et qui indique le niveau de fiabilité de la détection. 

Voici un exemple de réponse de `DetectLabels`. L’exemple de réponse ci-dessous contient divers attributs renvoyés pour GENERAL\$1LABELS, notamment :
+ Nom : nom de l’étiquette détectée. Dans cet exemple, l’opération a détecté un objet portant l’étiquette Téléphone portable.
+ À chaque étiquette est associé un niveau de fiabilité. Dans cet exemple, le niveau de confiance pour l’étiquette était de 99,36 %.
+ Parents : étiquettes d’ancêtres associées à une étiquette détectée. Dans cet exemple, l’étiquette Téléphone portable possède une étiquette parent nommée Téléphone.
+ Alias : informations sur les alias possibles pour l’étiquette. Dans cet exemple, l’étiquette Téléphone portable comporte un alias possible de téléphone cellulaire.
+ Catégories : catégorie d’étiquette à laquelle appartient l’étiquette détectée. Dans cet exemple, il s’agit de la technologie et de l’informatique.

La réponse pour les étiquettes d’objets courants comprend des informations de cadre de délimitation pour l’emplacement de l’étiquette sur l’image d’entrée. Par exemple, l’étiquette Personne comporte un tableau d’instances contenant deux cadres de délimitation. Il s’agit des emplacements de deux personnes détectées dans l’image.

La réponse inclut également des attributs concernant IMAGE\$1PROPERTIES. Les attributs présentés par la fonctionnalité IMAGE\$1PROPERTIES sont les suivants :
+ Qualité : informations sur la netteté, la luminosité et le contraste de l’image d’entrée, notées entre 0 et 100. La qualité est indiquée pour l’ensemble de l’image ainsi que pour l’arrière-plan et le premier plan de l’image, si disponible. Toutefois, le contraste n’est indiqué que pour l’ensemble de l’image, tandis que la netteté et la luminosité sont également indiquées pour l’arrière-plan et le premier plan. 
+  Couleur dominante : tableau des couleurs dominantes de l’image. Chaque couleur dominante est décrite par un nom de couleur simplifié, une palette de couleurs CSS, des valeurs RGB et un code hexadécimal. 
+  Premier plan : informations sur les couleurs dominantes, la netteté et la luminosité du premier plan de l’image d’entrée. 
+  Arrière-plan : informations sur les couleurs dominantes, la netteté et la luminosité de l’arrière-plan de l’image d’entrée. 

Lorsque GENERAL\$1LABELS et IMAGE\$1PROPERTIES sont utilisés conjointement comme paramètres d’entrée, Image Amazon Rekognition renvoie également les couleurs dominantes des objets avec des cadres de délimitation. 

Le champ `LabelModelVersion` contient le numéro de version du modèle de détection utilisé par `DetectLabels`. 

```
{
   
   "Labels": [
        {
            "Name": "Mobile Phone",
            "Parents": [
              { 
                "Name": "Phone" 
              }
            ],
            "Aliases": [
              {
                "Name": "Cell Phone" 
              }
            ], 
            "Categories": [
              {
                "Name": "Technology and Computing"
              }
            ],
            "Confidence": 99.9364013671875,
            "Instances": [
                {
                    "BoundingBox": {
                        "Width": 0.26779675483703613,
                        "Height": 0.8562285900115967,
                        "Left": 0.3604024350643158,
                        "Top": 0.09245597571134567,
                    }
                    "Confidence": 99.9364013671875,
                    "DominantColors": [
                    {
                "Red": 120,
                "Green": 137,
                "Blue": 132,
                "HexCode": "3A7432",
                "SimplifiedColor": "red", 
                "CssColor": "fuscia",    
                "PixelPercentage": 40.10 
                    }       
                        ],
                }
            ]
        }
    ],
    "ImageProperties": {
        "Quality": {
            "Brightness": 40,
            "Sharpness": 40,
            "Contrast": 24,
        },
        "DominantColors": [
            {
                "Red": 120,
                "Green": 137,
                "Blue": 132,
                "HexCode": "3A7432",
                "SimplifiedColor": "red", 
                "CssColor": "fuscia",    
                "PixelPercentage": 40.10 
            }       
        ],
        "Foreground": {
            "Quality": {
                "Brightness": 40,
                "Sharpness": 40,
            },
            "DominantColors": [                
                {                    
                    "Red": 200,
                    "Green": 137,
                    "Blue": 132,
                    "HexCode": "3A7432",
                    "CSSColor": "",
                    "SimplifiedColor": "red", 
                    "PixelPercentage": 30.70             
                }          
            ],   
        }
        "Background": {
            "Quality": {
                "Brightness": 40,
                "Sharpness": 40,
            },
            "DominantColors": [                
                {                    
                    "Red": 200,
                    "Green": 137,
                    "Blue": 132,
                    "HexCode": "3A7432",
                    "CSSColor": "",
                    "SimplifiedColor": "Red", 
                    "PixelPercentage": 10.20              
                }          
            ],   
        }, 
    },
    "LabelModelVersion": "3.0"
}
```

## Transformation de la DetectLabels réponse
<a name="detectlabels-transform-response"></a>

Lorsque vous utilisez l' DetectLabels API, vous pouvez avoir besoin de la structure de réponse pour imiter l'ancienne structure de réponse de l'API, où les étiquettes principales et les alias figuraient dans la même liste. 

Voici un exemple de la réponse API actuelle de [DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html):

```
"Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 99.99717712402344,
            "Instances": [],
            "Parents": [
                { 
                "Name": "Phone" 
                }
             ],
            "Aliases": [
                {
                "Name": "Cell Phone" 
                }
             ]
        }
 ]
```

L'exemple suivant montre la réponse précédente de l'[DetectLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectLabels.html)API :

```
"Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 99.99717712402344,
            "Instances": [],
            "Parents": [
                {
                "Name": "Phone" 
                }
             ]
         },
         {
            "Name": "Cell Phone",
            "Confidence": 99.99717712402344,
            "Instances": [],
            "Parents": [
                { 
                "Name": "Phone" 
                }
             ]
         },
]
```

Si nécessaire, vous pouvez transformer la réponse actuelle pour qu’elle suive le format de l’ancienne réponse. Vous pouvez utiliser l’exemple de code suivant pour transformer la dernière réponse d’API en structure de réponse d’API précédente :

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

L'exemple de code suivant montre comment transformer la réponse actuelle à partir de l' DetectLabels API. Dans l'exemple de code ci-dessous, vous pouvez remplacer la valeur de *EXAMPLE\$1INFERENCE\$1OUTPUT* par le résultat d'une DetectLabels opération que vous avez exécutée.

```
from copy import deepcopy

LABEL_KEY = "Labels"
ALIASES_KEY = "Aliases"
INSTANCE_KEY = "Instances"
NAME_KEY = "Name"

#Latest API response sample
EXAMPLE_INFERENCE_OUTPUT = {
    "Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Aliases": [
                {
                    "Name": "Cell Phone"
                }
            ],
            "Instances":[
                {
                    "BoundingBox":{
                        "Height":0.1549897,
                        "Width":0.07747964,
                        "Top":0.50858885,
                        "Left":0.00018205095
                    },
                    "Confidence":98.401276
                }
            ]
        },
        {
            "Name": "Urban",
            "Confidence": 99.99982,
            "Categories": [
                "Colors and Visual Composition"
            ]
        }
    ]
}

def expand_aliases(inferenceOutputsWithAliases):

    if LABEL_KEY in inferenceOutputsWithAliases:
        expandInferenceOutputs = []
        for primaryLabelDict in inferenceOutputsWithAliases[LABEL_KEY]:
            if ALIASES_KEY in primaryLabelDict:
                for alias in primaryLabelDict[ALIASES_KEY]:
                    aliasLabelDict = deepcopy(primaryLabelDict)
                    aliasLabelDict[NAME_KEY] = alias[NAME_KEY]
                    del aliasLabelDict[ALIASES_KEY]
                    if INSTANCE_KEY in aliasLabelDict:
                        del aliasLabelDict[INSTANCE_KEY]
                    expandInferenceOutputs.append(aliasLabelDict)

        inferenceOutputsWithAliases[LABEL_KEY].extend(expandInferenceOutputs)

    return inferenceOutputsWithAliases


if __name__ == "__main__":

    outputWithExpandAliases = expand_aliases(EXAMPLE_INFERENCE_OUTPUT)
    print(outputWithExpandAliases)
```

Voici un exemple de la réponse transformée :

```
#Output example after the transformation
{
    "Labels": [
        {
            "Name": "Mobile Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Aliases": [
                {
                    "Name": "Cell Phone"
                }
            ],
            "Instances":[
                {
                    "BoundingBox":{
                        "Height":0.1549897,
                        "Width":0.07747964,
                        "Top":0.50858885,
                        "Left":0.00018205095
                    },
                    "Confidence":98.401276
                }
            ]
        },
        {
            "Name": "Cell Phone",
            "Confidence": 97.530106,
            "Categories": [
                {
                    "Name": "Technology and Computing"
                }
            ],
            "Instances":[]
        },
        {
            "Name": "Urban",
            "Confidence": 99.99982,
            "Categories": [
                "Colors and Visual Composition"
            ]
        }
    ]
}
```

------

# Détection des étiquettes dans une vidéo
<a name="labels-detecting-labels-video"></a>

Vidéo Amazon Rekognition peut détecter les étiquettes (objets et concepts), ainsi que l’heure à laquelle une étiquette est détectée, dans une vidéo. Pour obtenir un exemple de code SDK, consultez [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md). Pour un AWS CLI exemple, voir[Analyse d'une vidéo à l'aide du AWS Command Line Interface](video-cli-commands.md).

La détection d’étiquettes Vidéo Amazon Rekognition est une opération asynchrone. Pour démarrer la détection d'étiquettes dans une vidéo, appelez [StartLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartlabelDetection.html). 

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 réussit, appelez [GetLabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetLabelDetection.html) pour obtenir les étiquettes détectées. Pour en savoir plus sur l’appel des opérations d’API d’analyse dans les vidéos, consultez [Appeler les opérations de Vidéo Amazon Rekognition](api-video.md). 

## StartLabelDetection Demande
<a name="getlabeldetection-operation-request"></a>

L’exemple suivant est un exemple JSON de requête `StartLabelDetection`. Vous fournissez l’opération `StartLabelDetection` avec une vidéo stockée dans un compartiment Amazon S3. Dans l’exemple de demande JSON, le compartiment Amazon S3 et le nom de la vidéo sont spécifiés, ainsi que `MinConfidence`, `Features`, `Settings`, et `NotificationChannel`.

`MinConfidence` est le niveau de fiabilité minimum que doit avoir Vidéo Amazon Rekognition en ce qui concerne la précision de l’étiquette détectée ou une instance de cadre de délimitation (en cas de détection) pour que celle-ci soit renvoyée dans la réponse.

Avec `Features`, vous pouvez spécifier que vous souhaitez que GENERAL\$1LABELS soit renvoyé dans le cadre de la réponse.

Avec `Settings`, vous pouvez filtrer les articles retournés pour GENERAL\$1LABELS. Pour les étiquettes, vous pouvez utiliser des filtres inclusifs et exclusifs. Vous pouvez également filtrer par étiquette spécifique, par étiquette individuelle ou par catégorie d’étiquette : 
+ `LabelInclusionFilters` : utilisé pour spécifier les étiquettes que vous souhaitez inclure dans la réponse. 
+ `LabelExclusionFilters` : utilisé pour spécifier les étiquettes que vous souhaitez exclure de la réponse.
+ `LabelCategoryInclusionFilters` : utilisé pour spécifier les catégories d’étiquettes que vous souhaitez inclure dans la réponse.
+ `LabelCategoryExclusionFilters` : utilisé pour spécifier les catégories d’étiquettes que vous souhaitez exclure de la réponse.

Vous pouvez également combiner des filtres inclusifs et exclusifs en fonction de vos besoins, en excluant certaines étiquettes ou catégories et en incluant d’autres.

`NotificationChannel` est l’ARN de la rubrique Amazon SNS sur laquelle vous souhaitez que Vidéo Amazon Rekognition publie l’état d’achèvement de l’opération de détection d’étiquettes. Si vous utilisez la politique d’autorisation `AmazonRekognitionServiceRole`, le nom de la rubrique Amazon SNS doit commencer par Rekognition.

Voici un exemple de demande `StartLabelDetection` au format JSON, y compris des filtres :

```
{
    "ClientRequestToken": "5a6e690e-c750-460a-9d59-c992e0ec8638",
    "JobTag": "5a6e690e-c750-460a-9d59-c992e0ec8638",
    "Video": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "video.mp4" 
         } 
     }, 
     "Features": ["GENERAL_LABELS"],
     "MinConfidence": 75,
     "Settings": {
         "GeneralLabels": {
             "LabelInclusionFilters": ["Cat", "Dog"],
             "LabelExclusionFilters": ["Tiger"],
             "LabelCategoryInclusionFilters": ["Animals and Pets"],
             "LabelCategoryExclusionFilters": ["Popular Landmark"] 
         }
     },
     "NotificationChannel": {
         "RoleArn": "arn:aws:iam::012345678910:role/SNSAccessRole",
         "SNSTopicArn": "arn:aws:sns:us-east-1:012345678910:notification-topic",
     }
}
```

## GetLabelDetection Réponse à l'opération
<a name="getlabeldetection-operation-response"></a>

`GetLabelDetection` renvoie un tableau (`Labels`) comprenant des informations sur les étiquettes détectées dans la vidéo. Le tableau peut être trié en fonction de l’heure ou de l’étiquette détectée lors de la spécification du paramètre `SortBy`. Vous pouvez également sélectionner la manière dont les éléments de réponse sont agrégés à l’aide du paramètre `AggregateBy`. 

L’exemple suivant constitue la réponse JSON de `GetLabelDetection`. Dans la réponse, notez les points suivants :
+ **Ordre de tri** : le tableau d’étiquettes renvoyé est trié en fonction de l’heure. Pour trier par étiquette, spécifiez `NAME` dans le paramètre d’entrée `SortBy` pour `GetLabelDetection`. Si l'étiquette apparaît plusieurs fois dans la vidéo, il existera plusieurs instances de l'élément ([LabelDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_LabelDetection.html)). L’ordre de tri par défaut est `TIMESTAMP`, tandis que l’ordre de tri secondaire est `NAME`.
+ **Informations de l’étiquette** :l’élément du tableau `LabelDetection` contient un objet ([étiquette](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Label.html)) qui contient quant à lui le nom de l’étiquette et le niveau de confiance d’Amazon Rekognition dans l’exactitude de l’étiquette détectée. Un objet `Label` comprend également une taxonomie hiérarchique des étiquettes et des informations sur le cadre de délimitation pour les étiquettes communes. `Timestamp` est le temps, en millisecondes, qui s’est écoulé entre le début de la vidéo et le moment où l’étiquette a été détectée. 

  Les informations relatives aux catégories ou alias associés à une étiquette sont également renvoyées. Pour les résultats agrégés par vidéo `SEGMENTS`, les structures `StartTimestampMillis`, `EndTimestampMillis` et `DurationMillis` sont renvoyées, qui définissent respectivement l’heure de début, l’heure de fin et la durée d’un segment.
+ **Agrégation** : spécifie la manière dont les résultats sont agrégés lorsqu’ils sont renvoyés. La valeur par défaut est d’agréger par `TIMESTAMPS`. Vous pouvez également choisir d’agréger par `SEGMENTS`, ce qui permet d’agréger les résultats sur une période donnée. En cas d’agrégation par `SEGMENTS`, les informations sur les instances détectées avec des cadres de délimitation ne sont pas renvoyées. Seules les étiquettes détectées lors des segments sont renvoyées.
+ **Informations sur la pagination** :l’exemple montre une page d’informations de détection d’étiquette. Vous pouvez spécifier le nombre d’objets `LabelDetection` à renvoyer dans le paramètre d’entrée `MaxResults` de `GetLabelDetection`. Si le nombre de résultats est supérieur à `MaxResults`, `GetLabelDetection` renvoie un jeton (`NextToken`) utilisé pour obtenir la page de résultats suivante. Pour de plus amples informations, veuillez consulter [Obtenir les résultats de l’analyse de Vidéo Amazon Rekognition](api-video.md#api-video-get).
+ **Informations sur la vidéo** – La réponse comprend des informations sur le format de la vidéo (`VideoMetadata`) dans chaque page d’informations renvoyée par `GetLabelDetection`.

Voici un exemple de GetLabelDetection réponse au format JSON avec agrégation par TIMESTAMPS :

```
{  
    "JobStatus": "SUCCEEDED",
    "LabelModelVersion": "3.0",
    "Labels": [
        {
            "Timestamp": 1000,
            "Label": {
                "Name": "Car",
                "Categories": [
                  {
                    "Name": "Vehicles and Automotive"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Automobile"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875, // Classification confidence
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567         
                        },  
                        "Confidence": 99.9364013671875 // Detection confidence     
                    }    
                ]
            }
        },
        {
            "Timestamp": 1000,
            "Label": {
                "Name": "Cup",
                "Categories": [
                  {
                    "Name": "Kitchen and Dining"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Mug"
                  }
                ],
                "Parents": [],
                "Confidence": 99.9364013671875, // Classification confidence
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567         
                        },  
                        "Confidence": 99.9364013671875 // Detection confidence     
                    }    
                ]
            }
        },
        {
            "Timestamp": 2000,
            "Label": {
                "Name": "Kangaroo",
                "Categories": [
                  {
                    "Name": "Animals and Pets"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Wallaby"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Mammal"
                  }
                ],
                "Confidence": 99.9364013671875,  
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567,
                        },  
                        "Confidence": 99.9364013671875    
                    }    
                ]
            }
        },
        {
            "Timestamp": 4000,
            "Label": {
                "Name": "Bicycle",
                "Categories": [
                  {
                    "Name": "Hobbies and Interests"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Bike"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875,
                "Instances": [    
                    {        
                        "BoundingBox": {            
                            "Width": 0.26779675483703613,
                            "Height": 0.8562285900115967,
                            "Left": 0.3604024350643158,
                            "Top": 0.09245597571134567         
                        },  
                        "Confidence": 99.9364013671875     
                    }    
                ]
            }
        }
    ],
    "VideoMetadata": {
        "ColorRange": "FULL",
        "DurationMillis": 5000,
        "Format": "MP4",
        "FrameWidth": 1280,
        "FrameHeight": 720,
        "FrameRate": 24
    }
}
```

Voici un exemple de GetLabelDetection réponse au format JSON avec agrégation par SEGMENTS :

```
{  
    "JobStatus": "SUCCEEDED",
    "LabelModelVersion": "3.0",
    "Labels": [ 
        {
            "StartTimestampMillis": 225,
            "EndTimestampMillis": 3578,
            "DurationMillis": 3353,
            "Label": {
                "Name": "Car",
                "Categories": [
                  {
                    "Name": "Vehicles and Automotive"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Automobile"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875 // Maximum confidence score for Segment mode
            }
        },
        {
            "StartTimestampMillis": 7578,
            "EndTimestampMillis": 12371,
            "DurationMillis": 4793,
            "Label": {
                "Name": "Kangaroo",
                "Categories": [
                  {
                    "Name": "Animals and Pets"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Wallaby"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Mammal"
                  }
                ],
                "Confidence": 99.9364013671875
            }
        },
        {
            "StartTimestampMillis": 22225,
            "EndTimestampMillis": 22578,
            "DurationMillis": 2353,
            "Label": {
                "Name": "Bicycle",
                "Categories": [
                  {
                    "Name": "Hobbies and Interests"
                  }
                ],
                "Aliases": [
                  {
                    "Name": "Bike"
                  }
                ],
                "Parents": [
                  {
                    "Name": "Vehicle"
                  }
                ],
                "Confidence": 99.9364013671875
            }
        }
    ],
    "VideoMetadata": {
        "ColorRange": "FULL",
        "DurationMillis": 5000,
        "Format": "MP4",
        "FrameWidth": 1280,
        "FrameHeight": 720,
        "FrameRate": 24
    }
}
```

## Transformation de la GetLabelDetection réponse
<a name="getlabeldetection-transform-response"></a>

Lorsque vous récupérez des résultats avec l'opération d' GetLabelDetection API, vous aurez peut-être besoin de la structure de réponse pour imiter l'ancienne structure de réponse d'API, où les étiquettes principales et les alias figuraient dans la même liste.

L'exemple de réponse JSON trouvé dans la section précédente affiche la forme actuelle de la réponse API de GetLabelDetection.

L'exemple suivant montre la réponse précédente de l' GetLabelDetection API : 

```
{
    "Labels": [
        {
            "Timestamp": 0,
            "Label": {
                "Instances": [],
                "Confidence": 60.51791763305664,
                "Parents": [],
                "Name": "Leaf"
            }
        },
        {
            "Timestamp": 0,
            "Label": {
                "Instances": [],
                "Confidence": 99.53411102294922,
                "Parents": [],
                "Name": "Human"
            }
        },
        {
            "Timestamp": 0,
            "Label": {
                "Instances": [
                    {
                        "BoundingBox": {
                            "Width": 0.11109819263219833,
                            "Top": 0.08098889887332916,
                            "Left": 0.8881205320358276,
                            "Height": 0.9073750972747803
                        },
                        "Confidence": 99.5831298828125
                    },
                    {
                        "BoundingBox": {
                            "Width": 0.1268676072359085,
                            "Top": 0.14018426835536957,
                            "Left": 0.0003282368124928324,
                            "Height": 0.7993982434272766
                        },
                        "Confidence": 99.46029663085938
                    }
                ],
                "Confidence": 99.63411102294922,
                "Parents": [],
                "Name": "Person"
            }
        },
        .
        .   
        .

        {
            "Timestamp": 166,
            "Label": {
                "Instances": [],
                "Confidence": 73.6471176147461,
                "Parents": [
                    {
                        "Name": "Clothing"
                    }
                ],
                "Name": "Sleeve"
            }
        }
        
    ],
    "LabelModelVersion": "2.0",
    "JobStatus": "SUCCEEDED",
    "VideoMetadata": {
        "Format": "QuickTime / MOV",
        "FrameRate": 23.976024627685547,
        "Codec": "h264",
        "DurationMillis": 5005,
        "FrameHeight": 674,
        "FrameWidth": 1280
    }
}
```

Si nécessaire, vous pouvez transformer la réponse actuelle pour qu’elle suive le format de l’ancienne réponse. Vous pouvez utiliser l’exemple de code suivant pour transformer la dernière réponse d’API en structure de réponse d’API précédente : 

```
from copy import deepcopy

VIDEO_LABEL_KEY = "Labels"
LABEL_KEY = "Label"
ALIASES_KEY = "Aliases"
INSTANCE_KEY = "Instances"
NAME_KEY = "Name"

#Latest API response sample for AggregatedBy SEGMENTS
EXAMPLE_SEGMENT_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label":{
                "Name": "Person",
                "Confidence": 97.530106,
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
            "StartTimestampMillis": 0,
            "EndTimestampMillis": 500666,
            "DurationMillis": 500666
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],

            },
            "StartTimestampMillis": 6400,
            "EndTimestampMillis": 8200,
            "DurationMillis": 1800
        },
    ]
}

#Output example after the transformation for AggregatedBy SEGMENTS
EXPECTED_EXPANDED_SEGMENT_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label":{
                "Name": "Person",
                "Confidence": 97.530106,
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
            "StartTimestampMillis": 0,
            "EndTimestampMillis": 500666,
            "DurationMillis": 500666
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],

            },
            "StartTimestampMillis": 6400,
            "EndTimestampMillis": 8200,
            "DurationMillis": 1800
        },
        {
            "Timestamp": 0,
            "Label":{
                "Name": "Human",
                "Confidence": 97.530106,
                "Parents": [],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
            "StartTimestampMillis": 0,
            "EndTimestampMillis": 500666,
            "DurationMillis": 500666
        },
    ]
}

#Latest API response sample for AggregatedBy TIMESTAMPS
EXAMPLE_TIMESTAMP_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label": {
                "Name": "Person",
                "Confidence": 97.530106,
                "Instances": [
                    {
                        "BoundingBox": {
                            "Height": 0.1549897,
                            "Width": 0.07747964,
                            "Top": 0.50858885,
                            "Left": 0.00018205095
                        },
                        "Confidence": 97.530106
                    },
                ],
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Instances": [],
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],
            },
        },
    ]
}

#Output example after the transformation for AggregatedBy TIMESTAMPS
EXPECTED_EXPANDED_TIMESTAMP_OUTPUT = {
    "Labels": [
        {
            "Timestamp": 0,
            "Label": {
                "Name": "Person",
                "Confidence": 97.530106,
                "Instances": [
                    {
                        "BoundingBox": {
                            "Height": 0.1549897,
                            "Width": 0.07747964,
                            "Top": 0.50858885,
                            "Left": 0.00018205095
                        },
                        "Confidence": 97.530106
                    },
                ],
                "Parents": [],
                "Aliases": [
                    {
                        "Name": "Human"
                    },
                ],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
        },
        {
            "Timestamp": 6400,
            "Label": {
                "Name": "Leaf",
                "Confidence": 89.77790069580078,
                "Instances": [],
                "Parents": [
                    {
                        "Name": "Plant"
                    }
                ],
                "Aliases": [],
                "Categories": [
                    {
                        "Name": "Plants and Flowers"
                    }
                ],
            },
        },
        {
            "Timestamp": 0,
            "Label": {
                "Name": "Human",
                "Confidence": 97.530106,
                "Parents": [],
                "Categories": [
                    {
                        "Name": "Person Description"
                    }
                ],
            },
        },
    ]
}

def expand_aliases(inferenceOutputsWithAliases):

    if VIDEO_LABEL_KEY in inferenceOutputsWithAliases:
        expandInferenceOutputs = []
        for segmentLabelDict in inferenceOutputsWithAliases[VIDEO_LABEL_KEY]:
            primaryLabelDict = segmentLabelDict[LABEL_KEY]
            if ALIASES_KEY in primaryLabelDict:
                for alias in primaryLabelDict[ALIASES_KEY]:
                    aliasLabelDict = deepcopy(segmentLabelDict)
                    aliasLabelDict[LABEL_KEY][NAME_KEY] = alias[NAME_KEY]
                    del aliasLabelDict[LABEL_KEY][ALIASES_KEY]
                    if INSTANCE_KEY in aliasLabelDict[LABEL_KEY]:
                        del aliasLabelDict[LABEL_KEY][INSTANCE_KEY]
                    expandInferenceOutputs.append(aliasLabelDict)

        inferenceOutputsWithAliases[VIDEO_LABEL_KEY].extend(expandInferenceOutputs)

    return inferenceOutputsWithAliases


if __name__ == "__main__":

    segmentOutputWithExpandAliases = expand_aliases(EXAMPLE_SEGMENT_OUTPUT)
    assert segmentOutputWithExpandAliases == EXPECTED_EXPANDED_SEGMENT_OUTPUT

    timestampOutputWithExpandAliases = expand_aliases(EXAMPLE_TIMESTAMP_OUTPUT)
    assert timestampOutputWithExpandAliases == EXPECTED_EXPANDED_TIMESTAMP_OUTPUT
```

# Détection d’étiquettes dans des événements vidéo en streaming
<a name="streaming-video-detect-labels"></a>

Vous pouvez utiliser Vidéo Amazon Rekognition pour détecter les étiquettes dans les vidéos en streaming. Pour ce faire, vous créez un processeur de flux ([CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)) pour démarrer et gérer l'analyse du streaming vidéo. 

Vidéo Amazon Rekognition utilise Amazon Kinesis Video Streams pour recevoir et traiter un flux vidéo. Lorsque vous créez le processeur de flux, vous choisissez ce que le processeur de flux doit détecter. Vous pouvez choisir des personnes, des forfaits et des animaux de compagnie, ou des personnes et des forfaits. Les résultats d’analyse sont envoyés dans votre compartiment Amazon S3 et dans les notifications Amazon SNS. Notez que Vidéo Amazon Rekognition détecte la présence d’une personne dans la vidéo, mais ne détecte pas s’il s’agit d’une personne en particulier. Pour rechercher un visage dans une collection dans une vidéo en streaming, voir [Recherche de visages dans une collection en vidéo streaming](collections-streaming.md). 

Pour utiliser Vidéo Amazon Rekognition avec du streaming vidéo, votre application a besoin des éléments suivants :
+ Un flux vidéo Kinesis pour envoyer des vidéos en streaming à Vidéo Amazon Rekognition. Pour plus d’informations, consultez le [Guide du développeur Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Un processeur de flux Vidéo Amazon Rekognition pour gérer l’analyse de la vidéo en streaming. Pour de plus amples informations, veuillez consulter [Présentation des opérations du processeur de flux Vidéo Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor).
+ Un compartiment Amazon S3. Vidéo Amazon Rekognition publie le résultat de la session dans le compartiment S3. La sortie inclut le cadre d’image dans lequel une personne ou un objet d’intérêt a été détecté pour la première fois. Vous devez être propriétaire du compartiment S3.
+ Rubrique Amazon SNS dans laquelle Amazon Rekognition Video publie des alertes intelligentes et un résumé. end-of-session

**Topics**
+ [Configuration de vos ressources Vidéo Amazon Rekognition et Amazon Kinesis](streaming-labels-setting-up.md)
+ [Opérations de détection des étiquettes d'appel pour les événements vidéo en streaming](streaming-labels-detection.md)

# Configuration de vos ressources Vidéo Amazon Rekognition et Amazon Kinesis
<a name="streaming-labels-setting-up"></a>

 Les procédures suivantes décrivent les étapes à suivre pour approvisionner le flux vidéo Kinesis et les autres ressources utilisées pour détecter les étiquettes dans une vidéo en streaming.

## Conditions préalables
<a name="streaming-video-prerequisites"></a>

Pour exécuter cette procédure, vous AWS SDK pour Java devez être installé. Pour de plus amples informations, veuillez consulter [Premiers pas avec Amazon Rekognition](getting-started.md). Le compte AWS que vous utilisez nécessite des autorisations d’accès à l’API Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Actions définies par Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) dans le *Guide de l’utilisateur IAM*. 

**Pour détecter les étiquettes dans un flux vidéo (AWS SDK)**

1. Créez un compartiment Amazon S3. Notez le nom du compartiment et les préfixes de la clé que vous souhaitez utiliser. Vous aurez besoin de ces informations ultérieurement.

1. Créer une rubrique Amazon SNS. Vous pouvez l’utiliser pour recevoir des notifications lorsqu’un objet d’intérêt est détecté pour la première fois dans le flux vidéo. Notez l’Amazon Resource Name ARN) de la rubrique. Pour plus d’informations, consultez [Création d’une règle Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html) dans le Guide du développeur Amazon SNS.

1. Abonner un point de terminaison à une rubrique Amazon SNS. Pour plus d’informations, consultez [Abonnement à une rubrique Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) dans le Guide du développeur Amazon SNS.

1. [Créez un flux vidéo Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) et notez l’Amazon Resource Name (ARN) du flux.

1. Si ce n’est pas déjà fait, créez une fonction de service IAM pour permettre à Vidéo Amazon Rekognition d’accéder à vos flux vidéo Kinesis, à votre compartiment S3 et à votre rubrique Amazon SNS. Pour de plus amples informations, veuillez consulter [Donner accès aux processeurs de flux de détection d’étiquettes](#streaming-labels-giving-access).

Vous pouvez ensuite [créer le processeur de flux de détection d’étiquettes](streaming-labels-detection.md#streaming-video-create-labels-stream-processor) et [démarrer le processeur de flux](streaming-labels-detection.md#streaming-video-start-labels-stream-processor) en utilisant le nom de processeur de flux que vous avez choisi.

**Note**  
Démarrez le processeur de flux uniquement après avoir vérifié que vous pouvez intégrer du contenu multimédia dans le flux vidéo Kinesis. 

## Orientation et configuration de la caméra
<a name="streaming-labels-camera-setup"></a>

Vidéo Amazon Rekognition Streaming Video Events est compatible avec toutes les caméras compatibles avec Kinesis Video Streams. Pour de meilleurs résultats, nous recommandons de placer la caméra entre 0 et 45 degrés par rapport au sol. La caméra doit être dans sa position verticale canonique. Par exemple, s’il y a une personne dans le cadre, celle-ci doit être orientée verticalement et la tête de la personne doit être plus haute dans le cadre que les pieds.

## Donner accès aux processeurs de flux de détection d’étiquettes
<a name="streaming-labels-giving-access"></a>

Vous utilisez un rôle de service Gestion des identités et des accès AWS (IAM) pour donner à Amazon Rekognition Video un accès en lecture aux flux vidéo Kinesis. Pour ce faire, utilisez les rôles IAM pour permettre à Vidéo Amazon Rekognition d’accéder à votre compartiment Amazon S3 et à une rubrique Amazon SNS.

Vous pouvez créer une politique d’autorisation qui autorise Vidéo Amazon Rekognition à accéder à une rubrique Amazon SNS, à un compartiment Amazon S3 et à un flux vidéo Kinesis existants. Pour une step-by-step procédure utilisant le AWS CLI, voir[AWS CLI commandes pour configurer un rôle IAM de détection d'étiquettes](#streaming-labels-giving-access-cli). 

**Pour permettre à Vidéo Amazon Rekognition d’accéder aux ressources de détection des étiquettes**

1. [ Créez une nouvelle stratégie d’autorisations avec l’éditeur de stratégie JSON IAM;](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor), et utilisez la stratégie suivante. Remplacez `kvs-stream-name` par le nom du flux vidéo Kinesis, remplacez `topicarn` par l’Amazon Ressource Name (ARN) de la rubrique Amazon SNS que vous souhaitez utiliser, et remplacez `bucket-name` par le nom du compartiment Amazon S3.

1. [Créez une fonction du service IAM;](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console), ou mettez à jour une fonction du service IAM existant. Utilisez les informations suivantes pour créer la fonction du service IAM :

   1. Choisissez **Rekognition** pour le nom du service.

   1. Choisissez **Rekognition** pour le cas d’utilisation de la fonction de service.

   1. Attachez la stratégie d’autorisations que vous avez créée à l’étape 1.

1. Notez l’ARN de la fonction de service. Vous en avez besoin pour créer le processeur de flux avant d’effectuer des opérations d’analyse vidéo.

1. (Facultatif) Si vous utilisez votre propre AWS KMS clé pour chiffrer les données envoyées à votre compartiment S3, vous devez ajouter l'instruction suivante avec le rôle IAM. (Il s’agit du rôle IAM que vous avez créé pour la stratégie de clé, qui correspond à la clé gérée par le client que vous souhaitez utiliser.)

   ```
       
               {
                          "Sid": "Allow use of the key by label detection Role",
                          "Effect": "Allow",
                          "Principal": {
                              "AWS": "arn:aws:iam:::role/REPLACE_WITH_LABEL_DETECTION_ROLE_CREATED"
                          },
                          "Action": [
                              "kms:Decrypt",
                              "kms:GenerateDataKey*"
                          ],
                          "Resource": "*"
               }
   ```

## AWS CLI commandes pour configurer un rôle IAM de détection d'étiquettes
<a name="streaming-labels-giving-access-cli"></a>

Si ce n'est pas déjà fait, configurez et configurez le AWS CLI avec vos informations d'identification.

Entrez les commandes suivantes dans le AWS CLI pour configurer un rôle IAM doté des autorisations nécessaires à la détection des étiquettes.

1. `export IAM_ROLE_NAME=labels-test-role`

1. `export AWS_REGION=us-east-1`

1. Créez un fichier de politique de relation de confiance (par exemple, assume-role-rekognition .json) avec le contenu suivant.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "",
         "Effect": "Allow",
         "Principal": {
           "Service": "rekognition.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

1. `aws iam create-role --role-name $IAM_ROLE_NAME --assume-role-policy-document file://path-to-assume-role-rekognition.json --region $AWS_REGION`

1. `aws iam attach-role-policy --role-name $IAM_ROLE_NAME --policy-arn "arn:aws:iam::aws:policy/service-role/AmazonRekognitionServiceRole" --region $AWS_REGION`

1. Si le nom de la rubrique SNS pour laquelle vous souhaitez recevoir des notifications ne commence pas par le préfixe « AmazonRekognition », ajoutez la politique suivante :

   `aws iam attach-role-policy --role-name $IAM_ROLE_NAME --policy-arn "arn:aws:iam::aws:policy/AmazonSNSFullAccess" --region $AWS_REGION`

1. Si vous utilisez votre propre clé AWS KMS pour chiffrer les données envoyées à votre compartiment Amazon S3, mettez à jour la stratégie de clé gérée par le client que vous souhaitez utiliser.

   1. Créez un fichier kms\$1key\$1policy.json contenant le contenu suivant :

      ```
      {
      "Sid": "Allow use of the key by label detection Role",
      "Effect": "Allow",
      "Principal": {
      "AWS": "arn:aws:iam:::role/REPLACE_WITH_IAM_ROLE_NAME_CREATED"
      },
      "Action": [
      "kms:Encrypt",
      "kms:GenerateDataKey*"
      ],
      "Resource": "*"
      }
      ```

   1. `export KMS_KEY_ID=labels-kms-key-id`. Remplacez KMS\$1KEY\$1ID par l’ID de clé KMS que vous avez créé.

   1. `aws kms put-key-policy --policy-name default --key-id $KMS_KEY_ID --policy file://path-to-kms-key-policy.json`

# Opérations de détection des étiquettes d'appel pour les événements vidéo en streaming
<a name="streaming-labels-detection"></a>

Vidéo Amazon Rekognition peut détecter des personnes ou des objets pertinents dans une vidéo en streaming et vous avertir lorsqu’ils sont détectés. Lorsque vous créez un processeur de flux de détection d’étiquettes, choisissez les étiquettes que vous souhaitez que Vidéo Amazon Rekognition détecte. Il peut s’agir de personnes, de colis et d’animaux domestiques, ou de personnes, de colis et d’animaux domestiques. Choisissez uniquement les étiquettes spécifiques que vous souhaitez détecter. Ainsi, les seules étiquettes pertinentes créent des notifications. Vous pouvez configurer des options pour déterminer quand stocker les informations vidéo, puis effectuer un traitement supplémentaire en fonction des étiquettes détectées dans l’image.

Une fois que vous avez configuré vos ressources, le processus de détection des libellés dans une vidéo en streaming est le suivant :

1. Créez le processeur de flux.

1. Démarrage du processeur de flux

1. Si un objet d’intérêt est détecté, vous recevez une notification Amazon SNS pour la première occurrence de chaque objet d’intérêt.

1. Le processeur de flux s’arrête lorsque le temps spécifié dans `MaxDurationInSeconds` est écoulé.

1. Vous recevez une notification Amazon SNS finale avec un résumé de l’événement.

1. Vidéo Amazon Rekognition publie un résumé détaillé de la session dans votre compartiment S3.

**Topics**
+ [Création du processeur de flux de détection d’étiquettes Vidéo Amazon Rekognition](#streaming-video-create-labels-stream-processor)
+ [Démarrage du processeur de flux de détection d’étiquettes Vidéo Amazon Rekognition](#streaming-video-start-labels-stream-processor)
+ [Analyse des résultats de détection des étiquettes](#streaming-video-labels-stream-processor-results)

## Création du processeur de flux de détection d’étiquettes Vidéo Amazon Rekognition
<a name="streaming-video-create-labels-stream-processor"></a>

Avant de pouvoir analyser une vidéo en streaming, vous devez créer un processeur de streaming Amazon Rekognition Video (). [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)

Si vous souhaitez créer un processeur de flux pour détecter les étiquettes qui vous intéressent et les personnes, fournissez en entrée un flux vidéo Kinesis (`Input`), des informations sur le compartiment Amazon S3 (`Output`) et un ARN de rubrique Amazon SNS (`StreamProcessorNotificationChannel`). Vous pouvez également fournir un ID de clé KMS pour chiffrer les données envoyées à votre compartiment S3. Vous spécifiez ce que vous souhaitez détecter dans `Settings`, comme les personnes, les colis et les personnes, ou les animaux domestiques, les personnes et les colis. Vous pouvez également spécifier l’endroit du cadre que vous souhaitez qu’Amazon Rekognition surveille avec `RegionsOfInterest`. L’exemple suivant est un exemple JSON de requête `CreateStreamProcessor`.

```
{
  "DataSharingPreference": { "OptIn":TRUE
  },
  "Input": {
    "KinesisVideoStream": {
      "Arn": "arn:aws:kinesisvideo:us-east-1:nnnnnnnnnnnn:stream/muh_video_stream/nnnnnnnnnnnnn"
    }
  },
  "KmsKeyId": "muhkey",
  "Name": "muh-default_stream_processor",
  "Output": {
    "S3Destination": {
      "Bucket": "s3bucket",
      "KeyPrefix": "s3prefix"
    }
  },
  "NotificationChannel": {
    "SNSTopicArn": "arn:aws:sns:us-east-2:nnnnnnnnnnnn:MyTopic"
  },
  "RoleArn": "arn:aws:iam::nnnnnnnnn:role/Admin",
  "Settings": {
    "ConnectedHome": {
      "Labels": [
        "PET"
      ]
    "MinConfidence": 80
    }
  },
  "RegionsOfInterest": [
    {
      "BoundingBox": {
        "Top": 0.11,
        "Left": 0.22,
        "Width": 0.33,
        "Height": 0.44
      }
    },
    {
      "Polygon": [
        {
          "X": 0.11,
          "Y": 0.11
        },
        {
          "X": 0.22,
          "Y": 0.22
        },
        {
          "X": 0.33,
          "Y": 0.33
        }
      ]
    }
  ]
}
```

Notez que vous pouvez modifier la valeur `MinConfidence` lorsque vous spécifiez le `ConnectedHomeSettings` pour le processeur de flux. `MinConfidence` est une valeur numérique comprise entre 0 et 100 qui indique dans quelle mesure l’algorithme est certain de ses prédictions. Par exemple, une notification `person` avec une valeur de confiance de 90 signifie que l’algorithme est absolument certain que la personne est présente dans la vidéo. Une valeur de confiance de 10 indique qu’il pourrait y avoir une personne. Vous pouvez définir `MinConfidence` à la valeur de votre choix comprise entre 0 et 100 en fonction de la fréquence à laquelle vous souhaitez être averti. Par exemple, si vous souhaitez être averti uniquement lorsque Rekognition est absolument certaine de la présence d’un package dans l’image vidéo, vous pouvez définir `MinConfidence` à la valeur 90.

Par défaut, `MinConfidence ` est défini à 50. Si vous souhaitez optimiser l’algorithme pour une plus grande précision, vous pouvez définir `MinConfidence` à une valeur supérieure à 50. Vous recevez alors moins de notifications, mais chaque notification est plus fiable. Si vous souhaitez optimiser l’algorithme pour augmenter le taux de rappel, vous pouvez régler `MinConfidence` à une valeur inférieure à 50 pour recevoir davantage de notifications. 

## Démarrage du processeur de flux de détection d’étiquettes Vidéo Amazon Rekognition
<a name="streaming-video-start-labels-stream-processor"></a>

Pour démarrer l'analyse de vidéo en streaming, appelez [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) avec le nom de processeur de flux que vous avez spécifié dans `CreateStreamProcessor`. Lorsque vous exécutez l’opération `StartStreamProcessor` sur un processeur de flux de détection d’étiquettes, vous saisissez des informations de démarrage et d’arrêt pour déterminer le temps de traitement.

Lorsque vous démarrez le processeur de flux, l’état du processeur de flux de détection d’étiquettes change de la manière suivante :

1. Lorsque vous appelez `StartStreamProcessor`, l’état du processeur de flux de détection d’étiquettes passe de `STOPPED` ou `FAILED` vers `STARTING`.

1. Lorsque le processeur de flux de détection d’étiquettes fonctionne, il reste actif dans `STARTING`.

1. Lorsque le processeur de flux de détection d’étiquettes a terminé de fonctionner, l’état devient soit `STOPPED` ou `FAILED`.

Le `StartSelector` spécifie le point de départ du flux Kinesis pour démarrer le traitement. Vous pouvez utiliser l’horodatage du producteur KVS ou le numéro du fragment KVS. Pour de plus amples informations, veuillez consulter [Fragment](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_reader_Fragment.html).

**Note**  
Si vous utilisez l’horodatage KVS Producer, vous devez saisir l’heure en millisecondes.

Le `StopSelector` spécifie quand arrêter le traitement du flux. Vous pouvez spécifier la durée maximale de traitement de la vidéo. La durée par défaut est 10 secondes maximum. Notez que le temps de traitement réel peut être légèrement supérieur à la durée maximale, en fonction de la taille des fragments KVS individuels. Si la durée maximale est atteinte ou dépassée à la fin d’un fragment, le temps de traitement s’arrête. 

L’exemple suivant est un exemple JSON de requête `StartStreamProcessor`.

```
{
   "Name": "string",
   "StartSelector": {
     "KVSStreamStartSelector": { 
         "KVSProducerTimestamp": 1655930623123
      },
        "StopSelector": {
            "MaxDurationInSeconds": 11
      }
   }
}
```

Si le processeur de flux démarre avec succès, une réponse HTTP 200 est renvoyée. Un corps JSON vide est inclus.

## Analyse des résultats de détection des étiquettes
<a name="streaming-video-labels-stream-processor-results"></a>

Amazon Rekognition Video publie les notifications depuis un processeur de flux de détection d'étiquettes de trois manières : des notifications Amazon SNS pour les événements de détection d'objets, une notification Amazon SNS pour un résumé end-of-session et un rapport détaillé sur le compartiment Amazon S3. 
+ Notifications Amazon SNS pour les événements de détection d’objets. 

  Si des étiquettes sont détectées dans le flux vidéo, vous recevez des notifications Amazon SNS pour les événements de détection d’objets. Amazon Rekognition publie une notification la première fois qu’un objet d’intérêt ou une personne est détecté dans le flux vidéo. Les notifications incluent des informations telles que le type d’étiquette détecté, le niveau de confiance et un lien vers l’image du héros. Elles incluent également une image recadrée de la personne ou de l’objet détecté et un horodatage de détection. La notification de test a le format suivant :

  ```
  {"Subject": "Rekognition Stream Processing Event",
      "Message": {    
          "inputInformation": {
              "kinesisVideo": {
                  "streamArn": string
              }
          },
          "eventNamespace": {
              "type": "LABEL_DETECTED"
          },
          "labels": [{
              "id": string,
              "name": "PERSON" | "PET" | "PACKAGE",
              "frameImageUri": string,
              "croppedImageUri": string,
              "videoMapping": {
                  "kinesisVideoMapping": {
                      "fragmentNumber": string,
                      "serverTimestamp": number,
                      "producerTimestamp": number,
                      "frameOffsetMillis": number
                  }
              },
              "boundingBox": {
                  "left": number,
                  "top": number,
                  "height": number,
                  "width": number
              }
          }],
          "eventId": string,
          "tags": {
              [string]: string
          },
          "sessionId": string,
          "startStreamProcessorRequest": object
      }
  }
  ```
+ Résumé d'Amazon SNS. end-of-session

  Vous recevez également une notification Amazon SNS à la fin de la session de traitement du flux. Cette notification répertorie les métadonnées de la session. Cela inclut des détails tels que la durée du flux traité. La notification de test a le format suivant :

  ```
  {"Subject": "Rekognition Stream Processing Event",
      "Message": {
          "inputInformation": {
              "kinesisVideo": {
                  "streamArn": string,
                  "processedVideoDurationMillis": number
              }
          },
          "eventNamespace": {
              "type": "STREAM_PROCESSING_COMPLETE"
          },
          "streamProcessingResults": {
              "message": string
          },
          "eventId": string,
          "tags": {
              [string]: string
          },
          "sessionId": string,
          "startStreamProcessorRequest": object
      }
  }
  ```
+ Rapport sur le compartiment Amazon S3.

  Vidéo Amazon Rekognition publie les résultats d’inférence détaillés d’une opération d’analyse vidéo vers le compartiment Amazon S3 fournis dans l’opération `CreateStreamProcessor`. Ces résultats incluent des cadres d’image dans lesquels un objet d’intérêt ou une personne a été détecté pour la première fois. 

  Les cadres sont disponibles dans S3 dans le chemin suivant : ObjectKeyPrefix/StreamProcessorName/SessionId/*service\$1determined\$1unique\$1path*. Dans ce chemin, **LabelKeyPrefix**se trouvent un argument facultatif fourni par le client, **StreamProcessorName**le nom de la ressource du processeur de flux et **SessionId**un identifiant unique pour la session de traitement de flux. Remplacez-les en fonction de votre situation.

# Détection des étiquettes personnalisées
<a name="labels-detecting-custom-labels"></a>

Les étiquettes personnalisées Amazon Rekognition peuvent identifier les objets et les scènes dans des images spécifiques aux besoins de votre entreprise, telles que les logos ou les pièces de machines d’ingénierie. Pour de plus amples informations, veuillez consulter [What Is Amazon Rekognition Custom Labels?](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html) dans le manuel * Guide du développeur d’étiquettes personnalisées Amazon Rekognition*.