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 et analyse des visages Amazon Rekognition APIs vous permet de détecter et d'analyser des visages sur des images et des vidéos. Cette section fournit une vue d'ensemble des opérations autres que le stockage pour l'analyse faciale. Ces opérations incluent des fonctionnalités telles que la détection des repères faciaux, l'analyse des émotions et la comparaison des visages. Amazon Rekognition peut identifier les repères faciaux (par exemple, la position des yeux), détecter les émotions (par exemple, le bonheur ou la tristesse) et d'autres attributs (par exemple, la présence de lunettes, l'occlusion du visage). Lorsqu'un visage est détecté, le système analyse les attributs faciaux et renvoie un score de confiance pour chaque attribut. ![\[Femme souriante portant des lunettes de soleil et conduisant une voiture jaune vintage sur une route ouverte.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/sample-detect-faces.png) Cette section contient des exemples d'opérations relatives aux images et aux vidéos. Pour plus d'informations sur l'utilisation des opérations d'imagerie de la Rekognition, consultez. [Travail avec les images](images.md) Pour plus d'informations sur l'utilisation des opérations vidéo de Rekognition, consultez. [Utilisation des opérations d'analyse vidéo stockées](video.md) Notez que ces opérations ne sont pas des opérations de stockage. Vous pouvez utiliser les opérations de stockage et les collections de visages pour enregistrer les métadonnées faciales des visages détectés sur une image. Par la suite, vous pouvez rechercher les visages stockés sur les images et dans les vidéos. Cela permet notamment de rechercher une personne spécifique dans une vidéo de Pour de plus amples informations, veuillez consulter [Recherche de visages dans une collection](collections.md). Pour plus d'informations, consultez la section Visages d'[Amazon Rekognition. FAQs](https://aws.amazon.com/rekognition/faqs/) **Note** Les modèles de détection de visages utilisés par Amazon Rekognition Image et Amazon Rekognition Video ne prennent pas en charge la détection de visages chez des personnages ou des entités non humaines. cartoon/animated Si vous souhaitez détecter des personnages de dessins animés dans des images ou des vidéos, nous vous recommandons d'utiliser Étiquettes personnalisées Amazon Rekognition. Pour de plus amples informations, veuillez consulter le guide du développeur [Étiquettes personnalisées Amazon Rekognition](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/what-is.html). **Topics** + [ # Vue d'ensemble de la détection des visages et de la comparaison faciale ](face-feature-differences.md) + [ # Directives pour les attributs faciaux ](guidance-face-attributes.md) + [ # Détection de visages sur une image ](faces-detect-images.md) + [ # Comparaison de visages dans les images ](faces-comparefaces.md) + [ # Détection de visages dans une vidéo stockée ](faces-sqs-video.md) # Vue d'ensemble de la détection des visages et de la comparaison faciale Amazon Rekognition permet aux utilisateurs d'accéder à deux applications d'apprentissage automatique principales pour les images contenant des visages : la détection des visages et la comparaison des visages. Ils intègrent des fonctionnalités cruciales telles que l'analyse faciale et la vérification d'identité, ce qui les rend essentiels pour diverses applications, de la sécurité à l'organisation de photos personnelles. **Détection des visages** Un système de détection de visage répond à la question suivante : « Y a-t-il un visage sur cette photo ? » Les principaux aspects de la détection des visages sont les suivants : + **Emplacement et orientation** : détermine la présence, l'emplacement, l'échelle et l'orientation des visages dans les images ou les images vidéo. + **Attributs du visage** : détecte les visages quels que soient leurs attributs tels que le sexe, l'âge ou la pilosité du visage. + **Informations supplémentaires** : fournit des détails sur l'occlusion du visage et la direction du regard. **Comparaison des visages** Un système de comparaison de visages se concentre sur la question suivante : « Le visage d'une image correspond-il à un visage d'une autre image ? » Les fonctionnalités du système de comparaison des visages incluent : + **Prédictions de correspondance des** visages : compare un visage dans une image à un visage dans une base de données fournie pour prédire les correspondances. + Gestion des **attributs du visage : gère** les attributs pour comparer les visages indépendamment de leur expression, de leur pilosité faciale et de leur âge. **Scores de confiance et détections manquées** Les systèmes de détection des visages et de comparaison des visages utilisent des scores de confiance. Un score de confiance indique la probabilité de prédictions, telles que la présence d'un visage ou une correspondance entre des visages. Des scores plus élevés indiquent une plus grande probabilité. Par exemple, un niveau de confiance de 90 % indique une probabilité de détection ou de correspondance correcte supérieure à 60 %. Si un système de détection de visages ne détecte pas correctement un visage ou fournit une prédiction peu fiable pour un visage réel, il s'agit d'un detection/false négatif oublié. Si le système prédit de manière incorrecte la présence d'un visage avec un niveau de confiance élevé, il s'agit d'un faux alarm/false positif. De même, un système de comparaison faciale peut ne pas faire correspondre deux visages appartenant à la même personne ( detection/false négatif oublié) ou peut prédire à tort que deux visages de personnes différentes sont la même personne (faux alarm/false positif). **Conception de l'application et définition des seuils** + Vous pouvez définir un seuil qui indique le niveau de confiance minimal requis pour renvoyer un résultat. Le choix de seuils de confiance appropriés est essentiel pour la conception des applications et la prise de décision en fonction des résultats du système. + Le niveau de confiance que vous avez choisi doit refléter votre cas d'utilisation. Quelques exemples de cas d'utilisation et de seuils de confiance : + + **Applications photo** : un seuil inférieur (par exemple, 80 %) peut suffire pour identifier les membres de la famille sur les photos. + **Scénarios à enjeux élevés** : dans les cas d'utilisation où le risque de détection manquée ou de fausse alarme est plus élevé, comme dans le cas des applications de sécurité, le système doit utiliser un niveau de confiance plus élevé. Dans de tels cas, un seuil plus élevé (par exemple, 99 %) est recommandé pour des correspondances faciales précises. Pour plus d'informations sur la définition et la compréhension des seuils de confiance, consultez[Recherche de visages dans une collection](collections.md). # Directives pour les attributs faciaux Voici des informations détaillées sur la manière dont Amazon Rekognition traite et renvoie les attributs faciaux. + **FaceDetail Objet** : pour chaque visage détecté, un FaceDetail objet est renvoyé. Il FaceDetail contient des données sur les repères faciaux, la qualité, la pose, etc. + **Prédictions d'attributs** : des attributs tels que l'émotion, le sexe, l'âge, etc. sont prédits. Un niveau de confiance est attribué à chaque prédiction, et les prédictions sont renvoyées avec le score de confiance correspondant. Un seuil de confiance de 99 % est recommandé pour les cas d'utilisation sensibles. Pour l'estimation de l'âge, le point médian de la fourchette d'âge prévue constitue la meilleure approximation. Notez que les prédictions relatives au genre et aux émotions sont basées sur l'apparence physique et ne doivent pas être utilisées pour déterminer l'identité sexuelle ou l'état émotionnel réels. Une prédiction binaire du sexe (homme/femme) est basée sur l'apparence physique d'un visage dans une image particulière. Cela n'indique pas l'identité sexuelle d'une personne, et vous ne devez pas utiliser Rekognition pour prendre une telle décision. 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. De même, la prédiction d'une émotion n'indique pas l'état émotionnel interne réel d'une personne, et vous ne devriez pas utiliser la Rekognition pour prendre une telle décision. Une personne prétendant avoir un visage heureux sur une photo peut avoir l'air heureuse, mais elle n'éprouve peut-être pas le bonheur. **Applications et cas d'utilisation** Voici quelques applications pratiques et cas d'utilisation de ces attributs : + **Applications** : Des attributs tels que le sourire, la pose et la netteté peuvent être utilisés pour sélectionner des photos de profil ou estimer des données démographiques de manière anonyme. + **Cas d'utilisation courants** : les applications de réseaux sociaux et l'estimation démographique lors d'événements ou de magasins de détail en sont des exemples typiques. Pour des informations plus détaillées sur chaque attribut, consultez [FaceDetail](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_FaceDetail.html). # Détection de visages sur une image Amazon Rekognition Image [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html)permet de rechercher les principales caractéristiques du visage, telles que les yeux, le nez et la bouche, afin de détecter les visages sur une image d'entrée. Image Amazon Rekognition détecte les 100 plus grands visages d'une image. Vous pouvez fournir l'image d'entrée sous la forme d'un tableau d'octets d'image (octets d'image encodés en base64) ou spécifier un objet Amazon S3. Dans cette procédure, vous chargez une image (JPEG ou PNG) dans votre compartiment S3 et spécifiez le nom de clé de l'objet. **Pour détecter des visages sur 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 visages) dans votre compartiment S3. Pour en savoir plus, consultez [Chargement d’objets dans Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*. 1. Utilisez les exemples suivants pour appeler `DetectFaces`. ------ #### [ Java ] Cet exemple affiche la fourchette d'âges estimée pour les visages détectés et répertorie la version JSON de tous les attributs faciaux détectés. Remplacez la valeur de `photo` par le nom du fichier image. Remplacez la valeur de `amzn-s3-demo-bucket` par le compartiment Amazon S3; dans lequel l'image est stockée. ``` //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.AmazonRekognitionException; import com.amazonaws.services.rekognition.model.Image; import com.amazonaws.services.rekognition.model.S3Object; import com.amazonaws.services.rekognition.model.AgeRange; import com.amazonaws.services.rekognition.model.Attribute; import com.amazonaws.services.rekognition.model.DetectFacesRequest; import com.amazonaws.services.rekognition.model.DetectFacesResult; import com.amazonaws.services.rekognition.model.FaceDetail; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.List; public class DetectFaces { public static void main(String[] args) throws Exception { String photo = "input.jpg"; String bucket = "bucket"; AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); DetectFacesRequest request = new DetectFacesRequest() .withImage(new Image() .withS3Object(new S3Object() .withName(photo) .withBucket(bucket))) .withAttributes(Attribute.ALL); // Replace Attribute.ALL with Attribute.DEFAULT to get default values. try { DetectFacesResult result = rekognitionClient.detectFaces(request); List < FaceDetail > faceDetails = result.getFaceDetails(); for (FaceDetail face: faceDetails) { if (request.getAttributes().contains("ALL")) { AgeRange ageRange = face.getAgeRange(); System.out.println("The detected face is estimated to be between " + ageRange.getLow().toString() + " and " + ageRange.getHigh().toString() + " years old."); System.out.println("Here's the complete set of attributes:"); } else { // non-default attributes have null values. System.out.println("Here's the default set of attributes:"); } ObjectMapper objectMapper = new ObjectMapper(); System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(face)); } } catch (AmazonRekognitionException e) { e.printStackTrace(); } } } ``` ------ #### [ 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/DetectFaces.java). ``` import java.util.List; //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.RekognitionException; import software.amazon.awssdk.services.rekognition.model.S3Object; import software.amazon.awssdk.services.rekognition.model.DetectFacesRequest; import software.amazon.awssdk.services.rekognition.model.DetectFacesResponse; import software.amazon.awssdk.services.rekognition.model.Image; import software.amazon.awssdk.services.rekognition.model.Attribute; import software.amazon.awssdk.services.rekognition.model.FaceDetail; import software.amazon.awssdk.services.rekognition.model.AgeRange; //snippet-end:[rekognition.java2.detect_labels.import] public class DetectFaces { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " bucket - The name of the Amazon S3 bucket that contains the image (for example, ,amzn-s3-demo-bucket)." + " 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(); DetectFacesRequest facesRequest = DetectFacesRequest.builder() .attributes(Attribute.ALL) .image(myImage) .build(); DetectFacesResponse facesResponse = rekClient.detectFaces(facesRequest); List faceDetails = facesResponse.faceDetails(); for (FaceDetail face : faceDetails) { AgeRange ageRange = face.ageRange(); System.out.println("The detected face is estimated to be between " + ageRange.low().toString() + " and " + ageRange.high().toString() + " years old."); System.out.println("There is a smile : "+face.smile().value().toString()); } } catch (RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.detect_labels.main] } ``` ------ #### [ AWS CLI ] Cet exemple affiche le résultat JSON de l'`detect-faces` AWS CLI opération. Remplacez `file` par le nom d'un fichier image. Remplacez `amzn-s3-demo-bucket` par le nom du compartiment Amazon S3; qui contient le fichier image. ``` aws rekognition detect-faces --image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket,"Name":"image-name"}}"\ --attributes "ALL" --profile profile-name --region region-name ``` 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-faces --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" --attributes "ALL" --profile profile-name --region region-name ``` ------ #### [ Python ] Cet exemple affiche la fourchette d'âge estimée et les autres attributs pour les visages détectés, et répertorie la version JSON de tous les attributs faciaux détectés. Remplacez la valeur de `photo` par le nom du fichier image. Remplacez la valeur de `amzn-s3-demo-bucket` par le compartiment Amazon S3; dans lequel l'image est stockée. 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. ``` import boto3 import json def detect_faces(photo, bucket, region): session = boto3.Session(profile_name='profile-name', region_name=region) client = session.client('rekognition', region_name=region) response = client.detect_faces(Image={'S3Object':{'Bucket':bucket,'Name':photo}}, Attributes=['ALL']) print('Detected faces for ' + photo) for faceDetail in response['FaceDetails']: print('The detected face is between ' + str(faceDetail['AgeRange']['Low']) + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old') print('Here are the other attributes:') print(json.dumps(faceDetail, indent=4, sort_keys=True)) # Access predictions for individual face details and print them print("Gender: " + str(faceDetail['Gender'])) print("Smile: " + str(faceDetail['Smile'])) print("Eyeglasses: " + str(faceDetail['Eyeglasses'])) print("Face Occluded: " + str(faceDetail['FaceOccluded'])) print("Emotions: " + str(faceDetail['Emotions'][0])) return len(response['FaceDetails']) def main(): photo='photo' bucket='amzn-s3-demo-bucket' region='region' face_count=detect_faces(photo, bucket, region) print("Faces detected: " + str(face_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Cet exemple affiche la fourchette d'âges estimée pour les visages détectés et répertorie la version JSON de tous les attributs faciaux détectés. Remplacez la valeur de `photo` par le nom du fichier image. Remplacez la valeur de `amzn-s3-demo-bucket` par le compartiment Amazon S3; dans lequel l'image est stockée. ``` //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 DetectFaces { public static void Example() { String photo = "input.jpg"; String bucket = "amzn-s3-demo-bucket"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); DetectFacesRequest detectFacesRequest = new DetectFacesRequest() { Image = new Image() { S3Object = new S3Object() { Name = photo, Bucket = bucket }, }, // Attributes can be "ALL" or "DEFAULT". // "DEFAULT": BoundingBox, Confidence, Landmarks, Pose, and Quality. // "ALL": See https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Rekognition/TFaceDetail.html Attributes = new List() { "ALL" } }; try { DetectFacesResponse detectFacesResponse = rekognitionClient.DetectFaces(detectFacesRequest); bool hasAll = detectFacesRequest.Attributes.Contains("ALL"); foreach(FaceDetail face in detectFacesResponse.FaceDetails) { Console.WriteLine("BoundingBox: top={0} left={1} width={2} height={3}", face.BoundingBox.Left, face.BoundingBox.Top, face.BoundingBox.Width, face.BoundingBox.Height); Console.WriteLine("Confidence: {0}\nLandmarks: {1}\nPose: pitch={2} roll={3} yaw={4}\nQuality: {5}", face.Confidence, face.Landmarks.Count, face.Pose.Pitch, face.Pose.Roll, face.Pose.Yaw, face.Quality); if (hasAll) Console.WriteLine("The detected face is estimated to be between " + face.AgeRange.Low + " and " + face.AgeRange.High + " years old."); } } catch (Exception e) { Console.WriteLine(e.Message); } } } ``` ------ #### [ Ruby ] Cet exemple affiche la tranche d'âge estimée pour les visages détectés et répertorie différents attributs faciaux. Remplacez la valeur de `photo` par le nom du fichier image. Remplacez la valeur de `amzn-s3-demo-bucket` par le compartiment Amazon S3; dans lequel l'image est stockée. ``` # 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 bucketname without s3:// photo = 'input.jpg'# the name of file client = Aws::Rekognition::Client.new credentials: credentials attrs = { image: { s3_object: { bucket: bucket, name: photo }, }, attributes: ['ALL'] } response = client.detect_faces attrs puts "Detected faces for: #{photo}" response.face_details.each do |face_detail| low = face_detail.age_range.low high = face_detail.age_range.high puts "The detected face is between: #{low} and #{high} years old" puts "All other attributes:" puts " bounding_box.width: #{face_detail.bounding_box.width}" puts " bounding_box.height: #{face_detail.bounding_box.height}" puts " bounding_box.left: #{face_detail.bounding_box.left}" puts " bounding_box.top: #{face_detail.bounding_box.top}" puts " age.range.low: #{face_detail.age_range.low}" puts " age.range.high: #{face_detail.age_range.high}" puts " smile.value: #{face_detail.smile.value}" puts " smile.confidence: #{face_detail.smile.confidence}" puts " eyeglasses.value: #{face_detail.eyeglasses.value}" puts " eyeglasses.confidence: #{face_detail.eyeglasses.confidence}" puts " sunglasses.value: #{face_detail.sunglasses.value}" puts " sunglasses.confidence: #{face_detail.sunglasses.confidence}" puts " gender.value: #{face_detail.gender.value}" puts " gender.confidence: #{face_detail.gender.confidence}" puts " beard.value: #{face_detail.beard.value}" puts " beard.confidence: #{face_detail.beard.confidence}" puts " mustache.value: #{face_detail.mustache.value}" puts " mustache.confidence: #{face_detail.mustache.confidence}" puts " eyes_open.value: #{face_detail.eyes_open.value}" puts " eyes_open.confidence: #{face_detail.eyes_open.confidence}" puts " mout_open.value: #{face_detail.mouth_open.value}" puts " mout_open.confidence: #{face_detail.mouth_open.confidence}" puts " emotions[0].type: #{face_detail.emotions[0].type}" puts " emotions[0].confidence: #{face_detail.emotions[0].confidence}" puts " landmarks[0].type: #{face_detail.landmarks[0].type}" puts " landmarks[0].x: #{face_detail.landmarks[0].x}" puts " landmarks[0].y: #{face_detail.landmarks[0].y}" puts " pose.roll: #{face_detail.pose.roll}" puts " pose.yaw: #{face_detail.pose.yaw}" puts " pose.pitch: #{face_detail.pose.pitch}" puts " quality.brightness: #{face_detail.quality.brightness}" puts " quality.sharpness: #{face_detail.quality.sharpness}" puts " confidence: #{face_detail.confidence}" puts "------------" puts "" end ``` ------ #### [ Node.js ] Cet exemple affiche la tranche d'âge estimée pour les visages détectés et répertorie différents attributs faciaux. Remplacez la valeur de `photo` par le nom du fichier image. Remplacez la valeur de `amzn-s3-demo-bucket` par le compartiment Amazon S3; dans lequel l'image est stockée. 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 = 'photo-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 }, }, Attributes: ['ALL'] } client.detectFaces(params, function(err, response) { if (err) { console.log(err, err.stack); // an error occurred } else { console.log(`Detected faces for: ${photo}`) response.FaceDetails.forEach(data => { let low = data.AgeRange.Low let high = data.AgeRange.High console.log(`The detected face is between: ${low} and ${high} years old`) console.log("All other attributes:") console.log(` BoundingBox.Width: ${data.BoundingBox.Width}`) console.log(` BoundingBox.Height: ${data.BoundingBox.Height}`) console.log(` BoundingBox.Left: ${data.BoundingBox.Left}`) console.log(` BoundingBox.Top: ${data.BoundingBox.Top}`) console.log(` Age.Range.Low: ${data.AgeRange.Low}`) console.log(` Age.Range.High: ${data.AgeRange.High}`) console.log(` Smile.Value: ${data.Smile.Value}`) console.log(` Smile.Confidence: ${data.Smile.Confidence}`) console.log(` Eyeglasses.Value: ${data.Eyeglasses.Value}`) console.log(` Eyeglasses.Confidence: ${data.Eyeglasses.Confidence}`) console.log(` Sunglasses.Value: ${data.Sunglasses.Value}`) console.log(` Sunglasses.Confidence: ${data.Sunglasses.Confidence}`) console.log(` Gender.Value: ${data.Gender.Value}`) console.log(` Gender.Confidence: ${data.Gender.Confidence}`) console.log(` Beard.Value: ${data.Beard.Value}`) console.log(` Beard.Confidence: ${data.Beard.Confidence}`) console.log(` Mustache.Value: ${data.Mustache.Value}`) console.log(` Mustache.Confidence: ${data.Mustache.Confidence}`) console.log(` EyesOpen.Value: ${data.EyesOpen.Value}`) console.log(` EyesOpen.Confidence: ${data.EyesOpen.Confidence}`) console.log(` MouthOpen.Value: ${data.MouthOpen.Value}`) console.log(` MouthOpen.Confidence: ${data.MouthOpen.Confidence}`) console.log(` Emotions[0].Type: ${data.Emotions[0].Type}`) console.log(` Emotions[0].Confidence: ${data.Emotions[0].Confidence}`) console.log(` Landmarks[0].Type: ${data.Landmarks[0].Type}`) console.log(` Landmarks[0].X: ${data.Landmarks[0].X}`) console.log(` Landmarks[0].Y: ${data.Landmarks[0].Y}`) console.log(` Pose.Roll: ${data.Pose.Roll}`) console.log(` Pose.Yaw: ${data.Pose.Yaw}`) console.log(` Pose.Pitch: ${data.Pose.Pitch}`) console.log(` Quality.Brightness: ${data.Quality.Brightness}`) console.log(` Quality.Sharpness: ${data.Quality.Sharpness}`) console.log(` Confidence: ${data.Confidence}`) console.log("------------") console.log("") }) // for response.faceDetails } // if }); ``` ------ ## DetectFaces demande d'opération La valeur d’entrée de `DetectFaces` est une image. Dans cet exemple, l'image est chargée à partir d'un compartiment Amazon S3. Le paramètre `Attributes` indique que tous les attributs faciaux doivent être renvoyés. Pour de plus amples informations, veuillez consulter [Travail avec les images](images.md). ``` { "Image": { "S3Object": { "Bucket": "amzn-s3-demo-bucket", "Name": "input.jpg" } }, "Attributes": [ "ALL" ] } ``` ## DetectFaces réponse à l'opération `DetectFaces` renvoie les informations suivantes pour chaque visage détecté : + **Cadre de délimitation** :coordonnées du cadre de délimitation entourant le visage. + **Fiabilité** : niveau de certitude que le cadre de délimitation contient un visage. + **Repères faciaux** : tableau des repères faciaux. Pour chaque repère (par exemple, l'œil gauche, l'œil droit et la bouche), la réponse indique les coordonnées x et y. + **Attributs faciaux** : ensemble d'attributs faciaux, indiquant par exemple si le visage est occlus, renvoyé sous forme d'objet `FaceDetail`. L'ensemble comprend : barbe AgeRange, émotions, lunettes EyeDirection, genre EyesOpen FaceOccluded, moustache MouthOpen, sourire et lunettes de soleil. Pour chacun de ces attributs, la réponse fournit une valeur. La valeur peut être de différents types, tels qu'un type booléen (si une personne porte des lunettes de soleil), une chaîne (qu'il s'agisse d'un homme ou d'une femme) ou une valeur de degré angulaire (pour la direction pitch/yaw du regard). De plus, pour la plupart des attributs, la réponse fournit également un niveau de fiabilité de la valeur détectée pour chaque attribut. Notez que si les EyeDirection attributs FaceOccluded et sont pris en charge lors de l'utilisation`DetectFaces`, ils ne le sont pas lors de l'analyse de vidéos avec `StartFaceDetection` et`GetFaceDetection`. + **Qualité** : décrit la luminosité et la netteté du visage. Pour plus d'informations sur une détection optimale des visages, consultez [Recommandations pour les images d’entrée de comparaison faciale](recommendations-facial-input-images.md). + **Pose** : décrit la rotation du visage à l'intérieur de l'image. La demande peut décrire un ensemble d'attributs faciaux que vous souhaitez recevoir. Un sous-ensemble `DEFAULT` d'attributs faciaux - `BoundingBox`, `Confidence`, `Pose`, `Quality`, et `Landmarks` - sera toujours renvoyé. Vous pouvez demander le retour d'attributs faciaux spécifiques (en plus de la liste par défaut) en utilisant `["DEFAULT", "FACE_OCCLUDED", "EYE_DIRECTION"]` ou en utilisant un seul attribut, par exemple `["FACE_OCCLUDED"]`. Vous pouvez demander tous les attributs faciaux en utilisant `["ALL"]`. Le fait de demander davantage d'attributs peut augmenter le temps de réponse. Voici un exemple de réponse à un appel d'API `DetectFaces` : ``` { "FaceDetails": [ { "BoundingBox": { "Width": 0.7919622659683228, "Height": 0.7510867118835449, "Left": 0.08881539851427078, "Top": 0.151064932346344 }, "AgeRange": { "Low": 18, "High": 26 }, "Smile": { "Value": false, "Confidence": 89.77348327636719 }, "Eyeglasses": { "Value": true, "Confidence": 99.99996948242188 }, "Sunglasses": { "Value": true, "Confidence": 93.65237426757812 }, "Gender": { "Value": "Female", "Confidence": 99.85968780517578 }, "Beard": { "Value": false, "Confidence": 77.52591705322266 }, "Mustache": { "Value": false, "Confidence": 94.48904418945312 }, "EyesOpen": { "Value": true, "Confidence": 98.57169342041016 }, "MouthOpen": { "Value": false, "Confidence": 74.33953094482422 }, "Emotions": [ { "Type": "SAD", "Confidence": 65.56403350830078 }, { "Type": "CONFUSED", "Confidence": 31.277774810791016 }, { "Type": "DISGUSTED", "Confidence": 15.553778648376465 }, { "Type": "ANGRY", "Confidence": 8.012762069702148 }, { "Type": "SURPRISED", "Confidence": 7.621500015258789 }, { "Type": "FEAR", "Confidence": 7.243380546569824 }, { "Type": "CALM", "Confidence": 5.8196024894714355 }, { "Type": "HAPPY", "Confidence": 2.2830512523651123 } ], "Landmarks": [ { "Type": "eyeLeft", "X": 0.30225440859794617, "Y": 0.41018882393836975 }, { "Type": "eyeRight", "X": 0.6439348459243774, "Y": 0.40341562032699585 }, { "Type": "mouthLeft", "X": 0.343580037355423, "Y": 0.6951127648353577 }, { "Type": "mouthRight", "X": 0.6306480765342712, "Y": 0.6898072361946106 }, { "Type": "nose", "X": 0.47164231538772583, "Y": 0.5763645172119141 }, { "Type": "leftEyeBrowLeft", "X": 0.1732882857322693, "Y": 0.34452149271965027 }, { "Type": "leftEyeBrowRight", "X": 0.3655243515968323, "Y": 0.33231860399246216 }, { "Type": "leftEyeBrowUp", "X": 0.2671719491481781, "Y": 0.31669262051582336 }, { "Type": "rightEyeBrowLeft", "X": 0.5613729953765869, "Y": 0.32813435792922974 }, { "Type": "rightEyeBrowRight", "X": 0.7665090560913086, "Y": 0.3318614959716797 }, { "Type": "rightEyeBrowUp", "X": 0.6612788438796997, "Y": 0.3082450032234192 }, { "Type": "leftEyeLeft", "X": 0.2416982799768448, "Y": 0.4085965156555176 }, { "Type": "leftEyeRight", "X": 0.36943578720092773, "Y": 0.41230902075767517 }, { "Type": "leftEyeUp", "X": 0.29974061250686646, "Y": 0.3971870541572571 }, { "Type": "leftEyeDown", "X": 0.30360740423202515, "Y": 0.42347756028175354 }, { "Type": "rightEyeLeft", "X": 0.5755768418312073, "Y": 0.4081145226955414 }, { "Type": "rightEyeRight", "X": 0.7050536870956421, "Y": 0.39924031496047974 }, { "Type": "rightEyeUp", "X": 0.642906129360199, "Y": 0.39026668667793274 }, { "Type": "rightEyeDown", "X": 0.6423097848892212, "Y": 0.41669243574142456 }, { "Type": "noseLeft", "X": 0.4122826159000397, "Y": 0.5987403392791748 }, { "Type": "noseRight", "X": 0.5394935011863708, "Y": 0.5960900187492371 }, { "Type": "mouthUp", "X": 0.478581964969635, "Y": 0.6660456657409668 }, { "Type": "mouthDown", "X": 0.483366996049881, "Y": 0.7497162818908691 }, { "Type": "leftPupil", "X": 0.30225440859794617, "Y": 0.41018882393836975 }, { "Type": "rightPupil", "X": 0.6439348459243774, "Y": 0.40341562032699585 }, { "Type": "upperJawlineLeft", "X": 0.11031254380941391, "Y": 0.3980775475502014 }, { "Type": "midJawlineLeft", "X": 0.19301874935626984, "Y": 0.7034031748771667 }, { "Type": "chinBottom", "X": 0.4939905107021332, "Y": 0.8877836465835571 }, { "Type": "midJawlineRight", "X": 0.7990140914916992, "Y": 0.6899225115776062 }, { "Type": "upperJawlineRight", "X": 0.8548634648323059, "Y": 0.38160091638565063 } ], "Pose": { "Roll": -5.83309268951416, "Yaw": -2.4244730472564697, "Pitch": 2.6216139793395996 }, "Quality": { "Brightness": 96.16363525390625, "Sharpness": 95.51618957519531 }, "Confidence": 99.99872589111328, "FaceOccluded": { "Value": true, "Confidence": 99.99726104736328 }, "EyeDirection": { "Yaw": 16.299732, "Pitch": -6.407457, "Confidence": 99.968704 } } ], "ResponseMetadata": { "RequestId": "8bf02607-70b7-4f20-be55-473fe1bba9a2", "HTTPStatusCode": 200, "HTTPHeaders": { "x-amzn-requestid": "8bf02607-70b7-4f20-be55-473fe1bba9a2", "content-type": "application/x-amz-json-1.1", "content-length": "3409", "date": "Wed, 26 Apr 2023 20:18:50 GMT" }, "RetryAttempts": 0 } } ``` Notez ce qui suit : + Les données `Pose` décrivent la rotation du visage détecté. Vous pouvez utiliser la combinaison des données `BoundingBox` et `Pose` pour tracer le cadre de délimitation autour des visages que votre application affiche. + `Quality` décrit la luminosité et la netteté du visage. Vous pouvez juger utile de comparer les visages de différentes images pour trouver le meilleur. + La réponse précédente montre l'ensemble des `landmarks` faciaux que le service peut détecter, ainsi que l'ensemble des attributs du visage et des émotions. Pour obtenir toutes ces informations dans la réponse, définissez le paramètre `attributes` avec la valeur `ALL`. Par défaut, l'API `DetectFaces` renvoie uniquement les cinq attributs faciaux suivants : `BoundingBox`, `Confidence`, `Pose`, `Quality` et `landmarks`. Les repères par défaut renvoyés sont les suivants : `eyeLeft`, `eyeRight`, `nose`, `mouthLeft` et `mouthRight`. # Comparaison de visages dans les images Avec Rekognition, vous pouvez comparer des visages entre deux images à l'aide de cette opération. [CompareFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CompareFaces.html) Cette fonctionnalité est utile pour les applications telles que la vérification d'identité ou la mise en correspondance de photos. CompareFaces compare un visage de l'image *source* avec chaque visage de l'image *cible*. Les images sont transmises CompareFaces sous la forme suivante : + Représentation d'une image codée en base64. + Objets Amazon S3. **Détection des visages et comparaison des visages** La comparaison des visages est différente de la détection des visages. La détection des visages (qui utilise DetectFaces) identifie uniquement la présence et l'emplacement des visages dans une image ou une vidéo. En revanche, la comparaison de visages consiste à comparer un visage détecté dans une image source à des visages dans une image cible afin de trouver des correspondances. **Seuils de similarité** Utilisez le `similarityThreshold` paramètre pour définir le niveau de confiance minimal pour les correspondances à inclure dans la réponse. Par défaut, seuls les visages présentant un score de similarité supérieur ou égal à 80 % sont renvoyés dans la réponse. **Note** `CompareFaces`utilise des algorithmes d'apprentissage automatique, qui sont probabilistes. Un faux négatif est une prédiction incorrecte selon laquelle un visage de l'image cible présente un faible score de confiance en matière de similarité par rapport au visage de l'image source. Pour réduire le risque de faux négatifs, nous vous recommandons de comparer l'image cible à plusieurs images sources. Si vous prévoyez d'utiliser `CompareFaces` pour prendre une décision qui a une incidence sur les droits, la confidentialité ou l'accès aux services d'une personne, nous vous recommandons de transmettre le résultat à un humain pour examen et validation supplémentaire avant de passer à l'action. Les exemples de code suivants montrent comment utiliser les CompareFaces opérations pour différents AWS SDKs. Dans cet AWS CLI exemple, vous chargez deux images JPEG dans votre compartiment Amazon S3 et spécifiez le nom de la clé de l'objet. Dans les autres exemples, vous chargez deux fichiers à partir du système de fichiers local et les entrez sous forme de tableaux d'octets d'image. **Pour comparer des visages** 1. Si vous ne l’avez pas déjà fait : 1. Créez ou mettez à jour un utilisateur doté d'autorisations `AmazonRekognitionFullAccess` et `AmazonS3ReadOnlyAccess` (à titre d'AWS CLI exemple uniquement). 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. Utilisez l'exemple de code suivant pour appeler l'opération `CompareFaces`. ------ #### [ Java ] Cet exemple affiche des informations sur des visages correspondants dans les images source et cible, qui sont chargées à partir du système de fichiers local. Remplacez la valeur de `sourceImage` et de `targetImage` par le chemin et le nom de fichier des images source et cible. ``` //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.Image; import com.amazonaws.services.rekognition.model.BoundingBox; import com.amazonaws.services.rekognition.model.CompareFacesMatch; import com.amazonaws.services.rekognition.model.CompareFacesRequest; import com.amazonaws.services.rekognition.model.CompareFacesResult; import com.amazonaws.services.rekognition.model.ComparedFace; import java.util.List; import java.io.File; import java.io.FileInputStream; import java.io.InputStream; import java.nio.ByteBuffer; import com.amazonaws.util.IOUtils; public class CompareFaces { public static void main(String[] args) throws Exception{ Float similarityThreshold = 70F; String sourceImage = "source.jpg"; String targetImage = "target.jpg"; ByteBuffer sourceImageBytes=null; ByteBuffer targetImageBytes=null; AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); //Load source and target images and create input parameters try (InputStream inputStream = new FileInputStream(new File(sourceImage))) { sourceImageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream)); } catch(Exception e) { System.out.println("Failed to load source image " + sourceImage); System.exit(1); } try (InputStream inputStream = new FileInputStream(new File(targetImage))) { targetImageBytes = ByteBuffer.wrap(IOUtils.toByteArray(inputStream)); } catch(Exception e) { System.out.println("Failed to load target images: " + targetImage); System.exit(1); } Image source=new Image() .withBytes(sourceImageBytes); Image target=new Image() .withBytes(targetImageBytes); CompareFacesRequest request = new CompareFacesRequest() .withSourceImage(source) .withTargetImage(target) .withSimilarityThreshold(similarityThreshold); // Call operation CompareFacesResult compareFacesResult=rekognitionClient.compareFaces(request); // Display results List faceDetails = compareFacesResult.getFaceMatches(); for (CompareFacesMatch match: faceDetails){ ComparedFace face= match.getFace(); BoundingBox position = face.getBoundingBox(); System.out.println("Face at " + position.getLeft().toString() + " " + position.getTop() + " matches with " + match.getSimilarity().toString() + "% confidence."); } List uncompared = compareFacesResult.getUnmatchedFaces(); System.out.println("There was " + uncompared.size() + " face(s) that did not match"); } } ``` ------ #### [ 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/CompareFaces.java). ``` import java.util.List; 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.RekognitionException; import software.amazon.awssdk.services.rekognition.model.Image; import software.amazon.awssdk.services.rekognition.model.BoundingBox; import software.amazon.awssdk.services.rekognition.model.CompareFacesMatch; import software.amazon.awssdk.services.rekognition.model.CompareFacesRequest; import software.amazon.awssdk.services.rekognition.model.CompareFacesResponse; import software.amazon.awssdk.services.rekognition.model.ComparedFace; import software.amazon.awssdk.core.SdkBytes; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; // snippet-end:[rekognition.java2.detect_faces.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 CompareFaces { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " pathSource - The path to the source image (for example, C:\\AWS\\pic1.png). \n " + " pathTarget - The path to the target image (for example, C:\\AWS\\pic2.png). \n\n"; if (args.length != 2) { System.out.println(usage); System.exit(1); } Float similarityThreshold = 70F; String sourceImage = args[0]; String targetImage = args[1]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); compareTwoFaces(rekClient, similarityThreshold, sourceImage, targetImage); rekClient.close(); } // snippet-start:[rekognition.java2.compare_faces.main] public static void compareTwoFaces(RekognitionClient rekClient, Float similarityThreshold, String sourceImage, String targetImage) { try { InputStream sourceStream = new FileInputStream(sourceImage); InputStream tarStream = new FileInputStream(targetImage); SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream); SdkBytes targetBytes = SdkBytes.fromInputStream(tarStream); // Create an Image object for the source image. Image souImage = Image.builder() .bytes(sourceBytes) .build(); Image tarImage = Image.builder() .bytes(targetBytes) .build(); CompareFacesRequest facesRequest = CompareFacesRequest.builder() .sourceImage(souImage) .targetImage(tarImage) .similarityThreshold(similarityThreshold) .build(); // Compare the two images. CompareFacesResponse compareFacesResult = rekClient.compareFaces(facesRequest); List faceDetails = compareFacesResult.faceMatches(); for (CompareFacesMatch match: faceDetails){ ComparedFace face= match.face(); BoundingBox position = face.boundingBox(); System.out.println("Face at " + position.left().toString() + " " + position.top() + " matches with " + face.confidence().toString() + "% confidence."); } List uncompared = compareFacesResult.unmatchedFaces(); System.out.println("There was " + uncompared.size() + " face(s) that did not match"); System.out.println("Source image rotation: " + compareFacesResult.sourceImageOrientationCorrection()); System.out.println("target image rotation: " + compareFacesResult.targetImageOrientationCorrection()); } catch(RekognitionException | FileNotFoundException e) { System.out.println("Failed to load source image " + sourceImage); System.exit(1); } } // snippet-end:[rekognition.java2.compare_faces.main] } ``` ------ #### [ AWS CLI ] Cet exemple affiche le résultat JSON de l'`compare-faces` AWS CLI opération. Remplacez `amzn-s3-demo-bucket` par le nom du compartiment Amazon S3 qui contient les images source et cible. Remplacez la valeur de `source.jpg` et de `target.jpg` par le nom de fichier de l'image source et le nom de fichier de l'image cible. ``` aws rekognition compare-faces --target-image \ "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" \ --source-image "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"image-name"}}" --profile profile-name ``` 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 compare-faces --target-image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" \ --source-image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"image-name\"}}" --profile profile-name ``` ------ #### [ Python ] Cet exemple affiche des informations sur des visages correspondants dans les images source et cible, qui sont chargées à partir du système de fichiers local. Remplacez la valeur de `source_file` et de `target_file` par le chemin et le nom de fichier des images source et cible. 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 compare_faces(sourceFile, targetFile): session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') imageSource = open(sourceFile, 'rb') imageTarget = open(targetFile, 'rb') response = client.compare_faces(SimilarityThreshold=80, SourceImage={'Bytes': imageSource.read()}, TargetImage={'Bytes': imageTarget.read()}) for faceMatch in response['FaceMatches']: position = faceMatch['Face']['BoundingBox'] similarity = str(faceMatch['Similarity']) print('The face at ' + str(position['Left']) + ' ' + str(position['Top']) + ' matches with ' + similarity + '% confidence') imageSource.close() imageTarget.close() return len(response['FaceMatches']) def main(): source_file = 'source-file-name' target_file = 'target-file-name' face_matches = compare_faces(source_file, target_file) print("Face matches: " + str(face_matches)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Cet exemple affiche des informations sur des visages correspondants dans les images source et cible, qui sont chargées à partir du système de fichiers local. Remplacez la valeur de `sourceImage` et de `targetImage` par le chemin et le nom de fichier des images source et cible. ``` //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.IO; using Amazon.Rekognition; using Amazon.Rekognition.Model; public class CompareFaces { public static void Example() { float similarityThreshold = 70F; String sourceImage = "source.jpg"; String targetImage = "target.jpg"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); Amazon.Rekognition.Model.Image imageSource = new Amazon.Rekognition.Model.Image(); try { using (FileStream fs = new FileStream(sourceImage, FileMode.Open, FileAccess.Read)) { byte[] data = new byte[fs.Length]; fs.Read(data, 0, (int)fs.Length); imageSource.Bytes = new MemoryStream(data); } } catch (Exception) { Console.WriteLine("Failed to load source image: " + sourceImage); return; } Amazon.Rekognition.Model.Image imageTarget = new Amazon.Rekognition.Model.Image(); try { using (FileStream fs = new FileStream(targetImage, FileMode.Open, FileAccess.Read)) { byte[] data = new byte[fs.Length]; data = new byte[fs.Length]; fs.Read(data, 0, (int)fs.Length); imageTarget.Bytes = new MemoryStream(data); } } catch (Exception) { Console.WriteLine("Failed to load target image: " + targetImage); return; } CompareFacesRequest compareFacesRequest = new CompareFacesRequest() { SourceImage = imageSource, TargetImage = imageTarget, SimilarityThreshold = similarityThreshold }; // Call operation CompareFacesResponse compareFacesResponse = rekognitionClient.CompareFaces(compareFacesRequest); // Display results foreach(CompareFacesMatch match in compareFacesResponse.FaceMatches) { ComparedFace face = match.Face; BoundingBox position = face.BoundingBox; Console.WriteLine("Face at " + position.Left + " " + position.Top + " matches with " + match.Similarity + "% confidence."); } Console.WriteLine("There was " + compareFacesResponse.UnmatchedFaces.Count + " face(s) that did not match"); } } ``` ------ #### [ Ruby ] Cet exemple affiche des informations sur des visages correspondants dans les images source et cible, qui sont chargées à partir du système de fichiers local. Remplacez la valeur de `photo_source` et de `photo_target` par le chemin et le nom de fichier des images source et cible. ``` # 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 bucketname without s3:// photo_source = 'source.jpg' photo_target = 'target.jpg' client = Aws::Rekognition::Client.new credentials: credentials attrs = { source_image: { s3_object: { bucket: bucket, name: photo_source }, }, target_image: { s3_object: { bucket: bucket, name: photo_target }, }, similarity_threshold: 70 } response = client.compare_faces attrs response.face_matches.each do |face_match| position = face_match.face.bounding_box similarity = face_match.similarity puts "The face at: #{position.left}, #{position.top} matches with #{similarity} % confidence" end ``` ------ #### [ Node.js ] Cet exemple affiche des informations sur des visages correspondants dans les images source et cible, qui sont chargées à partir du système de fichiers local. Remplacez la valeur de `photo_source` et de `photo_target` par le chemin et le nom de fichier des images source et cible. 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. ``` // Load the SDK var AWS = require('aws-sdk'); const bucket = 'bucket-name' // the bucket name without s3:// const photo_source = 'photo-source-name' // path and the name of file const photo_target = 'photo-target-name' 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 = { SourceImage: { S3Object: { Bucket: bucket, Name: photo_source }, }, TargetImage: { S3Object: { Bucket: bucket, Name: photo_target }, }, SimilarityThreshold: 70 } client.compareFaces(params, function(err, response) { if (err) { console.log(err, err.stack); // an error occurred } else { response.FaceMatches.forEach(data => { let position = data.Face.BoundingBox let similarity = data.Similarity console.log(`The face at: ${position.Left}, ${position.Top} matches with ${similarity} % confidence`) }) // for response.faceDetails } // if }); ``` ------ ## CompareFaces demande d'opération La valeur d’entrée de `CompareFaces` est une image. Dans cet exemple, les images source et cible sont chargées à partir du système de fichiers local. Le paramètre d'entrée `SimilarityThreshold` spécifie le niveau de fiabilité minimum auquel les visages comparés doivent correspondre pour être inclus dans la réponse. Pour de plus amples informations, veuillez consulter [Travail avec les images](images.md). ``` { "SourceImage": { "Bytes": "/9j/4AAQSk2Q==..." }, "TargetImage": { "Bytes": "/9j/4O1Q==..." }, "SimilarityThreshold": 70 } ``` ## CompareFaces réponse à l'opération La réponse inclut : + Un tableau de correspondances de visages : une liste de visages correspondants avec des scores de similarité et des métadonnées pour chaque visage correspondant. Si plusieurs faces correspondent, `faceMatches` le tableau inclut toutes les correspondances faciales. + Détails de la correspondance faciale : chaque visage correspondant fournit également un cadre de délimitation, une valeur de confiance, des emplacements repères et un score de similarité. + Liste des visages non correspondants : la réponse inclut également les visages de l'image cible qui ne correspondent pas au visage de l'image source. Comprend une boîte de délimitation pour chaque visage inégalé. + Informations sur le visage source : inclut des informations sur le visage provenant de l'image source utilisée pour la comparaison, notamment le cadre de sélection et la valeur de confiance. L'exemple montre qu'une correspondance faciale a été trouvée dans l'image cible. Pour cette correspondance, un cadre de délimitation et une valeur de fiabilité (niveau de fiabilité de Amazon Rekognition en ce qui concerne la présence d'un visage dans le cadre de délimitation) sont fournis. Le score de similarité de 99,99 indique à quel point les visages sont similaires. L'exemple montre également un visage trouvé par Amazon Rekognition dans l'image cible et qui ne correspond pas au visage analysé dans l'image source. ``` { "FaceMatches": [{ "Face": { "BoundingBox": { "Width": 0.5521978139877319, "Top": 0.1203877404332161, "Left": 0.23626373708248138, "Height": 0.3126954436302185 }, "Confidence": 99.98751068115234, "Pose": { "Yaw": -82.36799621582031, "Roll": -62.13221740722656, "Pitch": 0.8652129173278809 }, "Quality": { "Sharpness": 99.99880981445312, "Brightness": 54.49755096435547 }, "Landmarks": [{ "Y": 0.2996366024017334, "X": 0.41685718297958374, "Type": "eyeLeft" }, { "Y": 0.2658946216106415, "X": 0.4414493441581726, "Type": "eyeRight" }, { "Y": 0.3465650677680969, "X": 0.48636093735694885, "Type": "nose" }, { "Y": 0.30935320258140564, "X": 0.6251809000968933, "Type": "mouthLeft" }, { "Y": 0.26942989230155945, "X": 0.6454493403434753, "Type": "mouthRight" } ] }, "Similarity": 100.0 }], "SourceImageOrientationCorrection": "ROTATE_90", "TargetImageOrientationCorrection": "ROTATE_90", "UnmatchedFaces": [{ "BoundingBox": { "Width": 0.4890109896659851, "Top": 0.6566604375839233, "Left": 0.10989011079072952, "Height": 0.278298944234848 }, "Confidence": 99.99992370605469, "Pose": { "Yaw": 51.51519012451172, "Roll": -110.32493591308594, "Pitch": -2.322134017944336 }, "Quality": { "Sharpness": 99.99671173095703, "Brightness": 57.23163986206055 }, "Landmarks": [{ "Y": 0.8288310766220093, "X": 0.3133862614631653, "Type": "eyeLeft" }, { "Y": 0.7632885575294495, "X": 0.28091415762901306, "Type": "eyeRight" }, { "Y": 0.7417283654212952, "X": 0.3631140887737274, "Type": "nose" }, { "Y": 0.8081989884376526, "X": 0.48565614223480225, "Type": "mouthLeft" }, { "Y": 0.7548204660415649, "X": 0.46090251207351685, "Type": "mouthRight" } ] }], "SourceImageFace": { "BoundingBox": { "Width": 0.5521978139877319, "Top": 0.1203877404332161, "Left": 0.23626373708248138, "Height": 0.3126954436302185 }, "Confidence": 99.98751068115234 } } ``` # Détection de visages dans une vidéo stockée Vidéo Amazon Rekognition peut détecter des visages dans les vidéos stockées dans un compartiment Amazon S3 et fournir des informations telles que : + Le ou les moments auxquels les visages sont détectés dans une vidéo. + L'emplacement des visages dans le cadre vidéo au moment où ils ont été détectés. + Des repères faciaux tels que la position de l'œil gauche. + Attributs supplémentaires, comme expliqué sur la page [Directives pour les attributs faciaux](guidance-face-attributes.md). La détection des visages par Vidéo Amazon Rekognition dans les vidéos stockées est une opération asynchrone. Pour démarrer la détection des visages dans les vidéos, appelez [StartFaceDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartFaceDetection.html). Vidéo Amazon Rekognition publie l’état d’achèvement de l’analyse vidéo dans une rubrique Amazon Simple Notification Service (Amazon SNS). Si l'analyse vidéo aboutit, vous pouvez appeler [GetFaceDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetFaceDetection.html) pour obtenir les résultats de cette opération. Pour plus d’informations sur le démarrage de l’analyse vidéo et l’obtention des résultats, consultez [Appeler les opérations de Vidéo Amazon Rekognition](api-video.md). Cette procédure s’appuie sur le code figurant dans [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md), qui utilise une file d’attente Amazon Simple Queue Service (Amazon SQS) pour obtenir le statut d’achèvement d’une demande d’analyse vidéo. **Pour détecter des visages dans une vidéo stockée dans un compartiment Amazon S3 (SDK)** 1. Effectuez une [Analyse d’une vidéo stockée dans un compartiment Amazon S3 avec Java or Python (SDK)](video-analyzing-with-sqs.md). 1. Ajoutez le code suivant à la classe `VideoDetect` que vous avez créée à l’étape 1. ------ #### [ AWS CLI ] + Dans l'exemple de code suivant, remplacez `amzn-s3-demo-bucket` et `video-name` par le nom du compartiment Amazon S3 et le nom du fichier vidéo que vous avez spécifiés à l’étape 2. + Remplacez `region-name` par la région AWS que vous utilisez. Remplacez la valeur de `profile_name` par le nom de votre profil de développeur. + Remplacez `TopicARN` par l’ARN de la rubrique Amazon SNS que vous avez créée à l’étape 3 de [Configuration de Vidéo Amazon Rekognition](api-video-roles.md). + Remplacez `RoleARN` par l’ARN de la fonction de service IAM que vous avez créé à l’étape 7 de [Configuration de Vidéo Amazon Rekognition](api-video-roles.md). ``` aws rekognition start-face-detection --video "{"S3Object":{"Bucket":"amzn-s3-demo-bucket","Name":"Video-Name"}}" --notification-channel "{"SNSTopicArn":"Topic-ARN","RoleArn":"Role-ARN"}" --region region-name --profile profile-name ``` 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 start-face-detection --video "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"Name\":\"Video-Name\"}}" --notification-channel "{\"SNSTopicArn\":\"Topic-ARN\",\"RoleArn\":\"Role-ARN\"}" --region region-name --profile profile-name ``` Après avoir exécuté l'opération `StartFaceDetection` et obtenu le numéro d'identification de la tâche, exécutez l'opération `GetFaceDetection` suivante et fournissez le numéro d'identification de la tâche : ``` aws rekognition get-face-detection --job-id job-id-number --profile profile-name ``` ------ #### [ Java ] ``` //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.) private static void StartFaceDetection(String bucket, String video) throws Exception{ NotificationChannel channel= new NotificationChannel() .withSNSTopicArn(snsTopicArn) .withRoleArn(roleArn); StartFaceDetectionRequest req = new StartFaceDetectionRequest() .withVideo(new Video() .withS3Object(new S3Object() .withBucket(bucket) .withName(video))) .withNotificationChannel(channel); StartFaceDetectionResult startLabelDetectionResult = rek.startFaceDetection(req); startJobId=startLabelDetectionResult.getJobId(); } private static void GetFaceDetectionResults() throws Exception{ int maxResults=10; String paginationToken=null; GetFaceDetectionResult faceDetectionResult=null; do{ if (faceDetectionResult !=null){ paginationToken = faceDetectionResult.getNextToken(); } faceDetectionResult = rek.getFaceDetection(new GetFaceDetectionRequest() .withJobId(startJobId) .withNextToken(paginationToken) .withMaxResults(maxResults)); VideoMetadata videoMetaData=faceDetectionResult.getVideoMetadata(); System.out.println("Format: " + videoMetaData.getFormat()); System.out.println("Codec: " + videoMetaData.getCodec()); System.out.println("Duration: " + videoMetaData.getDurationMillis()); System.out.println("FrameRate: " + videoMetaData.getFrameRate()); //Show faces, confidence and detection times List faces= faceDetectionResult.getFaces(); for (FaceDetection face: faces) { long seconds=face.getTimestamp()/1000; System.out.print("Sec: " + Long.toString(seconds) + " "); System.out.println(face.getFace().toString()); System.out.println(); } } while (faceDetectionResult !=null && faceDetectionResult.getNextToken() != null); } ``` Dans la fonction `main`, remplacez les lignes : ``` StartLabelDetection(amzn-s3-demo-bucket, video); if (GetSQSMessageSuccess()==true) GetLabelDetectionResults(); ``` avec : ``` StartFaceDetection(amzn-s3-demo-bucket, video); if (GetSQSMessageSuccess()==true) GetFaceDetectionResults(); ``` ------ #### [ 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/VideoDetectFaces.java). ``` //snippet-start:[rekognition.java2.recognize_video_faces.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.*; import java.util.List; //snippet-end:[rekognition.java2.recognize_video_faces.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 VideoDetectFaces { private static String startJobId =""; public static void main(String[] args) { final String usage = "\n" + "Usage: " + "