Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Búsqueda de usuarios (imagen) `SearchUsersByImage` busca en el CollectionID especificado los usuarios de una colección que coincidan con el rostro más grande detectado en una imagen proporcionada. De forma predeterminada, SearchUsersByImage devuelve los ID de usuario para los que la puntuación de similitud es superior al 80%. La similitud indica en qué medida el UserID coincide con el rostro más grande detectado en la imagen suministrada. Si se devuelven varios UserID, se muestran en orden de mayor a menor puntuación de similitud. Si lo desea, puede utilizar el UserMatchThreshold para especificar un valor diferente. Para obtener más información, consulte [Administrar usuarios en una colección](managing-face-collections.md#collections-manage-users). **Para buscar usuarios por imagen (SDK)** 1. Si aún no lo ha hecho: 1. Cree o actualice un usuario de `AmazonRekognitionFullAccess` con permisos. Para obtener más información, consulte [Paso 1: Configurar una cuenta de AWS y crear un usuario](setting-up.md#setting-up-iam). 1. Instale y configure los AWS CLI y los AWS SDK. Para obtener más información, consulte [Paso 2: Configure el AWS CLI and AWS SDK](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `SearchUsersByImage`. ------ #### [ Java ] En este ejemplo de Java, se buscan los usuarios de una colección a partir de una imagen de entrada mediante la operación `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 ] Este AWS CLI comando busca los usuarios de una colección en función de una imagen de entrada, con la `SearchUsersByImage` operación. ``` aws rekognition search-users-by-image --image '{"S3Object":{"Bucket":"{{s3BucketName}}","Name":"{{file-name}}"}}' --collection-id {{MyCollectionId}} --region {{region-name}} ``` ------ #### [ Python ] En el siguiente ejemplo, se buscan los usuarios de una colección a partir de una imagen de entrada mediante la operación `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 solicitud de operación La solicitud para `SearchUsersByImage` incluye la colección en la que se busca la imagen y la ubicación de la imagen de origen. En este ejemplo, la imagen de origen se guarda en un bucket de Amazon S3 (`S3Object`). También se especifica el número máximo de usuarios que se devuelven (`MaxUsers`) y la confianza mínima que debe asociarse para que se devuelva un usuario (`UserMatchThreshold`). ``` { "CollectionId": "MyCollection", "Image": { "S3Object": { "Bucket": "bucket", "Name": "input.jpg" } }, "MaxUsers": 2, "UserMatchThreshold": 99 } ``` ## SearchUsersByImage respuesta de operación La respuesta para `SearchUsersByImage` incluye un `FaceDetail` objeto para`SearchedFace`, así como una lista de UserMatches con `UserId``Similarity`, y `UserStatus` para cada uno de ellos. Si la imagen de entrada contenía más de una cara, también se UnsearchedFaces devolverá una lista de. ``` { "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" ] } ] } ```