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.
# Recherche d’un visage à l’aide d’une image
Vous pouvez utiliser l'opération [SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html) afin de rechercher des visages correspondant au visage le plus grand d'une image fournie.
Pour de plus amples informations, veuillez consulter [Recherche de visages et d’utilisateurs dans une collection](collections-search-faces.md).
**Pour rechercher un visage dans une collection à l’aide d’une image (SDK)**
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 AWS CLI les AWS SDK. Pour de plus amples informations, veuillez consulter [Étape 2 : configurer le AWS CLI and AWS Kits SDK](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 l’opération `SearchFacesByImage`.
------
#### [ Java ]
Cet exemple affiche des informations sur les visages qui correspondent au visage le plus grand dans une image. L’exemple de code spécifie les paramètres `FaceMatchThreshold` et `MaxFaces` pour limiter les résultats renvoyés dans la réponse.
Dans l’exemple suivant, modifiez les éléments suivants : remplacez la valeur de `collectionId` par la collection à explorer, remplacez la valeur de `bucket` par le compartiment contenant l’image d’entrée, puis remplacez la valeur de `photo` par l’image d’entré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.FaceMatch;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.SearchFacesByImageRequest;
import com.amazonaws.services.rekognition.model.SearchFacesByImageResult;
import java.util.List;
import com.fasterxml.jackson.databind.ObjectMapper;
public class SearchFaceMatchingImageCollection {
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();
ObjectMapper objectMapper = new ObjectMapper();
// Get an image object from S3 bucket.
Image image=new Image()
.withS3Object(new S3Object()
.withBucket(bucket)
.withName(photo));
// Search collection for faces similar to the largest face in the image.
SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
.withCollectionId(collectionId)
.withImage(image)
.withFaceMatchThreshold(70F)
.withMaxFaces(2);
SearchFacesByImageResult searchFacesByImageResult =
rekognitionClient.searchFacesByImage(searchFacesByImageRequest);
System.out.println("Faces matching largest face in image from" + photo);
List < FaceMatch > faceImageMatches = searchFacesByImageResult.getFaceMatches();
for (FaceMatch face: faceImageMatches) {
System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(face));
System.out.println();
}
}
}
```
------
#### [ 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/SearchFaceMatchingImageCollection.java).
```
// snippet-start:[rekognition.java2.search_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.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.SearchFacesByImageRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.SearchFacesByImageResponse;
import software.amazon.awssdk.services.rekognition.model.FaceMatch;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
// snippet-end:[rekognition.java2.search_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 SearchFaceMatchingImageCollection {
public static void main(String[] args) {
final String usage = "\n" +
"Usage: " +
" \n\n" +
"Where:\n" +
" collectionId - The id 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();
System.out.println("Searching for a face in a collections");
searchFaceInCollection(rekClient, collectionId, sourceImage ) ;
rekClient.close();
}
// snippet-start:[rekognition.java2.search_faces_collection.main]
public static void searchFaceInCollection(RekognitionClient rekClient,String collectionId, String sourceImage) {
try {
InputStream sourceStream = new FileInputStream(new File(sourceImage));
SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
Image souImage = Image.builder()
.bytes(sourceBytes)
.build();
SearchFacesByImageRequest facesByImageRequest = SearchFacesByImageRequest.builder()
.image(souImage)
.maxFaces(10)
.faceMatchThreshold(70F)
.collectionId(collectionId)
.build();
SearchFacesByImageResponse imageResponse = rekClient.searchFacesByImage(facesByImageRequest) ;
System.out.println("Faces matching in the collection");
List faceImageMatches = imageResponse.faceMatches();
for (FaceMatch face: faceImageMatches) {
System.out.println("The similarity level is "+face.similarity());
System.out.println();
}
} catch (RekognitionException | FileNotFoundException e) {
System.out.println(e.getMessage());
System.exit(1);
}
}
// snippet-end:[rekognition.java2.search_faces_collection.main]
}
```
------
#### [ AWS CLI ]
Cette AWS CLI commande affiche la sortie JSON pour l'opération `search-faces-by-image` CLI. Remplacez la valeur de `Bucket` par le compartiment S3 utilisé à l’étape 2. Remplacez la valeur de `Name` par le nom de fichier image utilisé à l’étape 2. Remplacez la valeur de `collection-id` par la collection dans laquelle vous souhaitez effectuer la recherche. 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 search-faces-by-image --image '{"S3Object":{"Bucket":"bucket-name","Name":"image-name"}}' \
--collection-id "collection-id" --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 \\) pour corriger les erreurs d’analyse que vous pourriez rencontrer. Par exemple, consultez ce qui suit :
```
aws rekognition search-faces-by-image --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" \
--collection-id "collection-id" --profile profile-name
```
------
#### [ Python ]
Cet exemple affiche des informations sur les visages qui correspondent au visage le plus grand dans une image. L’exemple de code spécifie les paramètres `FaceMatchThreshold` et `MaxFaces` pour limiter les résultats renvoyés dans la réponse.
Dans l’exemple suivant, modifiez les éléments suivants : remplacez la valeur de `collectionId` par la collection à explorer, puis remplacez la valeur de `bucket` et de `photo` par le nom du compartiment S3 et le nom de l’image utilisés à l’étape 2. Remplacez la valeur de `profile_name` dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur.
```
#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
if __name__ == "__main__":
bucket='amzn-s3-demo-bucket'
collectionId='MyCollection'
fileName='input.jpg'
threshold = 70
maxFaces=2
client=boto3.client('rekognition')
response=client.search_faces_by_image(CollectionId=collectionId,
Image={'S3Object':{'Bucket':bucket,'Name':fileName}},
FaceMatchThreshold=threshold,
MaxFaces=maxFaces)
faceMatches=response['FaceMatches']
print ('Matching faces')
for match in faceMatches:
print ('FaceId:' + match['Face']['FaceId'])
print ('Similarity: ' + "{:.2f}".format(match['Similarity']) + "%")
print
```
------
#### [ .NET ]
Cet exemple affiche des informations sur les visages qui correspondent au visage le plus grand dans une image. L’exemple de code spécifie les paramètres `FaceMatchThreshold` et `MaxFaces` pour limiter les résultats renvoyés dans la réponse.
Dans l’exemple suivant, modifiez les éléments suivants : remplacez la valeur de `collectionId` par la collection à explorer, puis remplacez la valeur de `bucket` et de `photo` par le nom du compartiment S3 et le nom de l’image utilisés à l’étape 2.
```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)
using System;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;
public class SearchFacesMatchingImage
{
public static void Example()
{
String collectionId = "MyCollection";
String bucket = "amzn-s3-demo-bucket";
String photo = "input.jpg";
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();
// Get an image object from S3 bucket.
Image image = new Image()
{
S3Object = new S3Object()
{
Bucket = bucket,
Name = photo
}
};
SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
{
CollectionId = collectionId,
Image = image,
FaceMatchThreshold = 70F,
MaxFaces = 2
};
SearchFacesByImageResponse searchFacesByImageResponse = rekognitionClient.SearchFacesByImage(searchFacesByImageRequest);
Console.WriteLine("Faces matching largest face in image from " + photo);
foreach (FaceMatch face in searchFacesByImageResponse.FaceMatches)
Console.WriteLine("FaceId: " + face.Face.FaceId + ", Similarity: " + face.Similarity);
}
}
```
------
## SearchFacesByImage demande d'opération
Les paramètres d’entrée de `SearchFacesImageByImage` correspondent à la collection à explorer et à l’emplacement de l’image source. Dans cet exemple, l’image source est stockée dans un compartiment Amazon S3 (`S3Object`). Sont également spécifiés le nombre maximal de visages à renvoyer (`Maxfaces`) et le niveau de fiabilité minimal auquel doit correspondre un visage pour être renvoyé (`FaceMatchThreshold`).
```
{
"CollectionId": "MyCollection",
"Image": {
"S3Object": {
"Bucket": "bucket",
"Name": "input.jpg"
}
},
"MaxFaces": 2,
"FaceMatchThreshold": 99
}
```
## SearchFacesByImage réponse à l'opération
A partir d’une image d’entrée donnée (.jpeg ou .png), l’opération détecte dans un premier temps le visage dans l’image d’entrée, puis recherche dans la collection de visages spécifiée des visages similaires.
**Note**
Si le service détecte plusieurs visages dans l’image d’entrée, il utilise le visage détecté le plus grand pour explorer la collection de visages.
L’opération renvoie un tableau des correspondances de visage qui ont été trouvées, ainsi que des informations sur le visage d’entrée. Ces informations incluent notamment le cadre de délimitation, ainsi que la valeur de fiabilité, qui indique le niveau de certitude que le cadre de délimitation contient un visage.
Par défaut, `SearchFacesByImage` renvoie les visages pour lesquels l’algorithme détecte une similarité de plus de 80 %. La similarité indique à quel point le visage correspond au visage en entrée. Le cas échéant, vous pouvez l’utiliser `FaceMatchThreshold` pour spécifier une autre valeur. Pour chaque correspondance de visage trouvée, la réponse inclut la similarité et les métadonnées faciales, comme l’illustre l’exemple de réponse suivant :
```
{
"FaceMatches": [
{
"Face": {
"BoundingBox": {
"Height": 0.06333330273628235,
"Left": 0.1718519926071167,
"Top": 0.7366669774055481,
"Width": 0.11061699688434601
},
"Confidence": 100,
"ExternalImageId": "input.jpg",
"FaceId": "578e2e1b-d0b0-493c-aa39-ba476a421a34",
"ImageId": "9ba38e68-35b6-5509-9d2e-fcffa75d1653"
},
"Similarity": 99.9764175415039
}
],
"FaceModelVersion": "3.0",
"SearchedFaceBoundingBox": {
"Height": 0.06333333253860474,
"Left": 0.17185185849666595,
"Top": 0.7366666793823242,
"Width": 0.11061728745698929
},
"SearchedFaceConfidence": 99.99999237060547
}
```