Ricerca di utenti (immagine)

SearchUsersByImage ricerca nel CollectionID specificato gli utenti in una raccolta che corrispondano al volto più grande rilevato in un'immagine fornita. Per impostazione predefinita, SearchUsersByImage restituisce Utente IDs per il quale il punteggio di somiglianza è superiore all'80%. La somiglianza indica quanto lo UserID corrisponda al volto più grande rilevato nell'immagine fornita. Se IDs vengono restituiti più utenti, questi vengono elencati in ordine dal punteggio di somiglianza più alto al più basso. Facoltativamente, è possibile utilizzare il UserMatchThreshold per specificare un valore diverso. Per ulteriori informazioni, consulta Gestione degli utenti in una raccolta.

Per cercare gli utenti per immagine (SDK)

1. Se non lo hai già fatto:

   1. Crea o aggiorna un utente con le autorizzazioni AmazonRekognitionFullAccess. Per ulteriori informazioni, consulta Fase 1: impostazione di un account AWS e creazione di un utente.

   2. Installa e configura il AWS CLI e il AWS SDKs. Per ulteriori informazioni, consulta Passaggio 2: configura AWS CLI e AWS SDKs.

2. Utilizzare i seguenti esempi per richiamare l'operazione SearchUsersByImage.

   Java

   Questo esempio di Java cerca gli utenti di una raccolta in base a un'immagine di input, utilizzando l'operazione SearchUsersByImage.

   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.S3Object;
   import com.amazonaws.services.rekognition.model.SearchUsersByImageRequest;
   import com.amazonaws.services.rekognition.model.SearchUsersByImageResult;
   import com.amazonaws.services.rekognition.model.UserMatch;
   
   
   public class SearchUsersByImage {
       //Replace bucket, collectionId and photo with your values.
       public static final String collectionId = "MyCollection";
       public static final String s3Bucket = "bucket";
       public static final String s3PhotoFileKey = "input.jpg";
   
       public static void main(String[] args) throws Exception {
   
           AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
   
   
           // Get an image object from S3 bucket.
           Image image = new Image()
                   .withS3Object(new S3Object()
                           .withBucket(s3Bucket)
                           .withName(s3PhotoFileKey));
   
           // Search collection for users similar to the largest face in the image.
           SearchUsersByImageRequest request = new SearchUsersByImageRequest()
                   .withCollectionId(collectionId)
                   .withImage(image)
                   .withUserMatchThreshold(70F)
                   .withMaxUsers(2);
   
           SearchUsersByImageResult result =
                   rekognitionClient.searchUsersByImage(request);
   
           System.out.println("Printing search result with matched user and similarity score");
           for (UserMatch match: result.getUserMatches()) {
               System.out.println(match.getUser().getUserId() + " with similarity score " + match.getSimilarity());
           }
       }
   }

   AWS CLI

   Questo AWS CLI comando cerca gli utenti in una raccolta in base a un'immagine di input, con l'SearchUsersByImageoperazione.

   aws rekognition search-users-by-image --image '{"S3Object":{"Bucket":"s3BucketName","Name":"file-name"}}' --collection-id MyCollectionId --region region-name

   Python

   L'esempio seguente cerca gli utenti di una raccolta in base a un'immagine di input, con l'operazione SearchUsersByImage.

   # 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
   from botocore.exceptions import ClientError
   import logging
   import os
   
   logger = logging.getLogger(__name__)
   session = boto3.Session(profile_name='profile-name')
   client = session.client('rekognition')
   
   def load_image(file_name):
       """
       helper function to load the image for indexFaces call from local disk
   
       :param image_file_name: The image file location that will be used by indexFaces call.
       :return: The Image in bytes
       """
       print(f'- loading image: {file_name}')
       with open(file_name, 'rb') as file:
           return {'Bytes': file.read()}
   
   def search_users_by_image(collection_id, image_file):
       """
       SearchUsersByImage operation with user ID provided as the search source
   
       :param collection_id: The ID of the collection where user and faces are stored.
       :param image_file: The image that contains the reference face to search for.
   
       :return: response of SearchUsersByImage API
       """
       logger.info(f'Searching for users using an image: {image_file}')
       try:
           response = client.search_users_by_image(
               CollectionId=collection_id,
               Image=load_image(image_file)
           )
           print(f'- found {len(response["UserMatches"])} matches')
           print([f'- {x["User"]["UserId"]} - {x["Similarity"]}%' for x in response["UserMatches"]])
       except ClientError:
           logger.exception(f'Failed to perform SearchUsersByImage with given image: {image_file}')
           raise
       else:
           print(response)
           return response
   
   def main():
       collection_id = "collection-id"
       IMAGE_SEARCH_SOURCE = os.getcwd() + '/image_path'
       search_users_by_image(collection_id, IMAGE_SEARCH_SOURCE)
   
   if __name__ == "__main__":
       main()

SearchUsersByImage richiesta di operazione

La richiesta per SearchUsersByImage include la raccolta in cui eseguire la ricerca e l'ubicazione dell'immagine di origine. In questo esempio, l'immagine di origine è archiviata in un bucket Amazon S3 ( S3Object ). Sono specificati anche il numero massimo di utenti da restituire ( MaxUsers ) e la confidenza minima da soddisfare affinché un volto venga restituito ( UserMatchThreshold).

{
    "CollectionId": "MyCollection",
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "input.jpg"
        }
    },
    "MaxUsers": 2,
    "UserMatchThreshold": 99
}
            

SearchUsersByImage risposta operativa

La risposta per SearchUsersByImage include un FaceDetail oggetto perSearchedFace, oltre a un elenco di UserMatches con UserIdSimilarity, e UserStatus per ciascuno. Se l'immagine di input conteneva più di un volto, UnsearchedFaces verrà restituito anche un elenco di.

{
    "SearchedFace": {
        "FaceDetail": {
            "BoundingBox": {
                "Width": 0.23692893981933594, 
                "Top": 0.19235000014305115, 
                "Left": 0.39177176356315613, 
                "Height": 0.5437348484992981
            }
        }
    }, 
    "UserMatches": [
        {
            "User": {
                "UserId": "demoUser1", 
                "UserStatus": "ACTIVE"
            }, 
            "Similarity": 100.0
        }, 
        {
            "User": {
                "UserId": "demoUser2", 
                "UserStatus": "ACTIVE"
            }, 
            "Similarity": 99.97946166992188
        }
    ], 
    "FaceModelVersion": "6", 
    "UnsearchedFaces": [
        {
            "FaceDetails": {
                "BoundingBox": {
                    "Width": 0.031677018851041794, 
                    "Top": 0.5593535900115967, 
                    "Left": 0.6102562546730042, 
                    "Height": 0.0682177022099495
                }
            }, 
            "Reasons": [
                "FACE_NOT_LARGEST"
            ]
        }, 
        {
            "FaceDetails": {
                "BoundingBox": {
                    "Width": 0.03254449740052223, 
                    "Top": 0.6080358028411865, 
                    "Left": 0.516062319278717, 
                    "Height": 0.06347997486591339
                }
            }, 
            "Reasons": [
                "FACE_NOT_LARGEST"
            ]
        }
    ]
}