Filtrage des visages IndexFaces demande d'opération IndexFaces réponse à l'opération

Ajout de visages à une collection

Vous pouvez utiliser cette IndexFacesopération pour détecter des visages dans une image et les ajouter à une collection. Pour chaque visage détecté, Amazon Rekognition extrait les caractéristiques faciales et stocke ces informations dans une base de données. Par ailleurs, la commande stocke les métadonnées de chaque visage détecté dans la collection de visages spécifiée. Amazon Rekognition ne stocke pas les octets d’image réels.

Pour en savoir plus sur la fourniture de visages adaptés pour l’indexation, consultez Recommandations pour les images d’entrée de comparaison faciale.

Pour chaque visage, l’opération IndexFaces conserve les informations suivantes :

Caractéristiques faciales multidimensionnelles : IndexFaces utilise l’analyse du visage pour extraire des informations multidimensionnelles sur les traits du visage et stocke ces informations dans la collection de visages. Vous ne pouvez pas accéder directement à ces informations. Cependant, Amazon Rekognition utilise ces informations lors de la recherche de correspondances dans une collection de visages.
Métadonnées : les métadonnées de chaque visage incluent un cadre de référence, un niveau de confiance (que le cadre contient un visage), IDs attribué par Amazon Rekognition (identifiant du visage et identifiant de l'image), et un identifiant d'image externe (si vous l'avez fourni) dans la demande. Ces informations vous sont renvoyées en réponse à l'IndexFacesAPIappel. Pour obtenir un exemple, consultez l’élément face dans l’exemple de réponse suivant.

Le service renvoie ces métadonnées en réponse aux API appels suivants :
- ListFaces
- Opérations de recherche de visages : les réponses SearchFaces SearchFacesByImageet le niveau de confiance dans la correspondance pour chaque visage correspondant, ainsi que les métadonnées du visage correspondant.

Le nombre de visages indexés par IndexFaces dépend de la version du modèle de détection de visages qui est associée à la collection d’entrée. Pour de plus amples informations, veuillez consulter Comprendre le versionnement des modèles.

Les informations relatives aux visages indexés sont renvoyées dans un tableau d'FaceRecordobjets.

Vous pouvez associer des visages indexés à l’image sur laquelle ils ont été détectés. Par exemple, vous pouvez gérer un index côté client composé d’images et de visages présents sur celles-ci. Pour associer des visages à une image, spécifiez l’identifiant de l’image dans le paramètre de la demande ExternalImageId. L’ID de l’image peut être le nom de fichier ou un autre ID que vous créez.

Outre les informations précédentes selon lesquelles le visage est conservé API dans la collection de visages, le renvoie API également les détails du visage qui ne sont pas conservés dans la collection. (Consultez l’élément faceDetail dans l’exemple de réponse suivant).

Note

DetectFaces renvoie les mêmes informations, ce qui signifie que vous n’avez pas besoin d’appeler DetectFaces et IndexFaces pour la même image.

Filtrage des visages

L' IndexFaces opération permet de filtrer les visages indexés à partir d'une image. Avec IndexFaces, vous pouvez spécifier un nombre maximal de visages à indexer, ou vous pouvez choisir d’indexer uniquement les visages détectés avec une haute qualité.

Vous pouvez spécifier le nombre maximal de visages indexés par IndexFaces à l’aide du paramètre d’entrée MaxFaces. Cela s’avère utile lorsque vous souhaitez indexer les plus grands visages d’une image et pas les plus petits, comme ceux des personnes debout en arrière-plan.

Par défaut, choisit une barre de qualité IndexFaces utilisée pour filtrer les visages. Vous pouvez utiliser le paramètre d’entrée QualityFilter pour définir explicitement la barre de qualité. Les valeurs sont :

AUTO : Amazon Rekognition choisit la barre de qualité utilisée pour filtrer les visages (valeur par défaut).
LOW : tous les visages, à l’exception des visages de qualité inférieure, sont indexés.
MEDIUM
HIGH : seuls les visages de qualité supérieure sont indexés.
NONE : aucun visage n’est filtré en fonction de la qualité.

IndexFaces filtre les visages pour les raisons suivantes :

Le visage est trop petit par rapport aux dimensions de l’image.
Le visage est trop flou.
L’image est trop sombre.
Le visage prend un pose extrême.
Le visage n’est pas suffisamment détaillé pour la recherche de visage.

Note

Pour utiliser le filtrage de qualité, vous avez besoin d’une collection associée à la version 3, ou ultérieure, du modèle facial. Pour obtenir la version du modèle de visage associé à une collection, appelez DescribeCollection.

Les informations sur les visages qui ne sont pas indexés par IndexFaces sont renvoyées dans un tableau d'UnindexedFaceobjets. Le tableau Reasons contient une liste des raisons pour lesquelles un visage n’est pas indexé. Par exemple, la valeur EXCEEDS_MAX_FACES correspond à un visage qui n’est pas indexé, car le nombre de visages spécifié par MaxFaces a déjà été détecté.

Pour de plus amples informations, veuillez consulter Gestion des visages dans une collection.

Pour ajouter des visages à une collection (SDK)

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 : créer un AWS compte et créer un utilisateur.
2. Installez et configurez le AWS CLI et le AWS SDKs. Pour de plus amples informations, veuillez consulter Étape 2 : configurer le AWS CLI and AWS SDKs.
Chargez une image (contenant un ou plusieurs visages) dans votre compartiment Amazon S3.

Pour en savoir plus, consultez Téléchargement d'objets dans Amazon S3 dans le Guide de l’utilisateur Amazon Simple Storage Service.

Utilisez les exemples suivants pour appeler l’opération IndexFaces.

Java

Cet exemple affiche les identificateurs de visage pour les visages ajoutés à la collection.

Remplacez la valeur de collectionId par le nom de la collection à laquelle vous souhaitez ajouter un visage. Remplacez la valeur de bucket et de photo par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. Le paramètre .withMaxFaces(1) limite le nombre de visages indexés à 1. Supprimez ou modifiez sa valeur en fonction de vos besoins.


//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.)

package aws.example.rekognition.image;

import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.FaceRecord;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.IndexFacesRequest;
import com.amazonaws.services.rekognition.model.IndexFacesResult;
import com.amazonaws.services.rekognition.model.QualityFilter;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.UnindexedFace;
import java.util.List;

public class AddFacesToCollection {
    public static final String collectionId = "MyCollection";
    public static final String bucket = "bucket";
    public static final String photo = "input.jpg";

    public static void main(String[] args) throws Exception {

        AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();

        Image image = new Image()
                .withS3Object(new S3Object()
                .withBucket(bucket)
                .withName(photo));
        
        IndexFacesRequest indexFacesRequest = new IndexFacesRequest()
                .withImage(image)
                .withQualityFilter(QualityFilter.AUTO)
                .withMaxFaces(1)
                .withCollectionId(collectionId)
                .withExternalImageId(photo)
                .withDetectionAttributes("DEFAULT");

        IndexFacesResult indexFacesResult = rekognitionClient.indexFaces(indexFacesRequest);
        
        System.out.println("Results for " + photo);
        System.out.println("Faces indexed:");
        List<FaceRecord> faceRecords = indexFacesResult.getFaceRecords();
        for (FaceRecord faceRecord : faceRecords) {
            System.out.println("  Face ID: " + faceRecord.getFace().getFaceId());
            System.out.println("  Location:" + faceRecord.getFaceDetail().getBoundingBox().toString());
        }
        
        List<UnindexedFace> unindexedFaces = indexFacesResult.getUnindexedFaces();
        System.out.println("Faces not indexed:");
        for (UnindexedFace unindexedFace : unindexedFaces) {
            System.out.println("  Location:" + unindexedFace.getFaceDetail().getBoundingBox().toString());
            System.out.println("  Reasons:");
            for (String reason : unindexedFace.getReasons()) {
                System.out.println("   " + reason);
            }
        }
    }
}

Java V2

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


//snippet-start:[rekognition.java2.add_faces_collection.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.IndexFacesResponse;
import software.amazon.awssdk.services.rekognition.model.IndexFacesRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.QualityFilter;
import software.amazon.awssdk.services.rekognition.model.Attribute;
import software.amazon.awssdk.services.rekognition.model.FaceRecord;
import software.amazon.awssdk.services.rekognition.model.UnindexedFace;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.Reason;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
//snippet-end:[rekognition.java2.add_faces_collection.import]

/**
* 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 AddFacesToCollection {

 public static void main(String[] args) {

     final String usage = "\n" +
         "Usage: " +
         "    <collectionId> <sourceImage>\n\n" +
         "Where:\n" +
         "    collectionName - The name of the collection.\n" +
         "    sourceImage - The path to the image (for example, C:\\AWS\\pic1.png). \n\n";

     if (args.length != 2) {
         System.out.println(usage);
         System.exit(1);
     }

     String collectionId = args[0];
     String sourceImage = args[1];
     Region region = Region.US_EAST_1;
     RekognitionClient rekClient = RekognitionClient.builder()
         .region(region)
         .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
         .build();

     addToCollection(rekClient, collectionId, sourceImage);
     rekClient.close();
 }

 // snippet-start:[rekognition.java2.add_faces_collection.main]
 public static void addToCollection(RekognitionClient rekClient, String collectionId, String sourceImage) {

     try {
         InputStream sourceStream = new FileInputStream(sourceImage);
         SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
         Image souImage = Image.builder()
             .bytes(sourceBytes)
             .build();

         IndexFacesRequest facesRequest = IndexFacesRequest.builder()
             .collectionId(collectionId)
             .image(souImage)
             .maxFaces(1)
             .qualityFilter(QualityFilter.AUTO)
             .detectionAttributes(Attribute.DEFAULT)
             .build();

         IndexFacesResponse facesResponse = rekClient.indexFaces(facesRequest);
         System.out.println("Results for the image");
         System.out.println("\n Faces indexed:");
         List<FaceRecord> faceRecords = facesResponse.faceRecords();
         for (FaceRecord faceRecord : faceRecords) {
             System.out.println("  Face ID: " + faceRecord.face().faceId());
             System.out.println("  Location:" + faceRecord.faceDetail().boundingBox().toString());
         }

         List<UnindexedFace> unindexedFaces = facesResponse.unindexedFaces();
         System.out.println("Faces not indexed:");
         for (UnindexedFace unindexedFace : unindexedFaces) {
             System.out.println("  Location:" + unindexedFace.faceDetail().boundingBox().toString());
             System.out.println("  Reasons:");
             for (Reason reason : unindexedFace.reasons()) {
                 System.out.println("Reason:  " + reason);
             }
         }

     } catch (RekognitionException | FileNotFoundException e) {
         System.out.println(e.getMessage());
         System.exit(1);
     }
 }
 // snippet-end:[rekognition.java2.add_faces_collection.main]
}

AWS CLI

Cette AWS CLI commande affiche le JSON résultat de l'index-facesCLIopération.

Remplacez la valeur de collection-id par le nom de la collection dans laquelle vous souhaitez stocker le visage. Remplacez la valeur de Bucket et de Name par le compartiment Amazon S3, et le fichier image utilisé à l’étape 2. Le paramètre max-faces limite le nombre de visages indexés à 1. Supprimez ou modifiez sa valeur en fonction de vos besoins. 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.


aws rekognition index-faces --image '{"S3Object":{"Bucket":"bucket-name","Name":"file-name"}}' --collection-id "collection-id" \
                                --max-faces 1 --quality-filter "AUTO" --detection-attributes "ALL" \ 
                                --external-image-id "example-image.jpg" --profile profile-name

Si vous y accédez CLI sur un appareil Windows, utilisez des guillemets doubles au lieu de guillemets simples et évitez les guillemets doubles intérieurs par une barre oblique inverse (c'est-à-dire \) pour corriger les erreurs d'analyse que vous pourriez rencontrer. Pour un exemple, consultez ce qui suit :


aws rekognition index-faces --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" \
--collection-id "collection-id" --max-faces 1 --quality-filter "AUTO" --detection-attributes "ALL" \ 
--external-image-id "example-image.jpg" --profile profile-name

Python

Cet exemple affiche les identificateurs de visage pour les visages ajoutés à la collection.

Remplacez la valeur de collectionId par le nom de la collection à laquelle vous souhaitez ajouter un visage. Remplacez la valeur de bucket et de photo par le nom du compartiment Amazon S3 et le nom de l’image utilisés à l’étape 2. Le paramètre d’entrée MaxFaces limite le nombre de visages indexés à 1. Supprimez ou modifiez sa valeur en fonction de vos besoins. 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 add_faces_to_collection(bucket, photo, collection_id):

    session = boto3.Session(profile_name='profile-name')
    client = session.client('rekognition')

    response = client.index_faces(CollectionId=collection_id,
                                  Image={'S3Object': {'Bucket': bucket, 'Name': photo}},
                                  ExternalImageId=photo,
                                  MaxFaces=1,
                                  QualityFilter="AUTO",
                                  DetectionAttributes=['ALL'])

    print('Results for ' + photo)
    print('Faces indexed:')
    for faceRecord in response['FaceRecords']:
        print('  Face ID: ' + faceRecord['Face']['FaceId'])
        print('  Location: {}'.format(faceRecord['Face']['BoundingBox']))

    print('Faces not indexed:')
    for unindexedFace in response['UnindexedFaces']:
        print(' Location: {}'.format(unindexedFace['FaceDetail']['BoundingBox']))
        print(' Reasons:')
        for reason in unindexedFace['Reasons']:
            print('   ' + reason)
    return len(response['FaceRecords'])

def main():
    bucket = 'bucket-name'
    collection_id = 'collection-id'
    photo = 'photo-name'

    indexed_faces_count = add_faces_to_collection(bucket, photo, collection_id)
    print("Faces indexed count: " + str(indexed_faces_count))

if __name__ == "__main__":
    main()

.NET

Cet exemple affiche les identificateurs de visage pour les visages ajoutés à la collection.


//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 System.Collections.Generic;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;

public class AddFaces
{
    public static void Example()
    {
        String collectionId = "MyCollection";
        String bucket = "bucket";
        String photo = "input.jpg";

        AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

        Image image = new Image()
        {
            S3Object = new S3Object()
            {
                Bucket = bucket,
                Name = photo
            }
        };

        IndexFacesRequest indexFacesRequest = new IndexFacesRequest()
        {
            Image = image,
            CollectionId = collectionId,
            ExternalImageId = photo,
            DetectionAttributes = new List<String>(){ "ALL" }
        };

        IndexFacesResponse indexFacesResponse = rekognitionClient.IndexFaces(indexFacesRequest);

        Console.WriteLine(photo + " added");
        foreach (FaceRecord faceRecord in indexFacesResponse.FaceRecords)
            Console.WriteLine("Face detected: Faceid is " +
               faceRecord.Face.FaceId);
    }
}

IndexFaces demande d'opération

La valeur d’entrée de IndexFaces est l’image à indexer et la collection à laquelle ajouter le ou les visages.


{
    "CollectionId": "MyCollection",
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "input.jpg"
        }
    },
    "ExternalImageId": "input.jpg",
    "DetectionAttributes": [
        "DEFAULT"
    ],
    "MaxFaces": 1,
    "QualityFilter": "AUTO"
}

IndexFaces réponse à l'opération

IndexFaces renvoie des informations sur les visages détectés dans l’image. Par exemple, la JSON réponse suivante inclut les attributs de détection par défaut pour les visages détectés dans l'image d'entrée. L'exemple montre également les visages qui ne sont pas indexés car la valeur du paramètre MaxFaces d'entrée a été dépassée ; le Reasons tableau contient EXCEEDS_ MAX _ FACES. Si un visage n'est pas indexé pour des raisons de qualité, il Reasons contient des valeurs telles que LOW_ SHARPNESS ou LOW_ BRIGHTNESS. Pour plus d'informations, consultez UnindexedFace.


{
    "FaceModelVersion": "3.0",
    "FaceRecords": [
        {
            "Face": {
                "BoundingBox": {
                    "Height": 0.3247932195663452,
                    "Left": 0.5055555701255798,
                    "Top": 0.2743072211742401,
                    "Width": 0.21444444358348846
                },
                "Confidence": 99.99998474121094,
                "ExternalImageId": "input.jpg",
                "FaceId": "b86e2392-9da1-459b-af68-49118dc16f87",
                "ImageId": "09f43d92-02b6-5cea-8fbd-9f187db2050d"
            },
            "FaceDetail": {
                "BoundingBox": {
                    "Height": 0.3247932195663452,
                    "Left": 0.5055555701255798,
                    "Top": 0.2743072211742401,
                    "Width": 0.21444444358348846
                },
                "Confidence": 99.99998474121094,
                "Landmarks": [
                    {
                        "Type": "eyeLeft",
                        "X": 0.5751981735229492,
                        "Y": 0.4010535478591919
                    },
                    {
                        "Type": "eyeRight",
                        "X": 0.6511467099189758,
                        "Y": 0.4017036259174347
                    },
                    {
                        "Type": "nose",
                        "X": 0.6314528584480286,
                        "Y": 0.4710812568664551
                    },
                    {
                        "Type": "mouthLeft",
                        "X": 0.5879443287849426,
                        "Y": 0.5171778798103333
                    },
                    {
                        "Type": "mouthRight",
                        "X": 0.6444502472877502,
                        "Y": 0.5164633989334106
                    }
                ],
                "Pose": {
                    "Pitch": -10.313642501831055,
                    "Roll": -1.0316886901855469,
                    "Yaw": 18.079818725585938
                },
                "Quality": {
                    "Brightness": 71.2919921875,
                    "Sharpness": 78.74752044677734
                }
            }
        }
    ],
    "OrientationCorrection": "",
    "UnindexedFaces": [
        {
            "FaceDetail": {
                "BoundingBox": {
                    "Height": 0.1329464465379715,
                    "Left": 0.5611110925674438,
                    "Top": 0.6832437515258789,
                    "Width": 0.08777777850627899
                },
                "Confidence": 92.37225341796875,
                "Landmarks": [
                    {
                        "Type": "eyeLeft",
                        "X": 0.5796897411346436,
                        "Y": 0.7452847957611084
                    },
                    {
                        "Type": "eyeRight",
                        "X": 0.6078574657440186,
                        "Y": 0.742687463760376
                    },
                    {
                        "Type": "nose",
                        "X": 0.597953200340271,
                        "Y": 0.7620673179626465
                    },
                    {
                        "Type": "mouthLeft",
                        "X": 0.5884202122688293,
                        "Y": 0.7920381426811218
                    },
                    {
                        "Type": "mouthRight",
                        "X": 0.60627681016922,
                        "Y": 0.7919750809669495
                    }
                ],
                "Pose": {
                    "Pitch": 15.658954620361328,
                    "Roll": -4.583454608917236,
                    "Yaw": 10.558992385864258
                },
                "Quality": {
                    "Brightness": 42.54612350463867,
                    "Sharpness": 86.93206024169922
                }
            },
            "Reasons": [
                "EXCEEDS_MAX_FACES"
            ]
        }
    ]
}

Pour obtenir toutes les informations faciales, spécifiez ALL « » pour le paramètre de DetectionAttributes demande. Ainsi, dans l’exemple de réponse suivant, notez la présence d’informations supplémentaires dans l’élément faceDetail, qui ne sont pas conservées sur le serveur :

25 repères faciaux (par rapport à seulement cinq dans l’exemple précédent)
Dix attributs faciaux (lunettes, barbe, occlusion, direction du regard, etc.)
Emotions (voir l’élément emotion)

L’élément face fournit des métadonnées qui sont conservées sur le serveur.

FaceModelVersion est la version du modèle facial associé à la collection. Pour de plus amples informations, veuillez consulter Comprendre le versionnement des modèles.

OrientationCorrection est l’orientation estimée de l’image. Les informations de correction de l’orientation ne sont pas renvoyées si vous utilisez une version du modèle de détection des visages supérieure à la version 3. Pour de plus amples informations, veuillez consulter Obtention de l’orientation d’une image et des coordonnées du cadre de délimitation.

L'exemple de réponse suivant montre le résultat renvoyé JSON lors de la spécification de [» ALL «] :


{
    "FaceModelVersion": "3.0",
    "FaceRecords": [
        {
            "Face": {
                "BoundingBox": {
                    "Height": 0.06333333253860474,
                    "Left": 0.17185185849666595,
                    "Top": 0.7366666793823242,
                    "Width": 0.11061728745698929
                },
                "Confidence": 99.99999237060547,
                "ExternalImageId": "input.jpg",
                "FaceId": "578e2e1b-d0b0-493c-aa39-ba476a421a34",
                "ImageId": "9ba38e68-35b6-5509-9d2e-fcffa75d1653"
            },
            "FaceDetail": {
                "AgeRange": {
                    "High": 25,
                    "Low": 15
                },
                "Beard": {
                    "Confidence": 99.98077392578125,
                    "Value": false
                },
                "BoundingBox": {
                    "Height": 0.06333333253860474,
                    "Left": 0.17185185849666595,
                    "Top": 0.7366666793823242,
                    "Width": 0.11061728745698929
                },
                "Confidence": 99.99999237060547,
                "Emotions": [
                    {
                        "Confidence": 95.40877532958984,
                        "Type": "HAPPY"
                    },
                    {
                        "Confidence": 6.6088080406188965,
                        "Type": "CALM"
                    },
                    {
                        "Confidence": 0.7385611534118652,
                        "Type": "SAD"
                    }
                ],
                 "EyeDirection": {
                    "yaw": 16.299732,
                    "pitch": -6.407457,
                    "confidence": 99.968704
                              }
                "Eyeglasses": {
                    "Confidence": 99.96795654296875,
                    "Value": false
                },
                "EyesOpen": {
                    "Confidence": 64.0671157836914,
                    "Value": true
                },
                "Gender": {
                    "Confidence": 100,
                    "Value": "Female"
                },
                "Landmarks": [
                    {
                        "Type": "eyeLeft",
                        "X": 0.21361233294010162,
                        "Y": 0.757106363773346
                    },
                    {
                        "Type": "eyeRight",
                        "X": 0.2518567442893982,
                        "Y": 0.7599404454231262
                    },
                    {
                        "Type": "nose",
                        "X": 0.2262365221977234,
                        "Y": 0.7711842060089111
                    },
                    {
                        "Type": "mouthLeft",
                        "X": 0.2050037682056427,
                        "Y": 0.7801263332366943
                    },
                    {
                        "Type": "mouthRight",
                        "X": 0.2430567592382431,
                        "Y": 0.7836716771125793
                    },
                    {
                        "Type": "leftPupil",
                        "X": 0.2161938101053238,
                        "Y": 0.756662905216217
                    },
                    {
                        "Type": "rightPupil",
                        "X": 0.2523181438446045,
                        "Y": 0.7603650689125061
                    },
                    {
                        "Type": "leftEyeBrowLeft",
                        "X": 0.20066319406032562,
                        "Y": 0.7501518130302429
                    },
                    {
                        "Type": "leftEyeBrowUp",
                        "X": 0.2130996286869049,
                        "Y": 0.7480520606040955
                    },
                    {
                        "Type": "leftEyeBrowRight",
                        "X": 0.22584207355976105,
                        "Y": 0.7504606246948242
                    },
                    {
                        "Type": "rightEyeBrowLeft",
                        "X": 0.24509544670581818,
                        "Y": 0.7526801824569702
                    },
                    {
                        "Type": "rightEyeBrowUp",
                        "X": 0.2582615911960602,
                        "Y": 0.7516844868659973
                    },
                    {
                        "Type": "rightEyeBrowRight",
                        "X": 0.26881539821624756,
                        "Y": 0.7554477453231812
                    },
                    {
                        "Type": "leftEyeLeft",
                        "X": 0.20624476671218872,
                        "Y": 0.7568746209144592
                    },
                    {
                        "Type": "leftEyeRight",
                        "X": 0.22105035185813904,
                        "Y": 0.7582521438598633
                    },
                    {
                        "Type": "leftEyeUp",
                        "X": 0.21401576697826385,
                        "Y": 0.7553104162216187
                    },
                    {
                        "Type": "leftEyeDown",
                        "X": 0.21317370235919952,
                        "Y": 0.7584449648857117
                    },
                    {
                        "Type": "rightEyeLeft",
                        "X": 0.24393919110298157,
                        "Y": 0.7600628137588501
                    },
                    {
                        "Type": "rightEyeRight",
                        "X": 0.2598416209220886,
                        "Y": 0.7605880498886108
                    },
                    {
                        "Type": "rightEyeUp",
                        "X": 0.2519053518772125,
                        "Y": 0.7582084536552429
                    },
                    {
                        "Type": "rightEyeDown",
                        "X": 0.25177454948425293,
                        "Y": 0.7612871527671814
                    },
                    {
                        "Type": "noseLeft",
                        "X": 0.2185886949300766,
                        "Y": 0.774715781211853
                    },
                    {
                        "Type": "noseRight",
                        "X": 0.23328955471515656,
                        "Y": 0.7759330868721008
                    },
                    {
                        "Type": "mouthUp",
                        "X": 0.22446128726005554,
                        "Y": 0.7805567383766174
                    },
                    {
                        "Type": "mouthDown",
                        "X": 0.22087252140045166,
                        "Y": 0.7891407608985901
                    }
                ],
                "MouthOpen": {
                    "Confidence": 95.87068939208984,
                    "Value": false
                },
                "Mustache": {
                    "Confidence": 99.9828109741211,
                    "Value": false
                },
                "Pose": {
                    "Pitch": -0.9409101605415344,
                    "Roll": 7.233824253082275,
                    "Yaw": -2.3602254390716553
                },
                "Quality": {
                    "Brightness": 32.01998519897461,
                    "Sharpness": 93.67259216308594
                },
                "Smile": {
                    "Confidence": 86.7142105102539,
                    "Value": true
                },
                "Sunglasses": {
                    "Confidence": 97.38925170898438,
                    "Value": false
                }
            }
        }
    ],
    "OrientationCorrection": "ROTATE_0"
    "UnindexedFaces": []
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Suppression d’une collection

Répertorier les visages et les utilisateurs associés dans une collection