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 rostros en una colección Amazon Rekognition le permite usar un rostro de entrada para buscar coincidencias en una colección de rostros almacenados. Empiece por almacenar la información sobre los rostros detectados en contenedores del lado del servidor denominados «colecciones». Las colecciones almacenan tanto caras como usuarios individuales (algunas caras de la misma persona). Los rostros individuales se almacenan como vectores faciales, una representación matemática del rostro (no una imagen real del rostro). Se pueden usar diferentes imágenes de la misma persona para crear y almacenar varios vectores faciales en la misma colección. Después, puede agregar varios vectores faciales de la misma persona para crear un vector de usuario. Los vectores de usuario pueden ofrecer una mayor precisión en la búsqueda de rostros con representaciones más robustas, que contienen distintos grados de iluminación, nitidez, pose, apariencia, etc. Una vez que haya creado una colección, puede usar un rostro de entrada para buscar vectores de usuario o vectores de rostros coincidentes en una colección. La búsqueda en vectores de usuarios puede mejorar considerablemente la precisión en comparación con la búsqueda en vectores de rostros individuales. Puede utilizar rostros detectados en imágenes, vídeos almacenados y vídeos en streaming para buscar en los vectores de rostros almacenados. Puede utilizar los rostros detectados en las imágenes para buscar en los vectores de usuario almacenados. Para almacenar la información del rostro, tiene que hacer lo siguiente: 1. Crear una colección: para almacenar información facial, primero debes crear ([CreateCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateCollection.html)) una colección de rostros en una de las AWS regiones de tu cuenta. Esta colección de rostros se especifica cuando se llama a la operación `IndexFaces`. 1. Indexar rostros: la [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html)operación detecta los rostros de una imagen, extrae y almacena los vectores faciales de la colección. Puede usar esta operación para detectar rostros en una imagen y conservar la información sobre los rasgos faciales que se detecten en una colección. Este es un ejemplo de una operación de API *con almacenamiento* porque el servicio almacena la información de vectores faciales en el servidor. Para crear un usuario y asociarle varios vectores faciales, debe hacer lo siguiente: 1. Crear un usuario: primero debe crear un usuario con [CreateUser](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateUser.html). Puede mejorar la precisión de la coincidencia de rostros agregando varios vectores faciales de la misma persona en un vector de usuario. Puede asociar hasta 100 vectores faciales a un vector de usuario. 1. Asociar caras: después de crear el usuario, puede añadir vectores faciales existentes a ese usuario con la [AssociateFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_AssociateFaces.html)operación. Los vectores faciales deben residir en la misma colección que un vector de usuario para poder asociarse a ese vector de usuario. Tras crear una colección y almacenar los vectores faciales y de usuario, puede utilizar las siguientes operaciones para buscar coincidencias faciales: + [SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html)- Para buscar rostros individuales almacenados con un rostro de una imagen. + [SearchFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFaces.html)- Para buscar rostros individuales almacenados con un identificador facial suministrado. + [SearchUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsers.html)- Para buscar usuarios almacenados con un identificador facial o un seudónimo proporcionados. + [SearchUsersByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsersByImage.html)- Para buscar usuarios almacenados con un rostro de una imagen. + [StartFaceSearch](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartFaceSearch.html)- Para buscar rostros en un vídeo almacenado. + [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)- Para buscar rostros en un vídeo en streaming. **nota** Las colecciones almacenan vectores faciales, que son representaciones matemáticas de los rostros. Las colecciones no almacenan imágenes de rostros. Los siguientes diagramas muestran el orden de las operaciones de llamada en función de los objetivos de uso de las colecciones por parte del usuario: **Para una máxima precisión de la coincidencia con los vectores de usuario:** ![\[El diagrama muestra cómo almacenar y buscar los vectores faciales de los usuarios en una colección y muestra operaciones como CreateCollection IndexFaces CreateUser, AssociateFaces, SearchUsersByImage, y SearchUsers.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/uservectorsCollection.png) **Para una coincidencia de alta precisión con vectores faciales individuales:** ![\[Diagrama que muestra el almacenamiento y la búsqueda de rostros en una colección, enumera operaciones como CreateCollection IndexFaces StartFaceSearch, CreateStreamProcessor,, SearchFacesByImage, y SearchFaces.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/facevectorsCollection.png) Puede utilizar las colecciones en diversas situaciones. Por ejemplo, puede crear una colección de rostros que almacene los rostros detectados a partir de las imágenes escaneadas de las tarjetas de identificación de los empleados y emitidas IDs por el gobierno mediante `AssociateFaces` las operaciones `IndexFaces` and. Cuando un empleado entra en el edificio, se captura una imagen del rostro del empleado y se envía a la operación `SearchUsersByImage`. Si el rostro coincidente produce una puntuación de similitud lo suficientemente alta (por ejemplo, un 99%), se puede autenticar al empleado. # Administración de colecciones de rostros, rostros y usuarios La colección de rostros es el recurso que Amazon Rekognition utiliza para incluir la información relacionada con los rostros y los usuarios. Se utilizan varias operaciones de la API de Rekognition para administrar la colección en sí, además de cualquier rostro o vector facial almacenado en la colección. ## Administración de una colección La colección de rostros es el principal recurso de Amazon Rekognition y cada colección de rostros que se crea tiene un nombre de recurso de Amazon (ARN) único. Creas cada colección de rostros en una AWS región específica de tu cuenta. Cuando se crea una nueva colección, está asociada a la versión más reciente del modelo de detección de rostros. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). Puede realizar las siguientes operaciones de administración en una colección: + Crear una colección con [CreateCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateCollection.html). Para obtener más información, consulte [Creación de una colección](create-collection-procedure.md). + Enumerar las colecciones disponibles con [ListCollections](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListCollections.html). Para obtener más información, consulte [Listado de colecciones](list-collection-procedure.md). + Describir una colección con [DescribeCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeCollection.html). Para obtener más información, consulte [Descripción de una colección](describe-collection-procedure.md). + Eliminar una colección con [DeleteCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteCollection.html). Para obtener más información, consulte [Eliminación de una colección](delete-collection-procedure.md). ## Administración de rostros en una colección Una vez creada una colección de rostros, puede almacenar rostros en ella. Amazon Rekognition ofrece las siguientes operaciones para la administración de los rostros de una colección: + La operación [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html) detecta rostros en la imagen de entrada (JPEG o PNG) y las añade a la colección de rostros especificada. Se devuelve un ID de rostro único por cada rostro detectado en la imagen. Una vez guardados los rostros, puede buscar rostros coincidentes en la colección. Para obtener más información, consulte [Agregar rostros a una colección](add-faces-to-collection-procedure.md). + La operación [ListFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListFaces.html) enumera los rostros de una colección. Para obtener más información, consulte [Agregar rostros a una colección](add-faces-to-collection-procedure.md). + La operación [DeleteFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteFaces.html) elimina los rostros de una colección. Para obtener más información, consulte [Eliminación de rostros de una colección](delete-faces-procedure.md). ## Administrar usuarios en una colección Después de almacenar varios vectores de rostros de la misma persona, puede mejorar la precisión asociando todos esos vectores faciales en un vector de usuario. Puede utilizar las siguientes operaciones para administrar sus usuarios: + [CreateUser](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateUser.html)- La operación crea un nuevo usuario en una colección con un ID de usuario único proporcionado. + [AssociateUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_AssociateUsers.html)- Añade de 1 a 100 caras únicas IDs a un seudónimo. Después de asociar al menos un ID de rostro a un usuario, puede buscar coincidencias con ese usuario en su colección. + [ListUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListUsers.html)- Muestra los usuarios de una colección. + [DeleteUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteUsers.html)- Elimina un usuario de una colección con el ID de usuario proporcionado. + [DisassociateFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DisassociateFaces.html)- Elimina uno o más rostros IDs de un usuario. # Uso de umbrales de similitud para asociar rostros y buscar coincidencias con estos Los umbrales de similitud se utilizan tanto para asociar rostros como para buscar coincidencias con estos. A continuación, se incluyen instrucciones para usar los umbrales de similitud en ambos casos de uso. ## Uso de umbrales de similitud para asociar rostros Al asociar rostros mediante esta [AssociateFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_AssociateFaces.html)operación, es importante asegurarse de que los rostros que se asocien a un usuario sean todos de la misma persona. Como ayuda, el parámetro `UserMatchThreshold` especifica el nivel mínimo de confianza de coincidencia del usuario necesario para que el nuevo rostro se asocie con un `UserID` que ya contenga al menos un `FaceID`. Esto ayuda a garantizar que `FaceIds` esté asociado con el `UserID` correcto. El valor oscila entre 0 y 100 y el valor predeterminado es 75. ## Uso de umbrales de similitud para que coincidan con rostros Le permitimos controlar los resultados de todas las operaciones de búsqueda ([CompareFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CompareFaces.html), [SearchFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFaces.html), [SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html), [SearchUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsers.html), [SearchUsersByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsersByImage.html)) proporcionando un umbral de similitud como parámetro de entrada. `FaceMatchThreshold`, el atributo de entrada del umbral de similitud para `SearchFaces` y `SearchFacesByImage`, controla la cantidad de resultados que se devuelven en función de la similitud con el rostro que se hace coincidir. El atributo de entrada del umbral de similitud para `SearchUsers` y `SearchUsersByImage` es `UserMatchThreshold` controla la cantidad de resultados que se devuelven en función de la similitud con el vector de usuario que se hace coincidir. El atributo de umbral es `SimilarityThreshold` para `CompareFaces`. Las respuestas con un valor de atributo de respuesta `Similarity` inferior al umbral no se devuelven. Este umbral es importante para calibrar su caso de uso, porque puede determinar la cantidad de falsos positivos que se incluyen en los resultados de coincidencia. Esto controla la exhaustividad de los resultados de la búsqueda; mientras más bajo sea el umbral, mayor será la exhaustividad. Todos los sistemas de machine learning son probabilísticos. Debe utilizar su buen juicio al establecer el umbral de similitud correcto, en función de su caso de uso. Por ejemplo, si desea crear una aplicación de fotografía para identificar a miembros de la familia parecidos, puede elegir un umbral más bajo (como, por ejemplo, un 80 %). Por otra parte, para muchos casos de uso para cumplimiento de la ley, le recomendamos utilizar un valor de umbral alto del 99 % o superior para reducir las identificaciones erróneas accidentales. Además de `FaceMatchThreshold` y `UserMatchThreshold`, puede utilizar el atributo de respuesta `Similarity` como medio para reducir las identificaciones erróneas accidentales. Por ejemplo, puede optar por utilizar un umbral bajo (como el 80 %) para devolver más resultados. A continuación, puede utilizar el atributo de respuesta Similitud (porcentaje de similitud) para restringir la selección y filtrar por las respuestas correctas en la aplicación. Una vez más, usar una similitud superior (como, por ejemplo, del 99 % o más) reduce el riesgo de identificación errónea. # Guía para indexar rostros en escenarios comunes A continuación se presentan las directrices para usar `IndexFaces` en situaciones comunes. ## Aplicaciones críticas o de seguridad pública + Llame a [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html) con imágenes que contengan un solo rostro por imagen y asocie el ID de rostro devuelto con el identificador del sujeto de la imagen. + Puede utilizar [DetectFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectFaces.html) antes de la indexación para comprobar que solo haya un rostro en la imagen. Si se detecta más de un rostro, vuelva a enviar la imagen después de revisarla y con solo un rostro presente en ella. Esto impide indexar varios rostros y asociárselos a la misma persona involuntariamente. ## Aplicaciones de uso compartido de fotografías y redes sociales + Debe realizar una llamada a `IndexFaces` sin restricciones respecto a las imágenes que contienen varios rostros en casos de uso como los álbumes de familia. En estos casos, se debe identificar a cada persona en cada foto y utilizar esa información para agrupar las fotos en función de las personas que aparecen en ellas. ## Uso general + Indexe varias imágenes diferentes de la misma persona, especialmente con diferentes atributos faciales (posturas, vello, etc.), crear un usuario y asociar los distintos rostros a ese usuario para mejorar la calidad de los resultados coincidentes. + Incluya un proceso de revisión que permita indexar las coincidencias erróneas con el identificador facial correcto, para mejorar la capacidad de encontrar coincidencias de rostros en lo sucesivo. + Para obtener información sobre la calidad de las imágenes, consulte [Recomendaciones para la comparación de rostros en las imágenes de entrada](recommendations-facial-input-images.md). # Búsqueda de rostros y usuarios dentro de una colección Tras crear una colección de rostros y almacenar los vectores de and/or usuario de vectores de rostros, puede buscar coincidencias faciales en una colección de rostros. Con Amazon Rekognition puede buscar rostros en una colección que coincidan con: + Un ID de rostro proporcionado ([SearchFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFaces.html)). Para obtener más información, consulte [Búsqueda de un rostro con un ID de rostro](search-face-with-id-procedure.md). + El rostro de mayor tamaño de una imagen proporcionada ([SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html)). Para obtener más información, consulte [Búsqueda de un rostro con una imagen](search-face-with-image-procedure.md). + Rostros en un vídeo almacenado. Para obtener más información, consulte [Búsqueda de rostros en vídeos almacenados](procedure-person-search-videos.md). + Rostros en un vídeo en streaming. Para obtener más información, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md). Puede usar la operación `CompareFaces` para comparar un rostro de la imagen de origen con los rostros de la imagen de destino. El ámbito de esta comparación se limita a los rostros que se detectan en la imagen de destino. Para obtener más información, consulte [Comparación de rostros en imágenes](https://docs.aws.amazon.com/rekognition/latest/dg/faces-comparefaces.html). Las distintas operaciones de búsqueda que se muestran en la siguiente lista comparan un rostro (identificado mediante un `FaceId` o una imagen de entrada) con todos los rostros almacenados en una colección de rostros determinada: + [SearchFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFaces.html) + [SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html) + [SearchUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsers.html) + [SearchUsersByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsersByImage.html) # Casos de uso para fines de seguridad pública Si implementa sistemas de detección y comparación faciales en casos de uso relacionados con la seguridad pública, además de las recomendaciones de [Prácticas recomendadas para sensores, vídeos e imágenes de entrada](best-practices.md) y [Guía para indexar rostros en escenarios comunes](guidance-index-faces.md), debe aplicar las prácticas recomendadas que se indican a continuación. En primer lugar, debe aplicar umbrales de confianza del 99 % o más con el fin de reducir la cantidad de errores y falsos positivos. En segundo lugar, debe incluir revisores humanos para que comprueben los resultados recibidos del sistema de detección o comparación de rostros y nunca deben tomarse decisiones basadas en los resultados del sistema sin que una persona los haya sometido previamente a revisión. Los sistemas de detección y comparación de rostros deben utilizarse como herramienta para filtrar los resultados y permitir que las personas revisen y estudien las opciones rápidamente. En tercer lugar, recomendamos transparencia respecto al uso de los sistemas de detección y comparación de rostros en estos casos de uso; esto incluye, siempre que sea posible, informar a los usuarios finales y a los sujetos del uso de estos sistemas, obtener su consentimiento para este tipo de uso y poner a su disposición un mecanismo que les permita aportar comentarios para mejorar el sistema. Si usted es una organismo de las fuerzas del orden que utiliza la característica de comparación de rostros de Amazon Rekognition en relación con investigaciones criminales, debe cumplir los requisitos mostrados en las [Condiciones de servicio de AWS](https://aws.amazon.com/service-terms/). Esto incluye lo siguiente. + Contar con personal debidamente formado que revise todas las decisiones para tomar medidas que puedan afectar a las libertades civiles de una persona o derechos humanos equivalentes. + Formar al personal en el uso responsable de los sistemas de reconocimiento facial. + Divulgar públicamente el uso que hace su organismo de los sistemas de reconocimiento facial. + No utilizar Amazon Rekognition para la vigilancia constante de una persona sin revisión independiente o en circunstancias extremas. En todos los casos, las coincidencias de la comparación facial deberían analizarse junto con otras pruebas de peso y no deberían tomarse como el único factor determinante para actuar. Sin embargo, si se utiliza la comparación facial en algunos non-law-enforcement escenarios (por ejemplo, para desbloquear un teléfono o autenticar la identidad de un empleado para acceder a un edificio de oficinas privado y seguro), estas decisiones no requerirían una auditoría manual porque no afectarían a las libertades civiles de una persona ni a sus derechos humanos equivalentes. Si va a usar un sistema de detección o comparación de rostros para casos de uso relacionados con la seguridad pública, debe aplicar las prácticas recomendadas mencionadas anteriormente. Además, debe consultar los recursos publicados sobre el uso de la comparación facial. Esto incluye documentos como la [Face Recognition Policy Template for State, Local, and Tribal Criminal Intelligence and Investigative Activities](https://www.bja.gov/Publications/Face-Recognition-Policy-Development-Template-508-compliant.pdf). Se trata de una plantilla de desarrollo de políticas de reconocimiento facial para su uso en actividades de inteligencia e investigación de delitos que está disponible a través de la Oficina de Asistencia Jurídica (Bureau of Justice Assistance) del Departamento de Justicia (Department of Justice) estadounidense. La plantilla proporciona varios recursos relativos a la comparación facial y a la identificación biométrica. Se ha diseñado para proporcionar a los organismos de seguridad pública, policiales y judiciales un marco para el desarrollo de políticas de comparación facial que cumpla la legislación aplicable, reduzca los riesgos para la privacidad y determine la responsabilidad y la vigilancia de las entidades. Otros recursos son las prácticas recomendadas para aplicar el reconocimiento facial a usos comerciales ([ Best Privacy Practices for Commercial Use of Facial Recognition](https://www.ntia.doc.gov/files/ntia/publications/privacy_best_practices_recommendations_for_commercial_use_of_facial_recogntion.pdf)) de la Administración Nacional de Telecomunicaciones e Información (National Telecommunications and Information Administration) y las mejores prácticas para los usos comunes del reconocimiento facial ([Best Practices for Common Uses of Facial Recognition](https://www.ftc.gov/sites/default/files/documents/reports/facing-facts-best-practices-common-uses-facial-recognition-technologies/121022facialtechrpt.pdf)) elaboradas por el personal de la Comisión Federal de Comercio (Federal Trade Commission) (ambas estadounidenses). Es posible que se elaboren y publiquen otros recursos más adelante. Por ello, es importante mantenerse informado continuamente sobre este tema tan importante. Le recordamos que debe cumplir todas las leyes aplicables cuando utilice los servicios de AWS y que no puede usar ningún servicio de AWS de ninguna manera que infrinja los derechos de otros o que pueda ser perjudicial para los demás. Esto significa que no puede usar los servicios de AWS en casos de uso con fines de seguridad pública de ningún modo que discrimine ilegalmente a personas o que infrinja sus libertades civiles o los derechos procesales o de privacidad que le asisten. Debe obtener asesoramiento jurídico adecuado según sea necesario para revisar los requisitos y dudas legales relativos a su caso de uso. ## Uso de Amazon Rekognition para mejorar la seguridad pública Amazon Rekognition puede ayudar a la seguridad pública y al cumplimiento de la ley en situaciones como encontrar a niños perdidos, luchar contra la trata de seres humanos o prevenir delitos. En situaciones relacionadas con el cumplimiento de la ley y la seguridad pública, tenga en cuenta lo siguiente: + Utilice Amazon Rekognition como el primer paso a la hora de encontrar posibles coincidencias. Gracias a las respuestas de las operaciones faciales de Amazon Rekognition, puede obtener rápidamente una serie de posibles coincidencias para examinarlas posteriormente. + No utilice respuestas de Amazon Rekognition para tomar decisiones autónomas para escenarios que requieren el análisis de un humano. Si usted es un organismo de las fuerzas del orden que utiliza Amazon Rekognition para ayudar a identificar a una persona en relación con una investigación criminal y se van a tomar medidas basadas en la identificación que podrían afectar a las libertades civiles de esa persona o a derechos humanos equivalentes, la decisión de emprender medidas la debe tomar una persona debidamente formada en función de su juicio objetivo de las pruebas de identificación. + Utilice un umbral de similitud del 99 % en los casos en los que sea necesario que las coincidencias de similitudes de los rostros sea muy precisa. Un ejemplo de esto sería la autenticación del acceso a un edificio. + Cuando los derechos civiles son un problema, como en casos de uso relacionados con la ley, utilice umbrales de confianza del 99 % o superiores y asegúrese de que una persona revisa las predicciones de comparación facial para garantizar que no se infringen los derechos civiles de ningún individuo. + Utilice un umbral de similitud inferior al 99 % en situaciones en las que resulte beneficioso contar con un conjunto más grande de coincidencias posibles. Un ejemplo de esto es la búsqueda de personas desaparecidas. En caso necesario, puede utilizar el atributo de respuesta Similarity para determinar la similitud de posibles coincidencias con la persona que desea reconocer.  + Tenga un plan para coincidencias de rostros falsos positivos devueltos por Amazon Rekognition. Por ejemplo, mejore las coincidencias utilizando varias imágenes de la misma persona cuando cree el índice con la operación [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html). Para obtener más información, consulte [Guía para indexar rostros en escenarios comunes](guidance-index-faces.md). En otros casos de uso (por ejemplo, las redes sociales), recomendamos aplicar su propio sentido común para evaluar si los resultados de Amazon Rekognition han de someterse a revisión humana. Además, en función de los requisitos de la aplicación, el umbral de similitud puede ser menor. # Creación de una colección Puede utilizar la operación [CreateCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateCollection.html) para crear una colección. Para obtener más información, consulte [Administración de una colección](managing-face-collections.md#managing-collections). **Para crear una colección (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 el AWS CLI y el. AWS SDKs Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `CreateCollection`. ------ #### [ Java ] En el siguiente ejemplo se crea una colección y se muestra el nombre de recurso de Amazon (ARN). Cambie el valor de `collectionId` por el nombre de la colección que desea crear. ``` //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.CreateCollectionRequest; import com.amazonaws.services.rekognition.model.CreateCollectionResult; public class CreateCollection { public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); String collectionId = "MyCollection"; System.out.println("Creating collection: " + collectionId ); CreateCollectionRequest request = new CreateCollectionRequest() .withCollectionId(collectionId); CreateCollectionResult createCollectionResult = rekognitionClient.createCollection(request); System.out.println("CollectionArn : " + createCollectionResult.getCollectionArn()); System.out.println("Status code : " + createCollectionResult.getStatusCode().toString()); } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/CreateCollection.java). Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` //snippet-start:[rekognition.java2.create_collection.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.CreateCollectionResponse; import software.amazon.awssdk.services.rekognition.model.CreateCollectionRequest; import software.amazon.awssdk.services.rekognition.model.RekognitionException; //snippet-end:[rekognition.java2.create_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 CreateCollection { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " collectionName - The name of the collection. \n\n"; if (args.length != 1) { System.out.println(usage); System.exit(1); } String collectionId = args[0]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); System.out.println("Creating collection: " +collectionId); createMyCollection(rekClient, collectionId ); rekClient.close(); } // snippet-start:[rekognition.java2.create_collection.main] public static void createMyCollection(RekognitionClient rekClient,String collectionId ) { try { CreateCollectionRequest collectionRequest = CreateCollectionRequest.builder() .collectionId(collectionId) .build(); CreateCollectionResponse collectionResponse = rekClient.createCollection(collectionRequest); System.out.println("CollectionArn: " + collectionResponse.collectionArn()); System.out.println("Status code: " + collectionResponse.statusCode().toString()); } catch(RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.create_collection.main] ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `create-collection` CLI. Reemplace el valor de `collection-id` por el nombre de la colección que desea crear. Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. ``` aws rekognition create-collection --profile profile-name --collection-id "collection-name" ``` ------ #### [ Python ] En el siguiente ejemplo se crea una colección y se muestra el nombre de recurso de Amazon (ARN). Cambie el valor de `collection_id` por el nombre de la colección que desea crear. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 create_collection(collection_id): session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') # Create a collection print('Creating collection:' + collection_id) response = client.create_collection(CollectionId=collection_id) print('Collection ARN: ' + response['CollectionArn']) print('Status code: ' + str(response['StatusCode'])) print('Done...') def main(): collection_id = "collection-id" create_collection(collection_id) if __name__ == "__main__": main() ``` ------ #### [ .NET ] En el siguiente ejemplo se crea una colección y se muestra el nombre de recurso de Amazon (ARN). Cambie el valor de `collectionId` por el nombre de la colección que desea crear. ``` //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 CreateCollection { public static void Example() { AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); String collectionId = "MyCollection"; Console.WriteLine("Creating collection: " + collectionId); CreateCollectionRequest createCollectionRequest = new CreateCollectionRequest() { CollectionId = collectionId }; CreateCollectionResponse createCollectionResponse = rekognitionClient.CreateCollection(createCollectionRequest); Console.WriteLine("CollectionArn : " + createCollectionResponse.CollectionArn); Console.WriteLine("Status code : " + createCollectionResponse.StatusCode); } } ``` ------ #### [ Node.JS ] En el siguiente ejemplo, sustituya el valor de `region` por el nombre de la región asociada a su cuenta y sustituya el valor de `collectionName` por el nombre deseado de su colección. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` //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 { CreateCollectionCommand} from "@aws-sdk/client-rekognition"; import { RekognitionClient } from "@aws-sdk/client-rekognition"; import {fromIni} from '@aws-sdk/credential-providers'; // Set the AWS Region. const REGION = "region-name"; //e.g. "us-east-1" // Set the profile name const profileName = "profile-name" // Name the collection const collectionName = "collection-name" const rekogClient = new RekognitionClient({region: REGION, credentials: fromIni({profile: profileName,}), }); const createCollection = async (collectionName) => { try { console.log(`Creating collection: ${collectionName}`) const data = await rekogClient.send(new CreateCollectionCommand({CollectionId: collectionName})); console.log("Collection ARN:") console.log(data.CollectionARN) console.log("Status Code:") console.log(String(data.StatusCode)) console.log("Success.", data); return data; } catch (err) { console.log("Error", err.stack); } }; createCollection(collectionName) ``` ------ ## CreateCollection solicitud de operación La entrada de `CreationCollection` es el nombre de la colección que desea crear. ``` { "CollectionId": "MyCollection" } ``` ## CreateCollection respuesta de operación Amazon Rekognition crea la colección y devuelve el Nombre de recurso de Amazon (ARN) de la colección que se acaba de crear. ``` { "CollectionArn": "aws:rekognition:us-east-1:acct-id:collection/examplecollection", "StatusCode": 200 } ``` # Etiquetado de colecciones Puede usar etiquetas para identificar, organizar, buscar y filtrar sus colecciones de Amazon Rekognition mediante etiquetas. Cada etiqueta es una marca que consta de una clave y un valor definidos por el usuario. También puede utilizar etiquetas para controlar el acceso a una colección mediante la Administración de identidad y acceso (IAM). Para obtener más información, consulte [Controlar el acceso a AWS los recursos mediante etiquetas de recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html). **Topics** + [Agregar etiquetas a una colección nueva](#add-tag-new-collection) + [Agregar etiquetas a una colección existente](#add-tag-existing-collection) + [Enumerar las etiquetas de una colección](#list-tags-collection) + [Eliminar etiquetas de una colección](#delete-tag-collection) ## Agregar etiquetas a una colección nueva Puede agregar etiquetas a una colección a medida que la crea mediante la operación `CreateCollection`. Indique una o varias etiquetas en el parámetro de entrada `Tags` de la matriz. ------ #### [ AWS CLI ] Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. ``` aws rekognition create-collection --collection-id "collection-name" --tags "{"key1":"value1","key2":"value2"}" --profile profile-name ``` Para los dispositivos de Windows: ``` aws rekognition create-collection --collection-id "collection-name" --tags "{\"key1\":\"value1\",\"key2\":\"value2\"}" --profile profile-name ``` ------ #### [ Python ] Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` import boto3 def create_collection(collection_id): client = boto3.client('rekognition') # Create a collection print('Creating collection:' + collection_id) response = client.create_collection(CollectionId=collection_id) print('Collection ARN: ' + response['CollectionArn']) print('Status code: ' + str(response['StatusCode'])) print('Done...') def main(): collection_id = 'NewCollectionName' create_collection(collection_id) if __name__ == "__main__": main() ``` ------ ## Agregar etiquetas a una colección existente Para agregar una o varias etiquetas a una colección existente, utilice la operación `TagResource`. Indique el nombre de recurso de Amazon (ARN) de la colección (`ResourceArn`) y las etiquetas (`Tags`) que desea añadir. En el siguiente ejemplo se ve cómo añadir dos etiquetas. ------ #### [ AWS CLI ] Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. ``` aws rekognition tag-resource --resource-arn collection-arn --tags "{"key1":"value1","key2":"value2"}" --profile profile-name ``` Para los dispositivos de Windows: ``` aws rekognition tag-resource --resource-arn collection-arn --tags "{\"key1\":\"value1\",\"key2\":\"value2\"}" --profile profile-name ``` ------ #### [ Python ] Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 create_tag(collection_id): session = boto3.Session(profile_name='default') client = session.client('rekognition') response = client.tag_resource(ResourceArn=collection_id, Tags={ "KeyName": "ValueName" }) print(response) if "'HTTPStatusCode': 200" in str(response): print("Success!!") def main(): collection_arn = "collection-arn" create_tag(collection_arn) if __name__ == "__main__": main() ``` ------ **nota** Si no conoce el nombre del recurso de Amazon de la colección, puede usar la operación `DescribeCollection`. ## Enumerar las etiquetas de una colección Para enumerar las etiquetas adjuntas a una colección, utilice la operación `ListTagsForResource` y especifique el ARN de la colección (`ResourceArn`). El resultado será la asignación de las claves y los valores de las etiquetas que se asocian a la colección especificada. ------ #### [ AWS CLI ] Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. ``` aws rekognition list-tags-for-resource --resource-arn resource-arn --profile profile-name ``` ------ #### [ Python ] Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` import boto3 def list_tags(): client = boto3.client('rekognition') response = client.list_tags_for_resource(ResourceArn="arn:aws:rekognition:region-name:5498347593847598:collection/NewCollectionName") print(response) def main(): list_tags() if __name__ == "__main__": main() ``` ------ El resultado muestra una lista de etiquetas adjuntas a la colección: ``` { "Tags": { "Dept": "Engineering", "Name": "Ana Silva Carolina", "Role": "Developer" } } ``` ## Eliminar etiquetas de una colección Para eliminar una o más etiquetas de una colección, utilice la operación `UntagResource`. Indique el ARN del modelo (`ResourceArn`) y las claves de etiqueta (`Tag-Keys`) que desee eliminar. ------ #### [ AWS CLI ] Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. ``` aws rekognition untag-resource --resource-arn resource-arn --profile profile-name --tag-keys "key1" "key2" ``` Si lo prefiere, también puede indicar claves de etiqueta en este formato: ``` --tag-keys key1,key2 ``` ------ #### [ Python ] Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` import boto3 def list_tags(): client = boto3.client('rekognition') response = client.untag_resource(ResourceArn="arn:aws:rekognition:region-name:5498347593847598:collection/NewCollectionName", TagKeys=['KeyName']) print(response) def main(): list_tags() if __name__ == "__main__": main() ``` ------ # Listado de colecciones Puede utilizar la operación [ListCollections](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListCollections.html) para obtener una lista de las colecciones de la región que utiliza. Para obtener más información, consulte [Administración de una colección](managing-face-collections.md#managing-collections). **Para enumerar colecciones (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `ListCollections`. ------ #### [ Java ] En el ejemplo siguiente se muestra una lista de las colecciones de la región actual. ``` //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 java.util.List; import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.ListCollectionsRequest; import com.amazonaws.services.rekognition.model.ListCollectionsResult; public class ListCollections { public static void main(String[] args) throws Exception { AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder.defaultClient(); System.out.println("Listing collections"); int limit = 10; ListCollectionsResult listCollectionsResult = null; String paginationToken = null; do { if (listCollectionsResult != null) { paginationToken = listCollectionsResult.getNextToken(); } ListCollectionsRequest listCollectionsRequest = new ListCollectionsRequest() .withMaxResults(limit) .withNextToken(paginationToken); listCollectionsResult=amazonRekognition.listCollections(listCollectionsRequest); List < String > collectionIds = listCollectionsResult.getCollectionIds(); for (String resultId: collectionIds) { System.out.println(resultId); } } while (listCollectionsResult != null && listCollectionsResult.getNextToken() != null); } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/ListCollections.java). ``` //snippet-start:[rekognition.java2.list_collections.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.ListCollectionsRequest; import software.amazon.awssdk.services.rekognition.model.ListCollectionsResponse; import software.amazon.awssdk.services.rekognition.model.RekognitionException; import java.util.List; //snippet-end:[rekognition.java2.list_collections.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 ListCollections { public static void main(String[] args) { Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); System.out.println("Listing collections"); listAllCollections(rekClient); rekClient.close(); } // snippet-start:[rekognition.java2.list_collections.main] public static void listAllCollections(RekognitionClient rekClient) { try { ListCollectionsRequest listCollectionsRequest = ListCollectionsRequest.builder() .maxResults(10) .build(); ListCollectionsResponse response = rekClient.listCollections(listCollectionsRequest); List collectionIds = response.collectionIds(); for (String resultId : collectionIds) { System.out.println(resultId); } } catch (RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.list_collections.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `list-collections` CLI. Sustituya el valor de `profile_name` de por el nombre de su perfil de desarrollador. ``` aws rekognition list-collections --profile profile-name ``` ------ #### [ Python ] En el ejemplo siguiente se muestra una lista de las colecciones de la región actual. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` #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 list_collections(): max_results=2 client=boto3.client('rekognition') #Display all the collections print('Displaying collections...') response=client.list_collections(MaxResults=max_results) collection_count=0 done=False while done==False: collections=response['CollectionIds'] for collection in collections: print (collection) collection_count+=1 if 'NextToken' in response: nextToken=response['NextToken'] response=client.list_collections(NextToken=nextToken,MaxResults=max_results) else: done=True return collection_count def main(): collection_count=list_collections() print("collections: " + str(collection_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] En el ejemplo siguiente se muestra una lista de las colecciones de la región actual. ``` //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 ListCollections { public static void Example() { AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); Console.WriteLine("Listing collections"); int limit = 10; ListCollectionsResponse listCollectionsResponse = null; String paginationToken = null; do { if (listCollectionsResponse != null) paginationToken = listCollectionsResponse.NextToken; ListCollectionsRequest listCollectionsRequest = new ListCollectionsRequest() { MaxResults = limit, NextToken = paginationToken }; listCollectionsResponse = rekognitionClient.ListCollections(listCollectionsRequest); foreach (String resultId in listCollectionsResponse.CollectionIds) Console.WriteLine(resultId); } while (listCollectionsResponse != null && listCollectionsResponse.NextToken != null); } } ``` ------ #### [ Node.js ] Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` //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 { ListCollectionsCommand } from "@aws-sdk/client-rekognition"; import { RekognitionClient } from "@aws-sdk/client-rekognition"; import {fromIni} from '@aws-sdk/credential-providers'; // Set the AWS Region. const REGION = "region-name"; //e.g. "us-east-1" // Set the profile name const profileName = "profile-name" // Name the collection const rekogClient = new RekognitionClient({region: REGION, credentials: fromIni({profile: profileName,}), }); const listCollection = async () => { var max_results = 10 console.log("Displaying collections:") var response = await rekogClient.send(new ListCollectionsCommand({MaxResults: max_results})) var collection_count = 0 var done = false while (done == false){ var collections = response.CollectionIds collections.forEach(collection => { console.log(collection) collection_count += 1 }); return collection_count } } var collect_list = await listCollection() console.log(collect_list) ``` ------ ## ListCollections solicitud de operación La entrada de `ListCollections` es el número máximo de colecciones que se va a devolver. ``` { "MaxResults": 2 } ``` Si la respuesta tiene más colecciones que los que requiere `MaxResults`, se devuelve un token que puede utilizar para obtener el siguiente conjunto de resultados, en una llamada posterior a `ListCollections`. Por ejemplo: ``` { "NextToken": "MGYZLAHX1T5a....", "MaxResults": 2 } ``` ## ListCollections respuesta de operación Amazon Rekognition devuelve un conjunto de colecciones (`CollectionIds`). Una matriz independiente (`FaceModelVersions`) proporciona la versión del modelo de rostros utilizada para analizar los rostros de cada colección. Por ejemplo, en la siguiente respuesta JSON, la colección `MyCollection` analiza rostros mediante la versión 2.0 del modelo de rostros. La colección `AnotherCollection` utiliza la versión 3.0 del modelo de rostros. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). `NextToken` es el token que se utiliza para obtener el siguiente conjunto de resultados, en una llamada posterior a `ListCollections`. ``` { "CollectionIds": [ "MyCollection", "AnotherCollection" ], "FaceModelVersions": [ "2.0", "3.0" ], "NextToken": "MGYZLAHX1T5a...." } ``` # Descripción de una colección Puede utilizar la operación [DescribeCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeCollection.html) para obtener la siguiente información acerca de una colección: + El número de rostros que se indexan en la colección. + La versión del modelo que se utiliza con la colección. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). + El nombre de recurso de Amazon (ARN) de la colección. + La fecha y hora de creación de la colección. **Para describir una colección (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `DescribeCollection`. ------ #### [ Java ] Este ejemplo describe una colección. Cambie el valor `collectionId` por el ID de la colección deseada. ``` //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 com.amazonaws.samples; import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.DescribeCollectionRequest; import com.amazonaws.services.rekognition.model.DescribeCollectionResult; public class DescribeCollection { public static void main(String[] args) throws Exception { String collectionId = "CollectionID"; AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); System.out.println("Describing collection: " + collectionId ); DescribeCollectionRequest request = new DescribeCollectionRequest() .withCollectionId(collectionId); DescribeCollectionResult describeCollectionResult = rekognitionClient.describeCollection(request); System.out.println("Collection Arn : " + describeCollectionResult.getCollectionARN()); System.out.println("Face count : " + describeCollectionResult.getFaceCount().toString()); System.out.println("Face model version : " + describeCollectionResult.getFaceModelVersion()); System.out.println("Created : " + describeCollectionResult.getCreationTimestamp().toString()); } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DescribeCollection.java). ``` 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.DescribeCollectionRequest; import software.amazon.awssdk.services.rekognition.model.DescribeCollectionResponse; import software.amazon.awssdk.services.rekognition.model.RekognitionException; //snippet-end:[rekognition.java2.describe_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 DescribeCollection { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " collectionName - The name of the Amazon Rekognition collection. \n\n"; if (args.length != 1) { System.out.println(usage); System.exit(1); } String collectionName = args[0]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); describeColl(rekClient, collectionName); rekClient.close(); } // snippet-start:[rekognition.java2.describe_collection.main] public static void describeColl(RekognitionClient rekClient, String collectionName) { try { DescribeCollectionRequest describeCollectionRequest = DescribeCollectionRequest.builder() .collectionId(collectionName) .build(); DescribeCollectionResponse describeCollectionResponse = rekClient.describeCollection(describeCollectionRequest); System.out.println("Collection Arn : " + describeCollectionResponse.collectionARN()); System.out.println("Created : " + describeCollectionResponse.creationTimestamp().toString()); } catch(RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.describe_collection.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `describe-collection` CLI. Cambie el valor de `collection-id` por el ID de la colección deseada. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition describe-collection --collection-id collection-name --profile profile-name ``` ------ #### [ Python ] Este ejemplo describe una colección. Cambie el valor `collection_id` por el ID de la colección deseada. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 def describe_collection(collection_id): print('Attempting to describe collection ' + collection_id) session = boto3.Session(profile_name='default') client = session.client('rekognition') try: response = client.describe_collection(CollectionId=collection_id) print("Collection Arn: " + response['CollectionARN']) print("Face Count: " + str(response['FaceCount'])) print("Face Model Version: " + response['FaceModelVersion']) print("Timestamp: " + str(response['CreationTimestamp'])) except ClientError as e: if e.response['Error']['Code'] == 'ResourceNotFoundException': print('The collection ' + collection_id + ' was not found ') else: print('Error other than Not Found occurred: ' + e.response['Error']['Message']) print('Done...') def main(): collection_id = 'collection-name' describe_collection(collection_id) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo describe una colección. Cambie el valor `collectionId` por el ID de la colección deseada. ``` //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 DescribeCollection { public static void Example() { AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); String collectionId = "CollectionID"; Console.WriteLine("Describing collection: " + collectionId); DescribeCollectionRequest describeCollectionRequest = new DescribeCollectionRequest() { CollectionId = collectionId }; DescribeCollectionResponse describeCollectionResponse = rekognitionClient.DescribeCollection(describeCollectionRequest); Console.WriteLine("Collection ARN: " + describeCollectionResponse.CollectionARN); Console.WriteLine("Face count: " + describeCollectionResponse.FaceCount); Console.WriteLine("Face model version: " + describeCollectionResponse.FaceModelVersion); Console.WriteLine("Created: " + describeCollectionResponse.CreationTimestamp); } } ``` ------ #### [ Node.js ] ``` //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 { DescribeCollectionCommand } from "@aws-sdk/client-rekognition"; import { RekognitionClient } from "@aws-sdk/client-rekognition"; import {fromIni} from '@aws-sdk/credential-providers'; // Set the AWS Region. const REGION = "region-name"; //e.g. "us-east-1" // Set the profile name const profileName = "profile-name" // Name the collection const rekogClient = new RekognitionClient({region: REGION, credentials: fromIni({profile: profileName,}), }); // Name the collection const collection_name = "collection-name" const describeCollection = async (collectionName) => { try { console.log(`Attempting to describe collection named - ${collectionName}`) var response = await rekogClient.send(new DescribeCollectionCommand({CollectionId: collectionName})) console.log('Collection Arn:') console.log(response.CollectionARN) console.log('Face Count:') console.log(response.FaceCount) console.log('Face Model Version:') console.log(response.FaceModelVersion) console.log('Timestamp:') console.log(response.CreationTimestamp) return response; // For unit tests. } catch (err) { console.log("Error", err.stack); } }; describeCollection(collection_name) ``` ------ ## DescribeCollection solicitud de operación La entrada de `DescribeCollection` es el ID de la colección deseada, tal y como se muestra en el siguiente ejemplo de JSON. ``` { "CollectionId": "MyCollection" } ``` ## DescribeCollection respuesta de operación La respuesta incluye: + El número de rostros que se indexan en la colección, `FaceCount`. + La versión del modelo facial que se utiliza con la colección, `FaceModelVersion`. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). + La colección del Nombre de recurso de Amazon, `CollectionARN`. + La fecha y hora de creación de la colección, `CreationTimestamp`. El valor de `CreationTimestamp` es el número de milisegundos desde el formato de tiempo Unix hasta la creación de la colección. El formato de tiempo Unix es 00:00:00 UTC (hora universal coordinada), jueves 1 de enero de 1970. Para obtener más información, consulte [Unix Time (Tiempo Unix)](https://en.wikipedia.org/wiki/Unix_time). ``` { "CollectionARN": "arn:aws:rekognition:us-east-1:nnnnnnnnnnnn:collection/MyCollection", "CreationTimestamp": 1.533422155042E9, "FaceCount": 200, "UserCount" : 20, "FaceModelVersion": "1.0" } ``` # Eliminación de una colección Puede utilizar la operación [DeleteCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteCollection.html) para eliminar una colección. Para obtener más información, consulte [Administración de una colección](managing-face-collections.md#managing-collections). **Para eliminar una colección (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `DeleteCollection`. ------ #### [ Java ] Este ejemplo elimina una colección. Cambie el valor `collectionId` de la colección que desea eliminar. ``` //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.DeleteCollectionRequest; import com.amazonaws.services.rekognition.model.DeleteCollectionResult; public class DeleteCollection { public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); String collectionId = "MyCollection"; System.out.println("Deleting collections"); DeleteCollectionRequest request = new DeleteCollectionRequest() .withCollectionId(collectionId); DeleteCollectionResult deleteCollectionResult = rekognitionClient.deleteCollection(request); System.out.println(collectionId + ": " + deleteCollectionResult.getStatusCode() .toString()); } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DeleteCollection.java). ``` // snippet-start:[rekognition.java2.delete_collection.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.DeleteCollectionRequest; import software.amazon.awssdk.services.rekognition.model.DeleteCollectionResponse; import software.amazon.awssdk.services.rekognition.model.RekognitionException; // snippet-end:[rekognition.java2.delete_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 DeleteCollection { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " collectionId - The id of the collection to delete. \n\n"; if (args.length != 1) { System.out.println(usage); System.exit(1); } String collectionId = args[0]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); System.out.println("Deleting collection: " + collectionId); deleteMyCollection(rekClient, collectionId); rekClient.close(); } // snippet-start:[rekognition.java2.delete_collection.main] public static void deleteMyCollection(RekognitionClient rekClient,String collectionId ) { try { DeleteCollectionRequest deleteCollectionRequest = DeleteCollectionRequest.builder() .collectionId(collectionId) .build(); DeleteCollectionResponse deleteCollectionResponse = rekClient.deleteCollection(deleteCollectionRequest); System.out.println(collectionId + ": " + deleteCollectionResponse.statusCode().toString()); } catch(RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.delete_collection.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `delete-collection` CLI. Reemplace el valor de `collection-id` por el nombre de la colección que desea eliminar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition delete-collection --collection-id collection-name --profile profile-name ``` ------ #### [ Python ] Este ejemplo elimina una colección. Cambie el valor `collection_id` de la colección que desea eliminar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 def delete_collection(collection_id): print('Attempting to delete collection ' + collection_id) session = boto3.Session(profile_name='default') client = session.client('rekognition') status_code = 0 try: response = client.delete_collection(CollectionId=collection_id) status_code = response['StatusCode'] except ClientError as e: if e.response['Error']['Code'] == 'ResourceNotFoundException': print('The collection ' + collection_id + ' was not found ') else: print('Error other than Not Found occurred: ' + e.response['Error']['Message']) status_code = e.response['ResponseMetadata']['HTTPStatusCode'] return (status_code) def main(): collection_id = 'collection-name' status_code = delete_collection(collection_id) print('Status code: ' + str(status_code)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo elimina una colección. Cambie el valor `collectionId` de la colección que desea eliminar. ``` //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 DeleteCollection { public static void Example() { AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); String collectionId = "MyCollection"; Console.WriteLine("Deleting collection: " + collectionId); DeleteCollectionRequest deleteCollectionRequest = new DeleteCollectionRequest() { CollectionId = collectionId }; DeleteCollectionResponse deleteCollectionResponse = rekognitionClient.DeleteCollection(deleteCollectionRequest); Console.WriteLine(collectionId + ": " + deleteCollectionResponse.StatusCode); } } ``` ------ #### [ Node.js ] Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` //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 { DeleteCollectionCommand } from "@aws-sdk/client-rekognition"; import { RekognitionClient } from "@aws-sdk/client-rekognition"; import {fromIni} from '@aws-sdk/credential-providers'; // Set the AWS Region. const REGION = "region-name"; //e.g. "us-east-1" // Set the profile name const profileName = "profile-name" // Name the collection const rekogClient = new RekognitionClient({region: REGION, credentials: fromIni({profile: profileName,}), }); // Name the collection const collection_name = "collection-name" const deleteCollection = async (collectionName) => { try { console.log(`Attempting to delete collection named - ${collectionName}`) var response = await rekogClient.send(new DeleteCollectionCommand({CollectionId: collectionName})) var status_code = response.StatusCode if (status_code = 200){ console.log("Collection successfully deleted.") } return response; // For unit tests. } catch (err) { console.log("Error", err.stack); } }; deleteCollection(collection_name) ``` ------ ## DeleteCollection solicitud de operación La entrada de `DeleteCollection` es el ID de la colección que se va a eliminar, tal y como se muestra en el siguiente ejemplo de JSON. ``` { "CollectionId": "MyCollection" } ``` ## DeleteCollection respuesta de operación La respuesta `DeleteCollection` contiene un código de estado HTTP que indica el éxito o el error de la operación. Se devuelve `200` si la colección se elimina correctamente. ``` {"StatusCode":200} ``` # Agregar rostros a una colección Puede utilizar la operación [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html) para detectar rostros en una imagen y añadirlas a una colección. Para cada rostro detectado, Amazon Rekognition extrae los rasgos faciales y almacena la información de rasgos en una base de datos. Además, el comando almacena los metadatos de cada uno de los rostros detectados en la colección de rostros especificada. Amazon Rekognition no conserva los bytes de las imágenes reales. Para obtener información acerca de cómo proporcionar rostros adecuados para su indexación, consulte [Recomendaciones para la comparación de rostros en las imágenes de entrada](recommendations-facial-input-images.md). Para cada rostro, la operación `IndexFaces` conserva la siguiente información: + **Rasgos faciales multidimensionales**: `IndexFaces` usa análisis faciales para extraer información multidimensional sobre los rasgos faciales y almacena la información en la colección de rostros. No se tiene acceso a esta información directamente. Sin embargo, Amazon Rekognition utiliza esta información cuando busca rostros coincidentes en una colección de rostros.   + **Metadatos**: los metadatos de cada rostro incluyen un cuadro delimitador, un nivel de confianza (que el cuadro delimitador contiene un rostro), IDs asignado por Amazon Rekognition (ID de rostro e ID de imagen) y un ID de imagen externo (si lo has proporcionado) en la solicitud. Esta información se devuelve en respuesta a la llamada a la API `IndexFaces`. Para ver un ejemplo, consulte el elemento `face` en la siguiente respuesta de ejemplo. El servicio devuelve estos metadatos en respuesta a las siguientes llamadas API:   + `[ListFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListFaces.html)` + Operaciones de búsqueda de rostros: las respuestas de [SearchFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFaces.html) y [SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html) devuelven la confianza de cada rostro coincidente, junto con los metadatos del rostro coincidente. El número de rostros indexada por `IndexFaces` depende de la versión del modelo de detección de rostros que esté asociada a la colección de entrada. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). La información sobre los rostros indexados se devuelve en una matriz de objetos [FaceRecord](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_FaceRecord.html). Es posible que desee asociar rostros indexados con la imagen en la que se detectaron. Por ejemplo, es posible que desee mantener un índice en el lado del cliente de imágenes y rostros en las imágenes. Para asociar rostros con una imagen, especifique un ID de imagen en el parámetro de solicitud `ExternalImageId`. El ID de imagen puede ser el nombre de archivo u otro ID que cree. Además de la información anterior que la API conserva en la colección de rostros, la API devuelve también detalles del rostro que no se conservan en la colección. (Consulte el elemento `faceDetail` en la siguiente respuesta de ejemplo). **nota** `DetectFaces` devuelve la misma información, por lo que no es necesario llamar a `DetectFaces` y `IndexFaces` para la misma imagen. ## Filtrado de rostros La IndexFaces operación le permite filtrar los rostros indexados a partir de una imagen. Con `IndexFaces`, puede especificar el número máximo de rostros que desea indexar, o bien indicar que solo se indexen los rostros detectados con un índice de calidad alto. Puede especificar el número máximo de rostros que se indexan mediante `IndexFaces` utilizando el parámetro de entrada `MaxFaces`. Esto resulta útil cuando se desea indexar los rostros de mayor tamaño de una imagen, pero no los más pequeños, como, por ejemplo, los de las personas que están de pie en segundo plano. De forma predeterminada, `IndexFaces` selecciona un estándar de calidad que se utiliza para filtrar los rostros. Puede utilizar el parámetro de entrada `QualityFilter` para establecer explícitamente el estándar de calidad. Los valores son: + `AUTO`: Amazon Rekognition elige el estándar de calidad que se usa para filtrar las caras (valor predeterminado). + `LOW`: todos los rostros, excepto los de menor calidad, están indexados. + `MEDIUM` + `HIGH`: solo se indexan los rostros de mayor calidad. + `NONE`: no se filtran rostros en función de la calidad. `IndexFaces` filtra rostros basándose en lo siguiente: + El rostro es demasiado pequeño en comparación con las dimensiones de la imagen. + El rostro está demasiado borroso. + La imagen es demasiado oscura. + El rostro tiene una postura extrema. + El rostro no tiene suficiente detalle para incluirse en la búsqueda de rostros. **nota** Para utilizar el filtrado según la calidad, necesita una colección asociada a la versión 3, o posterior, del modelo de rostros. Para obtener la versión del modelo de rostros asociado a una colección, llame a [DescribeCollection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeCollection.html). La información sobre los rostros no indexados por `IndexFaces` se devuelve en una matriz de objetos [UnindexedFace](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UnindexedFace.html). La matriz `Reasons` contiene una lista de razones por las que un rostro no se ha indexado. Por ejemplo, el valor `EXCEEDS_MAX_FACES` significa que un rostro no se ha indexado porque ya se ha detectado el número de rostros especificado por `MaxFaces`. Para obtener más información, consulte [Administración de rostros en una colección](managing-face-collections.md#collections-index-faces). **Para agregar rostros a una colección (SDK)** 1. Si aún no lo ha hecho: 1. Cree o actualice un usuario con los permisos `AmazonRekognitionFullAccess` y `AmazonS3ReadOnlyAccess`. 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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Suba una imagen (que contenga uno o varios rostros) en su bucket de Amazon S3. Para ver las instrucciones, consulte [Carga de objetos en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Consulte los siguientes ejemplos para llamar a la operación `IndexFaces`. ------ #### [ Java ] Este ejemplo muestra los ID de rostro para los rostros añadidos a la colección. Cambie el valor de `collectionId` por el nombre de la colección a la que desea agregar un rostro. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 2. El parámetro `.withMaxFaces(1)` reduce el número de rostros indexados a 1. Elimínelo o cambie su valor según sus necesidades. ``` //Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. //PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.) package aws.example.rekognition.image; import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.FaceRecord; import com.amazonaws.services.rekognition.model.Image; import com.amazonaws.services.rekognition.model.IndexFacesRequest; import com.amazonaws.services.rekognition.model.IndexFacesResult; import com.amazonaws.services.rekognition.model.QualityFilter; import com.amazonaws.services.rekognition.model.S3Object; import com.amazonaws.services.rekognition.model.UnindexedFace; import java.util.List; public class AddFacesToCollection { public static final String collectionId = "MyCollection"; public static final String bucket = "bucket"; public static final String photo = "input.jpg"; public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); Image image = new Image() .withS3Object(new S3Object() .withBucket(bucket) .withName(photo)); IndexFacesRequest indexFacesRequest = new IndexFacesRequest() .withImage(image) .withQualityFilter(QualityFilter.AUTO) .withMaxFaces(1) .withCollectionId(collectionId) .withExternalImageId(photo) .withDetectionAttributes("DEFAULT"); IndexFacesResult indexFacesResult = rekognitionClient.indexFaces(indexFacesRequest); System.out.println("Results for " + photo); System.out.println("Faces indexed:"); List faceRecords = indexFacesResult.getFaceRecords(); for (FaceRecord faceRecord : faceRecords) { System.out.println(" Face ID: " + faceRecord.getFace().getFaceId()); System.out.println(" Location:" + faceRecord.getFaceDetail().getBoundingBox().toString()); } List unindexedFaces = indexFacesResult.getUnindexedFaces(); System.out.println("Faces not indexed:"); for (UnindexedFace unindexedFace : unindexedFaces) { System.out.println(" Location:" + unindexedFace.getFaceDetail().getBoundingBox().toString()); System.out.println(" Reasons:"); for (String reason : unindexedFace.getReasons()) { System.out.println(" " + reason); } } } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/AddFacesToCollection.java). ``` //snippet-start:[rekognition.java2.add_faces_collection.import] import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider; import software.amazon.awssdk.core.SdkBytes; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.rekognition.RekognitionClient; import software.amazon.awssdk.services.rekognition.model.IndexFacesResponse; import software.amazon.awssdk.services.rekognition.model.IndexFacesRequest; import software.amazon.awssdk.services.rekognition.model.Image; import software.amazon.awssdk.services.rekognition.model.QualityFilter; import software.amazon.awssdk.services.rekognition.model.Attribute; import software.amazon.awssdk.services.rekognition.model.FaceRecord; import software.amazon.awssdk.services.rekognition.model.UnindexedFace; import software.amazon.awssdk.services.rekognition.model.RekognitionException; import software.amazon.awssdk.services.rekognition.model.Reason; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; import java.util.List; //snippet-end:[rekognition.java2.add_faces_collection.import] /** * Before running this Java V2 code example, set up your development environment, including your credentials. * * For more information, see the following documentation topic: * * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html */ public class AddFacesToCollection { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " collectionName - The name of the collection.\n" + " sourceImage - The path to the image (for example, C:\\AWS\\pic1.png). \n\n"; if (args.length != 2) { System.out.println(usage); System.exit(1); } String collectionId = args[0]; String sourceImage = args[1]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); addToCollection(rekClient, collectionId, sourceImage); rekClient.close(); } // snippet-start:[rekognition.java2.add_faces_collection.main] public static void addToCollection(RekognitionClient rekClient, String collectionId, String sourceImage) { try { InputStream sourceStream = new FileInputStream(sourceImage); SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream); Image souImage = Image.builder() .bytes(sourceBytes) .build(); IndexFacesRequest facesRequest = IndexFacesRequest.builder() .collectionId(collectionId) .image(souImage) .maxFaces(1) .qualityFilter(QualityFilter.AUTO) .detectionAttributes(Attribute.DEFAULT) .build(); IndexFacesResponse facesResponse = rekClient.indexFaces(facesRequest); System.out.println("Results for the image"); System.out.println("\n Faces indexed:"); List faceRecords = facesResponse.faceRecords(); for (FaceRecord faceRecord : faceRecords) { System.out.println(" Face ID: " + faceRecord.face().faceId()); System.out.println(" Location:" + faceRecord.faceDetail().boundingBox().toString()); } List unindexedFaces = facesResponse.unindexedFaces(); System.out.println("Faces not indexed:"); for (UnindexedFace unindexedFace : unindexedFaces) { System.out.println(" Location:" + unindexedFace.faceDetail().boundingBox().toString()); System.out.println(" Reasons:"); for (Reason reason : unindexedFace.reasons()) { System.out.println("Reason: " + reason); } } } catch (RekognitionException | FileNotFoundException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.add_faces_collection.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `index-faces` CLI. Reemplace el valor de `collection-id` por el nombre de la colección donde desea almacenar el rostro. Reemplace los valores `Bucket` y `Name` por el nombre del bucket de Amazon S3 y el nombre de archivo de imagen que utilizó en el paso 2. El parámetro `max-faces` reduce el número de rostros indexados a 1. Elimínelo o cambie su valor según sus necesidades. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition index-faces --image '{"S3Object":{"Bucket":"bucket-name","Name":"file-name"}}' --collection-id "collection-id" \ --max-faces 1 --quality-filter "AUTO" --detection-attributes "ALL" \ --external-image-id "example-image.jpg" --profile profile-name ``` Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \$1) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente: ``` aws rekognition index-faces --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" \ --collection-id "collection-id" --max-faces 1 --quality-filter "AUTO" --detection-attributes "ALL" \ --external-image-id "example-image.jpg" --profile profile-name ``` ------ #### [ Python ] Este ejemplo muestra los ID de rostro para los rostros añadidos a la colección. Cambie el valor de `collectionId` por el nombre de la colección a la que desea agregar un rostro. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 2. El parámetro de entrada `MaxFaces` determina el número de rostros indexados. Elimínelo o cambie su valor según sus necesidades. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. # PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.) import boto3 def add_faces_to_collection(bucket, photo, collection_id): session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') response = client.index_faces(CollectionId=collection_id, Image={'S3Object': {'Bucket': bucket, 'Name': photo}}, ExternalImageId=photo, MaxFaces=1, QualityFilter="AUTO", DetectionAttributes=['ALL']) print('Results for ' + photo) print('Faces indexed:') for faceRecord in response['FaceRecords']: print(' Face ID: ' + faceRecord['Face']['FaceId']) print(' Location: {}'.format(faceRecord['Face']['BoundingBox'])) print('Faces not indexed:') for unindexedFace in response['UnindexedFaces']: print(' Location: {}'.format(unindexedFace['FaceDetail']['BoundingBox'])) print(' Reasons:') for reason in unindexedFace['Reasons']: print(' ' + reason) return len(response['FaceRecords']) def main(): bucket = 'amzn-s3-demo-bucket' collection_id = 'collection-id' photo = 'photo-name' indexed_faces_count = add_faces_to_collection(bucket, photo, collection_id) print("Faces indexed count: " + str(indexed_faces_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo muestra los ID de rostro para los rostros añadidos a la colección. Cambie el valor de `collectionId` por el nombre de la colección a la que desea agregar un rostro. Reemplace los valores de `bucket` y `photo` por los nombre del bucket de Amazon S3 y de la imagen que utilizó en el paso 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 System.Collections.Generic; using Amazon.Rekognition; using Amazon.Rekognition.Model; public class AddFaces { public static void Example() { String collectionId = "MyCollection"; String bucket = "amzn-s3-demo-bucket"; String photo = "input.jpg"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); Image image = new Image() { S3Object = new S3Object() { Bucket = bucket, Name = photo } }; IndexFacesRequest indexFacesRequest = new IndexFacesRequest() { Image = image, CollectionId = collectionId, ExternalImageId = photo, DetectionAttributes = new List(){ "ALL" } }; IndexFacesResponse indexFacesResponse = rekognitionClient.IndexFaces(indexFacesRequest); Console.WriteLine(photo + " added"); foreach (FaceRecord faceRecord in indexFacesResponse.FaceRecords) Console.WriteLine("Face detected: Faceid is " + faceRecord.Face.FaceId); } } ``` ------ ## IndexFaces solicitud de operación La entrada de `IndexFaces` es la imagen que se va a indexar y la colección a la que se añadirá el rostro o los rostros. ``` { "CollectionId": "MyCollection", "Image": { "S3Object": { "Bucket": "bucket", "Name": "input.jpg" } }, "ExternalImageId": "input.jpg", "DetectionAttributes": [ "DEFAULT" ], "MaxFaces": 1, "QualityFilter": "AUTO" } ``` ## IndexFaces respuesta de operación `IndexFaces` devuelve información sobre los rostros que se han detectado en la imagen. Por ejemplo, la siguiente respuesta de JSON incluye los atributos de detección predeterminados para los rostros detectados en la imagen de entrada. El ejemplo también muestra rostros no indexados porque se ha superado el valor del parámetro de entrada `MaxFaces`: la matriz `Reasons` contiene *EXCEEDS\$1MAX\$1FACES*. Si un rostro no se indexa por razones de calidad, `Reasons` contiene valores como *LOW\$1SHARPNESS* o *LOW\$1BRIGHTNESS*. Para obtener más información, consulte [UnindexedFace](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UnindexedFace.html). ``` { "FaceModelVersion": "3.0", "FaceRecords": [ { "Face": { "BoundingBox": { "Height": 0.3247932195663452, "Left": 0.5055555701255798, "Top": 0.2743072211742401, "Width": 0.21444444358348846 }, "Confidence": 99.99998474121094, "ExternalImageId": "input.jpg", "FaceId": "b86e2392-9da1-459b-af68-49118dc16f87", "ImageId": "09f43d92-02b6-5cea-8fbd-9f187db2050d" }, "FaceDetail": { "BoundingBox": { "Height": 0.3247932195663452, "Left": 0.5055555701255798, "Top": 0.2743072211742401, "Width": 0.21444444358348846 }, "Confidence": 99.99998474121094, "Landmarks": [ { "Type": "eyeLeft", "X": 0.5751981735229492, "Y": 0.4010535478591919 }, { "Type": "eyeRight", "X": 0.6511467099189758, "Y": 0.4017036259174347 }, { "Type": "nose", "X": 0.6314528584480286, "Y": 0.4710812568664551 }, { "Type": "mouthLeft", "X": 0.5879443287849426, "Y": 0.5171778798103333 }, { "Type": "mouthRight", "X": 0.6444502472877502, "Y": 0.5164633989334106 } ], "Pose": { "Pitch": -10.313642501831055, "Roll": -1.0316886901855469, "Yaw": 18.079818725585938 }, "Quality": { "Brightness": 71.2919921875, "Sharpness": 78.74752044677734 } } } ], "OrientationCorrection": "", "UnindexedFaces": [ { "FaceDetail": { "BoundingBox": { "Height": 0.1329464465379715, "Left": 0.5611110925674438, "Top": 0.6832437515258789, "Width": 0.08777777850627899 }, "Confidence": 92.37225341796875, "Landmarks": [ { "Type": "eyeLeft", "X": 0.5796897411346436, "Y": 0.7452847957611084 }, { "Type": "eyeRight", "X": 0.6078574657440186, "Y": 0.742687463760376 }, { "Type": "nose", "X": 0.597953200340271, "Y": 0.7620673179626465 }, { "Type": "mouthLeft", "X": 0.5884202122688293, "Y": 0.7920381426811218 }, { "Type": "mouthRight", "X": 0.60627681016922, "Y": 0.7919750809669495 } ], "Pose": { "Pitch": 15.658954620361328, "Roll": -4.583454608917236, "Yaw": 10.558992385864258 }, "Quality": { "Brightness": 42.54612350463867, "Sharpness": 86.93206024169922 } }, "Reasons": [ "EXCEEDS_MAX_FACES" ] } ] } ``` Para obtener toda la información facial, especifique "ALL" para el parámetro de solicitud `DetectionAttributes`. Por ejemplo, en la siguiente respuesta de ejemplo, tenga en cuenta la información adicional del elemento `faceDetail`, que no se almacena de forma persistente en el servidor: + 25 referencias faciales (en comparación con las cinco del ejemplo anterior) + Diez atributos faciales (gafas, barba, oclusión, dirección de la mirada, etc.) + Emociones (véase el elemento `emotion`) El elemento `face` proporciona metadatos que se almacenan de forma persistente en el servidor. `FaceModelVersion` es la versión del modelo de rostros asociado a la colección. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). `OrientationCorrection` es la orientación estimada de la imagen. No se devolverá información de corrección de la orientación si utiliza una versión del modelo de detección facial posterior a la versión 3. Para obtener más información, consulte [Obtención de coordenadas de cuadro delimitador y orientación de imagen](images-orientation.md). El siguiente ejemplo de respuesta muestra el JSON devuelto al especificar ["ALL"]: ``` { "FaceModelVersion": "3.0", "FaceRecords": [ { "Face": { "BoundingBox": { "Height": 0.06333333253860474, "Left": 0.17185185849666595, "Top": 0.7366666793823242, "Width": 0.11061728745698929 }, "Confidence": 99.99999237060547, "ExternalImageId": "input.jpg", "FaceId": "578e2e1b-d0b0-493c-aa39-ba476a421a34", "ImageId": "9ba38e68-35b6-5509-9d2e-fcffa75d1653" }, "FaceDetail": { "AgeRange": { "High": 25, "Low": 15 }, "Beard": { "Confidence": 99.98077392578125, "Value": false }, "BoundingBox": { "Height": 0.06333333253860474, "Left": 0.17185185849666595, "Top": 0.7366666793823242, "Width": 0.11061728745698929 }, "Confidence": 99.99999237060547, "Emotions": [ { "Confidence": 95.40877532958984, "Type": "HAPPY" }, { "Confidence": 6.6088080406188965, "Type": "CALM" }, { "Confidence": 0.7385611534118652, "Type": "SAD" } ], "EyeDirection": { "yaw": 16.299732, "pitch": -6.407457, "confidence": 99.968704 } "Eyeglasses": { "Confidence": 99.96795654296875, "Value": false }, "EyesOpen": { "Confidence": 64.0671157836914, "Value": true }, "Gender": { "Confidence": 100, "Value": "Female" }, "Landmarks": [ { "Type": "eyeLeft", "X": 0.21361233294010162, "Y": 0.757106363773346 }, { "Type": "eyeRight", "X": 0.2518567442893982, "Y": 0.7599404454231262 }, { "Type": "nose", "X": 0.2262365221977234, "Y": 0.7711842060089111 }, { "Type": "mouthLeft", "X": 0.2050037682056427, "Y": 0.7801263332366943 }, { "Type": "mouthRight", "X": 0.2430567592382431, "Y": 0.7836716771125793 }, { "Type": "leftPupil", "X": 0.2161938101053238, "Y": 0.756662905216217 }, { "Type": "rightPupil", "X": 0.2523181438446045, "Y": 0.7603650689125061 }, { "Type": "leftEyeBrowLeft", "X": 0.20066319406032562, "Y": 0.7501518130302429 }, { "Type": "leftEyeBrowUp", "X": 0.2130996286869049, "Y": 0.7480520606040955 }, { "Type": "leftEyeBrowRight", "X": 0.22584207355976105, "Y": 0.7504606246948242 }, { "Type": "rightEyeBrowLeft", "X": 0.24509544670581818, "Y": 0.7526801824569702 }, { "Type": "rightEyeBrowUp", "X": 0.2582615911960602, "Y": 0.7516844868659973 }, { "Type": "rightEyeBrowRight", "X": 0.26881539821624756, "Y": 0.7554477453231812 }, { "Type": "leftEyeLeft", "X": 0.20624476671218872, "Y": 0.7568746209144592 }, { "Type": "leftEyeRight", "X": 0.22105035185813904, "Y": 0.7582521438598633 }, { "Type": "leftEyeUp", "X": 0.21401576697826385, "Y": 0.7553104162216187 }, { "Type": "leftEyeDown", "X": 0.21317370235919952, "Y": 0.7584449648857117 }, { "Type": "rightEyeLeft", "X": 0.24393919110298157, "Y": 0.7600628137588501 }, { "Type": "rightEyeRight", "X": 0.2598416209220886, "Y": 0.7605880498886108 }, { "Type": "rightEyeUp", "X": 0.2519053518772125, "Y": 0.7582084536552429 }, { "Type": "rightEyeDown", "X": 0.25177454948425293, "Y": 0.7612871527671814 }, { "Type": "noseLeft", "X": 0.2185886949300766, "Y": 0.774715781211853 }, { "Type": "noseRight", "X": 0.23328955471515656, "Y": 0.7759330868721008 }, { "Type": "mouthUp", "X": 0.22446128726005554, "Y": 0.7805567383766174 }, { "Type": "mouthDown", "X": 0.22087252140045166, "Y": 0.7891407608985901 } ], "MouthOpen": { "Confidence": 95.87068939208984, "Value": false }, "Mustache": { "Confidence": 99.9828109741211, "Value": false }, "Pose": { "Pitch": -0.9409101605415344, "Roll": 7.233824253082275, "Yaw": -2.3602254390716553 }, "Quality": { "Brightness": 32.01998519897461, "Sharpness": 93.67259216308594 }, "Smile": { "Confidence": 86.7142105102539, "Value": true }, "Sunglasses": { "Confidence": 97.38925170898438, "Value": false } } } ], "OrientationCorrection": "ROTATE_0" "UnindexedFaces": [] } ``` # Enumerar rostros y usuarios asociados en una colección Puede utilizar la [ListFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListFaces.html)operación para enumerar las caras y sus usuarios asociados en una colección. Para obtener más información, consulte [Administración de rostros en una colección](managing-face-collections.md#collections-index-faces). **Para mostrar una lista de los rostros de una colección (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `ListFaces`. ------ #### [ Java ] Este ejemplo muestra una lista de los rostros de una colección. Cambie el valor de `collectionId` por el de la colección deseada. ``` //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.Face; import com.amazonaws.services.rekognition.model.ListFacesRequest; import com.amazonaws.services.rekognition.model.ListFacesResult; import java.util.List; import com.fasterxml.jackson.databind.ObjectMapper; public class ListFacesInCollection { public static final String collectionId = "MyCollection"; public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); ObjectMapper objectMapper = new ObjectMapper(); ListFacesResult listFacesResult = null; System.out.println("Faces in collection " + collectionId); String paginationToken = null; do { if (listFacesResult != null) { paginationToken = listFacesResult.getNextToken(); } ListFacesRequest listFacesRequest = new ListFacesRequest() .withCollectionId(collectionId) .withMaxResults(1) .withNextToken(paginationToken); listFacesResult = rekognitionClient.listFaces(listFacesRequest); List < Face > faces = listFacesResult.getFaces(); for (Face face: faces) { System.out.println(objectMapper.writerWithDefaultPrettyPrinter() .writeValueAsString(face)); } } while (listFacesResult != null && listFacesResult.getNextToken() != null); } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/ListFacesInCollection.java). ``` // snippet-start:[rekognition.java2.list_faces_collection.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.Face; import software.amazon.awssdk.services.rekognition.model.ListFacesRequest; import software.amazon.awssdk.services.rekognition.model.ListFacesResponse; import software.amazon.awssdk.services.rekognition.model.RekognitionException; import java.util.List; // snippet-end:[rekognition.java2.list_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 ListFacesInCollection { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " collectionId - The name of the collection. \n\n"; if (args.length < 1) { System.out.println(usage); System.exit(1); } String collectionId = args[0]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); System.out.println("Faces in collection " + collectionId); listFacesCollection(rekClient, collectionId) ; rekClient.close(); } // snippet-start:[rekognition.java2.list_faces_collection.main] public static void listFacesCollection(RekognitionClient rekClient, String collectionId ) { try { ListFacesRequest facesRequest = ListFacesRequest.builder() .collectionId(collectionId) .maxResults(10) .build(); ListFacesResponse facesResponse = rekClient.listFaces(facesRequest); List faces = facesResponse.faces(); for (Face face: faces) { System.out.println("Confidence level there is a face: "+face.confidence()); System.out.println("The face Id value is "+face.faceId()); } } catch (RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.list_faces_collection.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `list-faces` CLI. Reemplace el valor de `collection-id` por el nombre de la colección que desea enumerar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition list-faces --collection-id "collection-id" --profile profile-name ``` ------ #### [ Python ] Este ejemplo muestra una lista de los rostros de una colección. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 list_faces_in_collection(collection_id): maxResults = 2 faces_count = 0 tokens = True session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') response = client.list_faces(CollectionId=collection_id, MaxResults=maxResults) print('Faces in collection ' + collection_id) while tokens: faces = response['Faces'] for face in faces: print(face) faces_count += 1 if 'NextToken' in response: nextToken = response['NextToken'] response = client.list_faces(CollectionId=collection_id, NextToken=nextToken, MaxResults=maxResults) else: tokens = False return faces_count def main(): collection_id = 'collection-id' faces_count = list_faces_in_collection(collection_id) print("faces count: " + str(faces_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo muestra una lista de los rostros de una colección. Cambie el valor de `collectionId` por el de la colección deseada. ``` //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 ListFaces { public static void Example() { String collectionId = "MyCollection"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); ListFacesResponse listFacesResponse = null; Console.WriteLine("Faces in collection " + collectionId); String paginationToken = null; do { if (listFacesResponse != null) paginationToken = listFacesResponse.NextToken; ListFacesRequest listFacesRequest = new ListFacesRequest() { CollectionId = collectionId, MaxResults = 1, NextToken = paginationToken }; listFacesResponse = rekognitionClient.ListFaces(listFacesRequest); foreach(Face face in listFacesResponse.Faces) Console.WriteLine(face.FaceId); } while (listFacesResponse != null && !String.IsNullOrEmpty(listFacesResponse.NextToken)); } } ``` ------ ## ListFaces solicitud de operación La entrada `ListFaces` es el identificador de la colección para la que quieres enumerar las caras. `MaxResults`es el número máximo de caras que se pueden devolver. ListFaces también incluye una lista de rostros con los IDs que filtrar los resultados y un seudónimo que se proporciona para mostrar solo los rostros asociados al usuario en cuestión. ``` { "CollectionId": "MyCollection", "MaxResults": 1 } ``` Si la respuesta tiene más rostros que los que requiere `MaxResults`, se devuelve un token que puede utilizar para obtener el siguiente conjunto de resultados, en una llamada posterior a `ListFaces`. Por ejemplo: ``` { "CollectionId": "MyCollection", "NextToken": "sm+5ythT3aeEVIR4WA....", "MaxResults": 1 } ``` ## ListFaces respuesta de operación La respuesta de `ListFaces` es información acerca de los metadatos de los rostros almacenados en la colección especificada. + **FaceModelVersion**— La versión del modelo de rostro asociada a la colección. Para obtener más información, consulte [Descripción del control de versiones de los modelos](face-detection-model.md). + **Faces**: información sobre los rostros de la colección. Esto incluye información acerca de [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html), la confianza, los identificadores de imágenes y el ID de rostro. Para obtener más información, consulte [Face](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Face.html). + **NextToken**— El token que se utiliza para obtener el siguiente conjunto de resultados. ``` { "FaceModelVersion": "6.0", "Faces": [ { "Confidence": 99.76940155029297, "IndexFacesModelVersion": "6.0", "UserId": "demoUser2", "ImageId": "56a0ca74-1c83-39dd-b363-051a64168a65", "BoundingBox": { "Width": 0.03177810087800026, "Top": 0.36568498611450195, "Left": 0.3453829884529114, "Height": 0.056759100407361984 }, "FaceId": "c92265d4-5f9c-43af-a58e-12be0ce02bc3" }, { "BoundingBox": { "Width": 0.03254450112581253, "Top": 0.6080359816551208, "Left": 0.5160620212554932, "Height": 0.06347999721765518 }, "IndexFacesModelVersion": "6.0", "FaceId": "851cb847-dccc-4fea-9309-9f4805967855", "Confidence": 99.94369506835938, "ImageId": "a8aed589-ceec-35f7-9c04-82e0b546b024" }, { "BoundingBox": { "Width": 0.03094629943370819, "Top": 0.4218429923057556, "Left": 0.6513839960098267, "Height": 0.05266290158033371 }, "IndexFacesModelVersion": "6.0", "FaceId": "c0eb3b65-24a0-41e1-b23a-1908b1aaeac1", "Confidence": 99.82969665527344, "ImageId": "56a0ca74-1c83-39dd-b363-051a64168a65" } ] } ``` # Eliminación de rostros de una colección Puede utilizar la operación [DeleteFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteFaces.html) para eliminar rostros de una colección. Para obtener más información, consulte [Administración de rostros en una colección](managing-face-collections.md#collections-index-faces). **Eliminación de los rostros de una colección** 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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `DeleteFaces`. ------ #### [ Java ] En este ejemplo se elimina un único rostro de una colección. Cambie el valor de `collectionId` por el nombre de la colección que contiene el rostro que desea eliminar. Cambie el valor de `faces` por el ID del rostro que desea eliminar. Para eliminar varias caras, añada la cara IDs a la `faces` matriz. ``` //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.DeleteFacesRequest; import com.amazonaws.services.rekognition.model.DeleteFacesResult; import java.util.List; public class DeleteFacesFromCollection { public static final String collectionId = "MyCollection"; public static final String faces[] = {"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}; public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); DeleteFacesRequest deleteFacesRequest = new DeleteFacesRequest() .withCollectionId(collectionId) .withFaceIds(faces); DeleteFacesResult deleteFacesResult=rekognitionClient.deleteFaces(deleteFacesRequest); List < String > faceRecords = deleteFacesResult.getDeletedFaces(); System.out.println(Integer.toString(faceRecords.size()) + " face(s) deleted:"); for (String face: faceRecords) { System.out.println("FaceID: " + face); } } } ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DeleteFacesFromCollection.java). ``` 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.DeleteFacesRequest; import software.amazon.awssdk.services.rekognition.model.RekognitionException; // snippet-end:[rekognition.java2.delete_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 DeleteFacesFromCollection { public static void main(String[] args) { final String usage = "\n" + "Usage: " + " \n\n" + "Where:\n" + " collectionId - The id of the collection from which faces are deleted. \n\n" + " faceId - The id of the face to delete. \n\n"; if (args.length != 1) { System.out.println(usage); System.exit(1); } String collectionId = args[0]; String faceId = args[1]; Region region = Region.US_EAST_1; RekognitionClient rekClient = RekognitionClient.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("profile-name")) .build(); System.out.println("Deleting collection: " + collectionId); deleteFacesCollection(rekClient, collectionId, faceId); rekClient.close(); } // snippet-start:[rekognition.java2.delete_faces_collection.main] public static void deleteFacesCollection(RekognitionClient rekClient, String collectionId, String faceId) { try { DeleteFacesRequest deleteFacesRequest = DeleteFacesRequest.builder() .collectionId(collectionId) .faceIds(faceId) .build(); rekClient.deleteFaces(deleteFacesRequest); System.out.println("The face was deleted from the collection."); } catch(RekognitionException e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.delete_faces_collection.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `delete-faces` CLI. Reemplace el valor de `collection-id` por el nombre de la colección que contiene el rostro que desea eliminar. Sustituya el valor de `face-ids` por una matriz de caras IDs que desee eliminar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition delete-faces --collection-id "collection-id" --face-ids "faceid" --profile profile-name ``` ------ #### [ Python ] En este ejemplo se elimina un único rostro de una colección. Cambie el valor de `collectionId` por el nombre de la colección que contiene el rostro que desea eliminar. Cambie el valor de `faces` por el ID del rostro que desea eliminar. Para eliminar varias caras, añada la cara IDs a la `faces` matriz. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 delete_faces_from_collection(collection_id, faces): session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') response = client.delete_faces(CollectionId=collection_id, FaceIds=faces) print(str(len(response['DeletedFaces'])) + ' faces deleted:') for faceId in response['DeletedFaces']: print(faceId) return len(response['DeletedFaces']) def main(): collection_id = 'collection-id' faces = [] faces.append("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") faces_count = delete_faces_from_collection(collection_id, faces) print("deleted faces count: " + str(faces_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] En este ejemplo se elimina un único rostro de una colección. Cambie el valor de `collectionId` por el nombre de la colección que contiene el rostro que desea eliminar. Cambie el valor de `faces` por el ID del rostro que desea eliminar. Para eliminar varias caras, añada la cara IDs a la `faces` lista. ``` //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 DeleteFaces { public static void Example() { String collectionId = "MyCollection"; List faces = new List() { "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" }; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); DeleteFacesRequest deleteFacesRequest = new DeleteFacesRequest() { CollectionId = collectionId, FaceIds = faces }; DeleteFacesResponse deleteFacesResponse = rekognitionClient.DeleteFaces(deleteFacesRequest); foreach (String face in deleteFacesResponse.DeletedFaces) Console.WriteLine("FaceID: " + face); } } ``` ------ ## DeleteFaces solicitud de operación La entrada `DeleteFaces` es el identificador de la colección que contiene las caras y una matriz de caras IDs para las caras que se van a eliminar. ``` { "CollectionId": "MyCollection", "FaceIds": [ "daf29cac-f910-41e9-851f-6eeb0e08f973" ] } ``` ## DeleteFaces respuesta de operación La `DeleteFaces` respuesta contiene una matriz de caras IDs para las caras que se eliminaron. ``` { "DeletedFaces": [ "daf29cac-f910-41e9-851f-6eeb0e08f973" ] } ``` Si la cara IDs proporcionada en la entrada está asociada actualmente a un usuario, se devolverá por motivos válidos. UnsuccessfulFaceDeletions ``` { "DeletedFaces": [ "daf29cac-f910-41e9-851f-6eeb0e08f973" ], "UnsuccessfulFaceDeletions" : [ { "FaceId" : "0b683aed-a0f1-48b2-9b5e-139e9cc2a757", "UserId" : "demoUser1", "Reason" : ["ASSOCIATED_TO_AN_EXISTING_USER"] } ] } ``` # Creación de un usuario Puedes usar la [CreateUser](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateUser.html)operación para crear un nuevo usuario en una colección usando un seudónimo único que proporciones. A continuación, puede asociar varios rostros al usuario recién creado. **Para crear un usuario (SDK)** 1. Si aún no lo ha hecho: 1. Cree o actualice una cuenta de usuario de IAM con permisos de `AmazonRekognitionFullAccess`. 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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `CreateUser`. ------ #### [ Java ] En este ejemplo de código Java se crea un usuario. ``` import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.CreateUserRequest; import com.amazonaws.services.rekognition.model.CreateUserResult; public class CreateUser { public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); //Replace collectionId and userId with the name of the user that you want to create in that target collection. String collectionId = "MyCollection"; String userId = "demoUser"; System.out.println("Creating new user: " + userId); CreateUserRequest request = new CreateUserRequest() .withCollectionId(collectionId) .withUserId(userId); rekognitionClient.createUser(request); } } ``` ------ #### [ AWS CLI ] Este AWS CLI comando crea un usuario mediante la operación `create-user` CLI. ``` aws rekognition create-user --user-id user-id --collection-id collection-name --region region-name --client-request-token request-token ``` ------ #### [ Python ] Este ejemplo de código de Python crea un usuario. ``` # 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 logger = logging.getLogger(__name__) session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') def create_user(collection_id, user_id): """ Creates a new User within a collection specified by CollectionId. Takes UserId as a parameter, which is a user provided ID which should be unique within the collection. :param collection_id: The ID of the collection where the indexed faces will be stored at. :param user_id: ID for the UserID to be created. This ID needs to be unique within the collection. :return: The indexFaces response """ try: logger.info(f'Creating user: {collection_id}, {user_id}') client.create_user( CollectionId=collection_id, UserId=user_id ) except ClientError: logger.exception(f'Failed to create user with given user id: {user_id}') raise def main(): collection_id = "collection-id" user_id = "user-id" create_user(collection_id, user_id) if __name__ == "__main__": main() ``` ------ #### [ Go ] Este ejemplo de código de Go usa el AWS Go SDK V2 y crea un usuario. ``` package main import ( "context" "fmt" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/rekognition" ) func main() { // Load the AWS SDK configuration cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2")) if err != nil { log.Fatalf("Failed to load configuration: %v", err) } // Create a Rekognition client client := rekognition.NewFromConfig(cfg) // Set up the input parameters input := &rekognition.CreateUserInput{ CollectionId: aws.String("my-new-collection"), // Replace with your collection ID UserId: aws.String("user12345678910"), // Replace with desired user ID } // Call the CreateUser operation result, err := client.CreateUser(context.TODO(), input) if err != nil { log.Fatalf("Failed to create user: %v", err) } // Print out the results fmt.Printf("User created successfully:\n") } ``` ------ # Eliminar un usuario Puede utilizar la [DeleteUser](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteUser.html)operación para eliminar un usuario de una colección, en función del UserID proporcionado. Tenga en cuenta que todos los rostros asociados al UserID se disocian del UserID antes de que se elimine el UserID especificado. **Para eliminar un usuario (SDK)** 1. Si aún no lo ha hecho: 1. Cree o actualice una cuenta de usuario de IAM con permisos de `AmazonRekognitionFullAccess`. 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 el AWS CLI y el. AWS SDKs Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `DeleteUser`. ------ #### [ Java ] En este ejemplo de código de Java se elimina un usuario. ``` import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.DeleteUserRequest; import com.amazonaws.services.rekognition.model.DeleteUserResult; public class DeleteUser { public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); //Replace collectionId and userId with the name of the user that you want to delete from that target collection. String collectionId = "MyCollection"; String userId = "demoUser"; System.out.println("Deleting existing user: " + userId); DeleteUserRequest request = new DeleteUserRequest() .withCollectionId(collectionId) .withUserId(userId); rekognitionClient.deleteUser(request); } } ``` ------ #### [ AWS CLI ] Este AWS CLI comando elimina un usuario mediante la operación `create-user` CLI. ``` aws rekognition delete-user --collection-id MyCollection --user-id user-id --collection-id collection-name --region region-name ``` ------ #### [ Python ] En este ejemplo de código de Python se elimina un usuario. ``` # 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 logger = logging.getLogger(__name__) session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') def delete_user(collection_id, user_id): """ Delete the user from the given collection :param collection_id: The ID of the collection where user is stored. :param user_id: The ID of the user in the collection to delete. """ logger.info(f'Deleting user: {collection_id}, {user_id}') try: client.delete_user( CollectionId=collection_id, UserId=user_id ) except ClientError: logger.exception(f'Failed to delete user with given user id: {user_id}') raise def main(): collection_id = "collection-id" user_id = "user-id" delete_user(collection_id, user_id) if __name__ == "__main__": main() ``` ------ # Asociar caras a un usuario Puede utilizar la [AssociateFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_AssociatingFaces.html)operación para asociar varias caras individuales a un solo usuario. Para asociar un rostro a un usuario, primero debe crear una colección y un usuario. Tenga en cuenta que los vectores faciales deben residir en la misma colección en la que reside el vector del usuario. **Para asociar rostros (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `AssociateFaces`. ------ #### [ Java ] En este ejemplo de código Java se asocia un rostro a un usuario. ``` import java.util.Arrays; import java.util.List; import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.AssociateFacesRequest; import com.amazonaws.services.rekognition.model.AssociateFacesResult; public class AssociateFaces { public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); /* Replace the below configurations to allow you successfully run the example @collectionId: The collection where user and faces are stored @userId: The user which faces will get associated to @faceIds: The list of face IDs that will get associated to the given user @userMatchThreshold: Minimum User match confidence required for the face to be associated with a User that has at least one faceID already associated */ String collectionId = "MyCollection"; String userId = "demoUser"; String faceId1 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; String faceId2 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; List faceIds = Arrays.asList(faceid1,faceid2); float userMatchThreshold = 0f; System.out.println("Associating faces to the existing user: " + userId); AssociateFacesRequest request = new AssociateFacesRequest() .withCollectionId(collectionId) .withUserId(userId) .withFaceIds(faceIds) .withUserMatchThreshold(userMatchThreshold); AssociateFacesResult result = rekognitionClient.associateFaces(request); System.out.println("Successful face associations: " + result.getAssociatedFaces().size()); System.out.println("Unsuccessful face associations: " + result.getUnsuccessfulFaceAssociations().size()); } } ``` ------ #### [ AWS CLI ] Este AWS CLI comando asocia un rostro a un usuario mediante la operación `associate-faces` CLI. ``` aws rekognition associate-faces --user-id user-id --face-ids face-id-1 face-id-2 --collection-id collection-name --region region-name ``` ------ #### [ Python ] En este ejemplo de código de Python se asocia un rostro a un usuario. ``` from botocore.exceptions import ClientError import boto3 import logging logger = logging.getLogger(__name__) session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') def associate_faces(collection_id, user_id, face_ids): """ Associate stored faces within collection to the given user :param collection_id: The ID of the collection where user and faces are stored. :param user_id: The ID of the user that we want to associate faces to :param face_ids: The list of face IDs to be associated to the given user :return: response of AssociateFaces API """ logger.info(f'Associating faces to user: {user_id}, {face_ids}') try: response = client.associate_faces( CollectionId=collection_id, UserId=user_id, FaceIds=face_ids ) print(f'- associated {len(response["AssociatedFaces"])} faces') except ClientError: logger.exception("Failed to associate faces to the given user") raise else: print(response) return response def main(): face_ids = ["faceId1", "faceId2"] collection_id = "collection-id" user_id = "user-id" associate_faces(collection_id, user_id, face_ids) if __name__ == "__main__": main() ``` ------ ## AssociateFaces respuesta de operación La respuesta para `AssociateFaces` incluye el `UserStatus`, que es el estado de la solicitud de disociación, así como una lista de los `FaceIds` que se van a asociar. También se devuelve una lista de `UnsuccessfulFaceAssociations`. Después de enviar una solicitud a `AssociateFaces`, la operación puede tardar aproximadamente un minuto en completarse. Por este motivo, UserStatus se devuelve el, que puede tener los siguientes valores: + CREADO: indica que el «usuario» se ha creado correctamente y que actualmente no tiene ningún rostro asociado. El «usuario» estará en este estado antes de que se realice una llamada AssociateFaces «» exitosa. + ACTUALIZACIÓN: indica que el «usuario» se está actualizando para reflejar las associated/disassociated caras nuevas y pasará a ESTAR ACTIVO en unos segundos. Los resultados de la búsqueda pueden incluir la palabra «Usuario» en este estado y los clientes pueden optar por ignorarlo de los resultados devueltos. + ACTIVO: indica que el **«usuario**»**** está actualizado para reflejar todas las associated/disassociated caras y se encuentra en un estado en el que se pueden realizar búsquedas. ``` { "UnsuccessfulFaceAssociations": [ { "Reasons": [ "LOW_MATCH_CONFIDENCE" ], "FaceId": "f5817d37-94f6-0000-bfee-1a2b3c4d5e6f", "Confidence": 0.9375374913215637 }, { "Reasons": [ "ASSOCIATED_TO_A_DIFFERENT_IDENTITY" ], "FaceId": "851cb847-dccc-1111-bfee-1a2b3c4d5e6f", "UserId": "demoUser2" } ], "UserStatus": "UPDATING", "AssociatedFaces": [ { "FaceId": "35ebbb41-7f67-2222-bfee-1a2b3c4d5e6f" } ] } ``` # Desasociar rostros de un usuario Puede utilizar esta [DisassociateFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DisassociateFaces.html)operación para eliminar la asociación entre un seudónimo y un identificador facial. **Para desasociar rostros (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `DisassociateFaces`. ------ #### [ Java ] En este ejemplo de Java, se elimina la asociación entre un FaceID y un UserID con la operación `DisassociateFaces`. ``` import java.util.Arrays; import java.util.List; import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.DisassociateFacesRequest; import com.amazonaws.services.rekognition.model.DisassociateFacesResult; public class DisassociateFaces { public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); /* Replace the below configurations to allow you successfully run the example @collectionId: The collection where user and faces are stored @userId: The user which faces will get disassociated from @faceIds: The list of face IDs that will get disassociated from the given user */ String collectionId = "MyCollection"; String userId = "demoUser"; String faceId1 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; String faceId2 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; List faceIds = Arrays.asList(faceid1,faceid2); System.out.println("Disassociating faces from existing user: " + userId); DisassociateFacesRequest request = new DisassociateFacesRequest() .withCollectionId(collectionId) .withUserId(userId) .withFaceIds(faceIds) DisassociateFacesResult result = rekognitionClient.disassociateFaces(request); System.out.println("Successful face disassociations: " + result.getDisassociatedFaces().size()); System.out.println("Unsuccessful face disassociations: " + result.getUnsuccessfulFaceDisassociations().size()); } } ``` ------ #### [ AWS CLI ] Este AWS CLI comando elimina la asociación entre un FaceID y un UserID con la operación. `DisassociateFaces` ``` aws rekognition disassociate-faces --face-ids list-of-face-ids --user-id user-id --collection-id collection-name --region region-name ``` ------ #### [ Python ] En el siguiente ejemplo, se elimina la asociación entre un FaceID y un UserID con la operación `DisassociateFaces`. ``` from botocore.exceptions import ClientError import boto3 import logging logger = logging.getLogger(__name__) session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') def disassociate_faces(collection_id, user_id, face_ids): """ Disassociate stored faces within collection to the given user :param collection_id: The ID of the collection where user and faces are stored. :param user_id: The ID of the user that we want to disassociate faces from :param face_ids: The list of face IDs to be disassociated from the given user :return: response of AssociateFaces API """ logger.info(f'Disssociating faces from user: {user_id}, {face_ids}') try: response = client.disassociate_faces( CollectionId=collection_id, UserId=user_id, FaceIds=face_ids ) print(f'- disassociated {len(response["DisassociatedFaces"])} faces') except ClientError: logger.exception("Failed to disassociate faces from the given user") raise else: print(response) return response def main(): face_ids = ["faceId1", "faceId2"] collection_id = "collection-id" user_id = "user-id" disassociate_faces(collection_id, user_id, face_ids) if __name__ == "__main__": main() ``` ------ ## DisassociateFaces respuesta de operación La respuesta para `DisassociateFaces` incluye el `UserStatus`, que es el estado de la solicitud de disociación, así como una lista de los `FaceIds` que se van a desasociar. También se devuelve una lista de `UnsuccessfulFaceDisassociations`. Tras enviar una solicitud a DisassociateFaces, la operación puede tardar aproximadamente un minuto en completarse. Por este motivo, UserStatus se devuelve el, que puede tener los siguientes valores: + CREADO: indica que el «usuario» se ha creado correctamente y que actualmente no tiene ningún rostro asociado. El «usuario» estará en este estado antes de que se realice una llamada AssociateFaces «» exitosa. + ACTUALIZACIÓN: indica que el «usuario» se está actualizando para reflejar las associated/disassociated caras nuevas y pasará a ESTAR ACTIVO en unos segundos. Los resultados de la búsqueda pueden incluir la palabra «Usuario» en este estado y los clientes pueden optar por ignorarlo de los resultados devueltos. + ACTIVO: indica que el **«usuario**»**** está actualizado para reflejar todas las associated/disassociated caras y se encuentra en un estado en el que se pueden realizar búsquedas. ``` { "UserStatus": "UPDATING", "DisassociatedFaces": [ { "FaceId": "c92265d4-5f9c-43af-a58e-12be0ce02bc3" } ], "UnsuccessfulFaceDisassociations": [ { "Reasons": [ "ASSOCIATED_TO_A_DIFFERENT_IDENTITY" ], "FaceId": "f5817d37-94f6-4335-bfee-6cf79a3d806e", "UserId": "demoUser1" } ] } ``` # Listado de usuarios en una colección Puede utilizar la [ListUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListUsers.html)operación para enumerar UserIds y el. UserStatus Para ver las caras IDs asociadas a un UserID, utilice la operación. [ListFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListFaces.html) **Para enumerar los usuarios (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 el AWS CLI y el. AWS SDKs Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `ListUsers`. ------ #### [ Java ] En este ejemplo de Java, se enumeran los usuarios de una colección mediante la operación `ListUsers`. ``` import java.util.List; import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.ListUsersRequest; import com.amazonaws.services.rekognition.model.ListUsersResult; import com.amazonaws.services.rekognition.model.User; public class ListUsers { public static void main(String[] args) throws Exception { AmazonRekognition amazonRekognition = AmazonRekognitionClientBuilder.defaultClient(); System.out.println("Listing users"); int limit = 10; ListUsersResult listUsersResult = null; String paginationToken = null; do { if (listUsersResult != null) { paginationToken = listUsersResult.getNextToken(); } ListUsersRequest request = new ListUsersRequest() .withCollectionId(collectionId) .withMaxResults(limit) .withNextToken(paginationToken); listUsersResult = amazonRekognition.listUsers(request); List users = listUsersResult.getUsers(); for (User currentUser: users) { System.out.println(currentUser.getUserId() + " : " + currentUser.getUserStatus()); } } while (listUsersResult.getNextToken() != null); } } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra los usuarios de una colección con la `ListUsers` operación. ``` aws rekognition list-users --collection-id collection-id --max-results number-of-max-results ``` ------ #### [ Python ] En el siguiente ejemplo, se muestran los usuarios de una colección con la operación `ListUsers`. ``` # 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 from pprint import pprint logger = logging.getLogger(__name__) session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') def list_users(collection_id): """ List all users from the given collection :param collection_id: The ID of the collection where user is stored. :return: response that contains list of Users found within given collection """ logger.info(f'Listing the users in collection: {collection_id}') try: response = client.list_users( CollectionId=collection_id ) pprint(response["Users"]) except ClientError: logger.exception(f'Failed to list all user from given collection: {collection_id}') raise else: return response def main(): collection_id = "collection-id" list_users(collection_id) if __name__ == "__main__": main() ``` ------ ## ListUsers respuesta de operación La respuesta a una solicitud ListUsers incluye una lista de los elementos `Users` de la colección junto con la `UsedId` dirección y `UserStatus` del usuario. ``` { "NextToken": "B1asJT3bAb/ttuGgPFV8BZoBZyGQzlUHXbuTNLh48a6enU7kXKw43hpOwizW7LOk/Gk7Em09lznoq6+FcDCcSq2olrn7A98BLkt5keu+ZRVRUTyrXtT6J7Hmp+ieQ2an6Zu0qzPfcdPeaJ9eAxG2d0WNrzJgi5hvmjoiSTTfKX3MQz1sduWQkvAAs4hZfhZoKFahFlqWofshCXa/FHAAY3PL1PjxXbkNeSSMq8V7i1MlKCdrPVykCv9MokpPt7jtNvKPEZGUhxgBTFMxNWLEcFnzAiCWDg91dFy/LalshPjXA9UVc5Gx9vIJNQ/eO3cQRghAkCT3FOAiXsLAnA015ODTomZpWWVpqB21wKpI3LYmfAVFrDPGzpbTVlRmLsJm41bkmnBBBw9+DHz1Jn7zW+qc5Fs3yaHu0f51Xg==", "Users": [ { "UserId": "demoUser4", "UserStatus": "CREATED" }, { "UserId": "demoUser2", "UserStatus": "CREATED" } ] } ``` # Búsqueda de un rostro con un ID de rostro Puede utilizar la [SearchFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFaces.html)operación para buscar usuarios en una colección que coincidan con la cara más grande de una imagen proporcionada. El ID de rostro se devuelve en la respuesta de la operación [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html) cuando el rostro se detecta y se añade a una colección. Para obtener más información, consulte [Administración de rostros en una colección](managing-face-collections.md#collections-index-faces). **Para buscar un rostro en una colección con su ID de rostro (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `SearchFaces`. ------ #### [ Java ] Este ejemplo muestra información acerca de los rostros que coinciden con un rostro identificado por su ID. Cambie el valor de `collectionID` por la colección que contiene el rostro requerido. Cambie el valor de `faceId` por el identificador del rostro que desea buscar. ``` //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.fasterxml.jackson.databind.ObjectMapper; import com.amazonaws.services.rekognition.model.FaceMatch; import com.amazonaws.services.rekognition.model.SearchFacesRequest; import com.amazonaws.services.rekognition.model.SearchFacesResult; import java.util.List; public class SearchFaceMatchingIdCollection { public static final String collectionId = "MyCollection"; public static final String faceId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); ObjectMapper objectMapper = new ObjectMapper(); // Search collection for faces matching the face id. SearchFacesRequest searchFacesRequest = new SearchFacesRequest() .withCollectionId(collectionId) .withFaceId(faceId) .withFaceMatchThreshold(70F) .withMaxFaces(2); SearchFacesResult searchFacesByIdResult = rekognitionClient.searchFaces(searchFacesRequest); System.out.println("Face matching faceId " + faceId); List < FaceMatch > faceImageMatches = searchFacesByIdResult.getFaceMatches(); for (FaceMatch face: faceImageMatches) { System.out.println(objectMapper.writerWithDefaultPrettyPrinter() .writeValueAsString(face)); System.out.println(); } } } ``` Ejecute el código de ejemplo. Se muestra información sobre rostros coincidentes. ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/SearchFaceMatchingIdCollection.java). ``` // snippet-start:[rekognition.java2.match_faces_collection.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.SearchFacesRequest; import software.amazon.awssdk.services.rekognition.model.SearchFacesResponse; import software.amazon.awssdk.services.rekognition.model.FaceMatch; import software.amazon.awssdk.services.rekognition.model.RekognitionException; import java.util.List; // snippet-end:[rekognition.java2.match_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 SearchFaceMatchingIdCollection { 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 faceId = 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"); searchFacebyId(rekClient, collectionId, faceId ) ; rekClient.close(); } // snippet-start:[rekognition.java2.match_faces_collection.main] public static void searchFacebyId(RekognitionClient rekClient,String collectionId, String faceId) { try { SearchFacesRequest searchFacesRequest = SearchFacesRequest.builder() .collectionId(collectionId) .faceId(faceId) .faceMatchThreshold(70F) .maxFaces(2) .build(); SearchFacesResponse imageResponse = rekClient.searchFaces(searchFacesRequest) ; 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 e) { System.out.println(e.getMessage()); System.exit(1); } } // snippet-end:[rekognition.java2.match_faces_collection.main] } ``` ------ #### [ AWS CLI ] Este AWS CLI comando muestra el resultado JSON de la operación `search-faces` CLI. Reemplace el valor de `face-id` por el identificador del rostro que desea buscar y reemplace el valor de `collection-id` por la colección en la que desea buscar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition search-faces --face-id face-id --collection-id "collection-id" --profile profile-name ``` ------ #### [ Python ] Este ejemplo muestra información acerca de los rostros que coinciden con un rostro identificado por su ID. Cambie el valor de `collectionID` por la colección que contiene el rostro requerido. Cambie el valor de `faceId` por el identificador del rostro que desea buscar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` # 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 search_face_in_collection(face_id, collection_id): threshold = 90 max_faces = 2 session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') response = client.search_faces(CollectionId=collection_id, FaceId=face_id, FaceMatchThreshold=threshold, MaxFaces=max_faces) face_matches = response['FaceMatches'] print('Matching faces') for match in face_matches: print('FaceId:' + match['Face']['FaceId']) print('Similarity: ' + "{:.2f}".format(match['Similarity']) + "%") return len(face_matches) def main(): face_id = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' collection_id = 'collection-id' faces = [] faces.append(face_id) faces_count = search_face_in_collection(face_id, collection_id) print("faces found: " + str(faces_count)) if __name__ == "__main__": main() ``` ------ #### [ .NET ] Este ejemplo muestra información acerca de los rostros que coinciden con un rostro identificado por su ID. Cambie el valor de `collectionID` por la colección que contiene el rostro requerido. Cambie el valor de `faceId` por el identificador del rostro que desea buscar. ``` //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 SearchFacesMatchingId { public static void Example() { String collectionId = "MyCollection"; String faceId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(); // Search collection for faces matching the face id. SearchFacesRequest searchFacesRequest = new SearchFacesRequest() { CollectionId = collectionId, FaceId = faceId, FaceMatchThreshold = 70F, MaxFaces = 2 }; SearchFacesResponse searchFacesResponse = rekognitionClient.SearchFaces(searchFacesRequest); Console.WriteLine("Face matching faceId " + faceId); Console.WriteLine("Matche(s): "); foreach (FaceMatch face in searchFacesResponse.FaceMatches) Console.WriteLine("FaceId: " + face.Face.FaceId + ", Similarity: " + face.Similarity); } } ``` Ejecute el código de ejemplo. Se muestra información sobre rostros coincidentes. ------ ## SearchFaces solicitud de operación Dado un ID de rostro (cada rostro almacenado en una colección de rostros tiene un ID de rostro), `SearchFaces` busca rostros similares en la colección de rostros especificada. La respuesta no incluye el rostro que está buscando. Incluye solo rostros similares. De forma predeterminada, `SearchFaces` devuelve rostros para los que el algoritmo detecta una similitud superior al 80%. La similitud indica la exactitud con la que los rostros encontrados coinciden con el rostro de entrada. Si lo prefiere, puede utilizar `FaceMatchThreshold` para especificar un valor diferente. ``` { "CollectionId": "MyCollection", "FaceId": "0b683aed-a0f1-48b2-9b5e-139e9cc2a757", "MaxFaces": 2, "FaceMatchThreshold": 99 } ``` ## SearchFaces respuesta de operación La operación devuelve una matriz de los rostros coincidentes encontrados y el ID del rostro que proporcionó como entrada. ``` { "SearchedFaceId": "7ecf8c19-5274-5917-9c91-1db9ae0449e2", "FaceMatches": [ list of face matches found ] } ``` Para cada rostro coincidente encontrado, la respuesta incluye metadatos de similitud y de rostro, como se muestra en la siguiente respuesta de ejemplo: ``` { ... "FaceMatches": [ { "Similarity": 100.0, "Face": { "BoundingBox": { "Width": 0.6154, "Top": 0.2442, "Left": 0.1765, "Height": 0.4692 }, "FaceId": "84de1c86-5059-53f2-a432-34ebb704615d", "Confidence": 99.9997, "ImageId": "d38ebf91-1a11-58fc-ba42-f978b3f32f60" } }, { "Similarity": 84.6859, "Face": { "BoundingBox": { "Width": 0.2044, "Top": 0.2254, "Left": 0.4622, "Height": 0.3119 }, "FaceId": "6fc892c7-5739-50da-a0d7-80cc92c0ba54", "Confidence": 99.9981, "ImageId": "5d913eaf-cf7f-5e09-8c8f-cb1bdea8e6aa" } } ] } ``` # Búsqueda de un rostro con una imagen Puede utilizar la operación [SearchFacesByImage](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchFacesByImage.html) para buscar rostros en una colección que coincida con el rostro de mayor tamaño en una imagen suministrada. Para obtener más información, consulte [Búsqueda de rostros y usuarios dentro de una colección](collections-search-faces.md). **Para buscar un rostro en una colección con una imagen (SDK)** 1. Si aún no lo ha hecho: 1. Cree o actualice un usuario con los permisos `AmazonRekognitionFullAccess` y `AmazonS3ReadOnlyAccess`. 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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Suba una imagen (que contenga uno o varios rostros) en el bucket de S3. Para ver las instrucciones, consulte [Carga de objetos en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Consulte los siguientes ejemplos para llamar a la operación `SearchFacesByImage`. ------ #### [ Java ] Este ejemplo muestra información acerca de los rostros que coinciden con el rostro de mayor tamaño de una imagen. El ejemplo de código especifica los parámetros `FaceMatchThreshold` y `MaxFaces` para limitar los resultados que se devuelven en la respuesta. En el siguiente ejemplo, cambie lo siguiente: el valor de `collectionId` por la colección en la que desea buscar; cambie el valor de búsqueda `bucket` por el bucket que contiene la imagen de entrada y cambie el valor de `photo` por la imagen de entrada. ``` //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 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](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 ] Este AWS CLI comando muestra el resultado JSON de la operación `search-faces-by-image` CLI. Reemplace el valor de `Bucket` por el nombre del bucket de S3 que utilizó en el paso 2. Reemplace el valor de `Name` por el nombre de archivo de imagen que utilizó en el paso 2. Reemplace el valor de `collection-id` por la colección en la que desea buscar. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` aws rekognition search-faces-by-image --image '{"S3Object":{"Bucket":"bucket-name","Name":"image-name"}}' \ --collection-id "collection-id" --profile profile-name ``` Si accede a la CLI en un dispositivo Windows, utilice comillas dobles en lugar de comillas simples y evite las comillas dobles internas con una barra invertida (es decir, \$1) para corregir cualquier error del analizador que pueda encontrar. Por ver un ejemplo, consulte lo siguiente: ``` aws rekognition search-faces-by-image --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" \ --collection-id "collection-id" --profile profile-name ``` ------ #### [ Python ] Este ejemplo muestra información acerca de los rostros que coinciden con el rostro de mayor tamaño de una imagen. El ejemplo de código especifica los parámetros `FaceMatchThreshold` y `MaxFaces` para limitar los resultados que se devuelven en la respuesta. En el siguiente ejemplo, cambie lo siguiente: el valor de `collectionId` por la colección que desea buscar y sustituya los valores de `bucket` y `photo` por los nombres del bucket de Amazon S3 y la imagen que utilizó en el Paso 2. Sustituya el valor de `profile_name` en la línea que crea la sesión de Rekognition por el nombre de su perfil de desarrollador. ``` #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 ] Este ejemplo muestra información acerca de los rostros que coinciden con el rostro de mayor tamaño de una imagen. El ejemplo de código especifica los parámetros `FaceMatchThreshold` y `MaxFaces` para limitar los resultados que se devuelven en la respuesta. En el siguiente ejemplo, cambie lo siguiente: el valor de `collectionId` por la colección que desea buscar y sustituya los valores de `bucket` y `photo` por los nombres del bucket de Amazon S3 y la imagen que utilizó en el paso 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 solicitud de operación Los parámetros de entrada de `SearchFacesImageByImage` son 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 rostros que se devuelven (`Maxfaces`) y la confianza mínima que debe asociarse para que se devuelva un rostro (`FaceMatchThreshold`). ``` { "CollectionId": "MyCollection", "Image": { "S3Object": { "Bucket": "bucket", "Name": "input.jpg" } }, "MaxFaces": 2, "FaceMatchThreshold": 99 } ``` ## SearchFacesByImage respuesta de operación Dada una imagen de entrada (.jpeg o .png), la operación detecta primero el rostro en la imagen de entrada y después busca rostros similares en la colección de rostros especificada. **nota** Si el servicio detecta varios rostros en la imagen de entrada, utiliza el rostro mayor detectado para buscarlo en la colección de rostros. La operación devuelve una matriz de los rostros coincidentes encontrados y la información sobre el rostro de entrada. Esto incluye información como el cuadro de límite y el valor de confianza, que indica el nivel de confianza de que el cuadro contenga un rostro. De forma predeterminada, `SearchFacesByImage` devuelve rostros para los que el algoritmo detecta una similitud superior al 80%. La similitud indica la exactitud con la que los rostros encontrados coinciden con el rostro de entrada. Si lo prefiere, puede utilizar `FaceMatchThreshold` para especificar un valor diferente. Para cada rostro coincidente encontrado, la respuesta incluye metadatos de similitud y de rostro, como se muestra en la siguiente respuesta de ejemplo: ``` { "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 } ``` # Búsqueda de usuarios (ID de rostro/ID de usuario) Puede utilizar la [SearchUsers](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_SearchUsers.html)operación para buscar usuarios en una colección específica que coincidan con un identificador facial o un identificador de usuario proporcionados. La operación muestra los resultados `UserIds` clasificados según la puntuación de similitud más alta por encima de la solicitada UserMatchThreshold. El ID de usuario se crea en la CreateUsers operación. Para obtener más información, consulte [Administrar usuarios en una colección](managing-face-collections.md#collections-manage-users). **Para buscar usuarios (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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](setup-awscli-sdk.md). 1. Consulte los siguientes ejemplos para llamar a la operación `SearchUsers`. ------ #### [ Java ] En este ejemplo de Java, se buscan los usuarios de una colección mediante la operación `SearchUsers`. ``` import com.amazonaws.services.rekognition.AmazonRekognition; import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder; import com.amazonaws.services.rekognition.model.UserMatch; import com.amazonaws.services.rekognition.model.SearchUsersRequest; import com.amazonaws.services.rekognition.model.SearchUsersResult; import com.amazonaws.services.rekognition.model.UserMatch; public class SearchUsers { //Replace collectionId and faceId with the values you want to use. public static final String collectionId = "MyCollection"; public static final String faceId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; public static final String userd = 'demo-user'; public static void main(String[] args) throws Exception { AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient(); // Search collection for faces matching the user id. SearchUsersRequest request = new SearchUsersRequest() .withCollectionId(collectionId) .withUserId(userId); SearchUsersResult result = rekognitionClient.searchUsers(request); System.out.println("Printing first search result with matched user and similarity score"); for (UserMatch match: result.getUserMatches()) { System.out.println(match.getUser().getUserId() + " with similarity score " + match.getSimilarity()); } // Search collection for faces matching the face id. SearchUsersRequest request1 = new SearchUsersRequest() .withCollectionId(collectionId) .withFaceId(faceId); SearchUsersResult result1 = rekognitionClient.searchUsers(request1); System.out.println("Printing second search result with matched user and similarity score"); for (UserMatch match: result1.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 con la `SearchUsers` operación. ``` aws rekognition search-users --face-id face-id --collection-id collection-id --region region-name ``` ------ #### [ Python ] En el siguiente ejemplo, se buscan los usuarios de una colección con la operación `SearchUsers`. ``` # 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 logger = logging.getLogger(__name__) session = boto3.Session(profile_name='profile-name') client = session.client('rekognition') def search_users_by_face_id(collection_id, face_id): """ SearchUsers operation with face ID provided as the search source :param collection_id: The ID of the collection where user and faces are stored. :param face_id: The ID of the face in the collection to search for. :return: response of SearchUsers API """ logger.info(f'Searching for users using a face-id: {face_id}') try: response = client.search_users( CollectionId=collection_id, FaceId=face_id ) 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 SearchUsers with given face id: {face_id}') raise else: print(response) return response def search_users_by_user_id(collection_id, user_id): """ SearchUsers operation with user ID provided as the search source :param collection_id: The ID of the collection where user and faces are stored. :param user_id: The ID of the user in the collection to search for. :return: response of SearchUsers API """ logger.info(f'Searching for users using a user-id: {user_id}') try: response = client.search_users( CollectionId=collection_id, UserId=user_id ) 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 SearchUsers with given face id: {user_id}') raise else: print(response) return response def main(): collection_id = "collection-id" user_id = "user-id" face_id = "face_id" search_users_by_face_id(collection_id, face_id) search_users_by_user_id(collection_id, user_id) if __name__ == "__main__": main() ``` ------ ## SearchUsers solicitud de operación Con un FaceID o un UserID SearchUsers , busca coincidencias de usuario en el CollectionID especificado. De forma predeterminada, SearchUsers devuelve el nombre de usuario IDs para el que la puntuación de similitud es superior al 80%. La similitud indica en qué medida el UserID coincide con el FaceID o el UserID proporcionados. Si IDs se devuelven varios usuarios, 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). A continuación se muestra un ejemplo de una SearchUsers solicitud que utiliza`UserId`: ``` { "CollectionId": "MyCollection", "UserId": "demoUser1", "MaxUsers": 2, "UserMatchThreshold": 99 } ``` El siguiente es un ejemplo de una SearchUsers solicitud que utiliza`FaceId`: ``` { "CollectionId": "MyCollection", "FaceId": "bff43c40-cfa7-4b94-bed8-8a08b2205107", "MaxUsers": 2, "UserMatchThreshold": 99 } ``` ## SearchUsers respuesta de operación Si busca con un`FaceId`, la respuesta para SearchUsers incluye el `FaceId` para el`SearchedFace`, así como una lista de `UserMatches` y el `UserId` y `UserStatus` para cada usuario. ``` { "SearchedFace": { "FaceId": "bff43c40-cfa7-4b94-bed8-8a08b2205107" }, "UserMatches": [ { "User": { "UserId": "demoUser1", "UserStatus": "ACTIVE" }, "Similarity": 100.0 }, { "User": { "UserId": "demoUser2", "UserStatus": "ACTIVE" }, "Similarity": 99.97946166992188 } ], "FaceModelVersion": "6" } ``` Si busca con un`UserId`, la respuesta para SearchUsers incluye el `UserId` para`SearchedUser`, además de los demás elementos de respuesta. ``` { "SearchedUser": { "UserId": "demoUser1" }, "UserMatches": [ { "User": { "UserId": "demoUser2", "UserStatus": "ACTIVE" }, "Similarity": 99.97946166992188 } ], "FaceModelVersion": "6" } ``` # 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 el nombre de usuario IDs para el 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 IDs se devuelven varios usuarios, 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 el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 2: Configure y AWS CLI AWS SDKs](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 mostrará 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" ] } ] } ``` # Búsqueda de rostros en vídeos almacenados Puede buscar una colección de rostros que coincida con rostros de personas detectados en un vídeo almacenado o un vídeo en streaming. En esta sección se explica la búsqueda de rostros en un vídeo almacenado. Para obtener información sobre la búsqueda de rostros en un vídeo en streaming, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md). Los rostros que busca se deben indexar primero en una colección utilizando [IndexFaces](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_IndexFaces.html). Para obtener más información, consulte [Agregar rostros a una colección](add-faces-to-collection-procedure.md). La búsqueda de rostros de Amazon Rekognition Video sigue el mismo flujo de trabajo asíncrono que otras operaciones de Amazon Rekognition Video que analizan vídeos almacenados en un bucket de Amazon S3. Para empezar a buscar rostros en un vídeo almacenado, llama [StartFaceSearch](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartFaceSearch.html)y proporciona el identificador de la colección en la que deseas buscar. Amazon Rekognition Video publica el estado de finalización de una operación de análisis de vídeo en un tema de Amazon Simple Notification Service (Amazon SNS). Si el análisis de vídeo es correcto, llame a [GetFaceSearch](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GeFaceSearch.html) para obtener los resultados de la búsqueda. Para obtener más información sobre cómo iniciar el análisis de vídeo y obtener los resultados, consulte [Cómo llamar a las operaciones de Amazon Rekognition Video](api-video.md). El siguiente procedimiento muestra cómo buscar una colección de rostros que coincide con los rostros de las personas detectados en un vídeo. El procedimiento también muestra cómo obtener los datos de seguimiento de las personas que coinciden en el vídeo. El procedimiento amplía el código de [Análisis de un vídeo almacenado en un bucket de Amazon S3 con Java o Python (SDK)](video-analyzing-with-sqs.md), que utiliza una cola de Amazon Simple Queue Service (Amazon SQS) para obtener el estado de realización de una solicitud de análisis de vídeo. **Para buscar rostros coincidentes en un vídeo (SDK)** 1. [Crear una colección](create-collection-procedure.md). 1. [Indexe un rostro en la colección](add-faces-to-collection-procedure.md). 1. Realice [Análisis de un vídeo almacenado en un bucket de Amazon S3 con Java o Python (SDK)](video-analyzing-with-sqs.md). 1. Añada el código siguiente a la clase `VideoDetect` que ha creado en el paso 3. ------ #### [ 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.) //Face collection search in video ================================================================== private static void StartFaceSearchCollection(String bucket, String video, String collection) throws Exception{ NotificationChannel channel= new NotificationChannel() .withSNSTopicArn(snsTopicArn) .withRoleArn(roleArn); StartFaceSearchRequest req = new StartFaceSearchRequest() .withCollectionId(collection) .withVideo(new Video() .withS3Object(new S3Object() .withBucket(bucket) .withName(video))) .withNotificationChannel(channel); StartFaceSearchResult startPersonCollectionSearchResult = rek.startFaceSearch(req); startJobId=startPersonCollectionSearchResult.getJobId(); } //Face collection search in video ================================================================== private static void GetFaceSearchCollectionResults() throws Exception{ GetFaceSearchResult faceSearchResult=null; int maxResults=10; String paginationToken=null; do { if (faceSearchResult !=null){ paginationToken = faceSearchResult.getNextToken(); } faceSearchResult = rek.getFaceSearch( new GetFaceSearchRequest() .withJobId(startJobId) .withMaxResults(maxResults) .withNextToken(paginationToken) .withSortBy(FaceSearchSortBy.TIMESTAMP) ); VideoMetadata videoMetaData=faceSearchResult.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()); System.out.println(); //Show search results List matches= faceSearchResult.getPersons(); for (PersonMatch match: matches) { long milliSeconds=match.getTimestamp(); System.out.print("Timestamp: " + Long.toString(milliSeconds)); System.out.println(" Person number: " + match.getPerson().getIndex()); List faceMatches = match.getFaceMatches(); if (faceMatches != null) { System.out.println("Matches in collection..."); for (FaceMatch faceMatch: faceMatches){ Face face=faceMatch.getFace(); System.out.println("Face Id: "+ face.getFaceId()); System.out.println("Similarity: " + faceMatch.getSimilarity().toString()); System.out.println(); } } System.out.println(); } System.out.println(); } while (faceSearchResult !=null && faceSearchResult.getNextToken() != null); } ``` En la función `main`, reemplace las líneas: ``` StartLabelDetection(bucket, video); if (GetSQSMessageSuccess()==true) GetLabelDetectionResults(); ``` por: ``` String collection="collection"; StartFaceSearchCollection(bucket, video, collection); if (GetSQSMessageSuccess()==true) GetFaceSearchCollectionResults(); ``` ------ #### [ Java V2 ] Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/VideoDetectFaces.java). ``` import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.rekognition.RekognitionClient; import software.amazon.awssdk.services.rekognition.model.*; import java.util.List; /** * 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 = """ Usage: