Ml 16090 Image004 1018x630.png

En diversas industrias, como las de servicios financieros, telecomunicaciones y atención médica, los clientes utilizan un proceso de identidad digital, que generalmente implica varios pasos para verificar a los usuarios finales durante la incorporación en línea o la autenticación intensificada. Un ejemplo de un paso que se puede utilizar es la búsqueda de rostros, que puede ayudar a determinar si el rostro de un nuevo usuario final coincide con los asociados con una cuenta existente.

La creación de un sistema de búsqueda de rostros preciso implica varios pasos. El sistema debe poder detectar rostros humanos en imágenes, extraer los rostros en representaciones vectoriales, almacenar vectores de rostros en una base de datos y comparar rostros nuevos con entradas existentes. Reconocimiento de Amazon hace que esto sea sencillo al brindarle modelos previamente entrenados que se invocan mediante simples llamadas API.

Amazon Rekognition le permite lograr una precisión de búsqueda de rostros muy alta con una sola imagen de rostro. En algunos casos, puedes utilizar varias imágenes del rostro de la misma persona para crear vectores de usuario y mejorar aún más la precisión. Esto es especialmente útil cuando las imágenes tienen variaciones en iluminación, poses y apariencias.

En esta publicación, demostramos cómo utilizar las API de búsqueda facial de Amazon Rekognition con vectores de usuario para aumentar la puntuación de similitud para coincidencias verdaderas y disminuir la puntuación de similitud para coincidencias verdaderas.

Comparamos los resultados de realizar coincidencias de rostros con y sin vectores de usuario.

Coincidencia de rostros de Amazon Rekognition

La coincidencia de rostros de Amazon Rekognition permite medir la similitud de un vector de rostro extraído de una imagen con un vector de rostro extraído de otra imagen. Se dice que un par de imágenes de caras son una verdadero partido si ambas imágenes contienen el rostro de la misma persona, y una verdadera no coincidencia de lo contrario. Amazon Rekognition devuelve una puntuación por la similitud de las caras de origen y de destino. La puntuación mínima de similitud es 0, lo que implica muy poca similitud, y la máxima es 100.

Para comparar una cara de origen con una colección de caras de destino (coincidencia 1:N), Amazon Rekognition le permite crear un objeto de colección y completarlo con caras de imágenes mediante llamadas API.

Al agregar una cara a una colección, Amazon Rekognition no almacena la imagen real de la cara, sino el vector de la cara, una representación matemática de la cara. Con el Buscar caras API, puede comparar una cara de origen con una o varias colecciones de caras de destino.

En junio de 2023, AWS lanzó vectores de usuario, una nueva capacidad que mejora significativamente la precisión de la búsqueda de rostros mediante el uso de múltiples imágenes faciales de un usuario. Ahora puede crear vectores de usuario, que agregan múltiples vectores de caras del mismo usuario. Los vectores de usuario ofrecen una mayor precisión de búsqueda de rostros con representaciones más sólidas, porque contienen distintos grados de iluminación, nitidez, pose, apariencia y más. Esto mejora la precisión en comparación con la búsqueda en vectores de caras individuales.

En las siguientes secciones, describimos el proceso de uso de vectores de usuario de Amazon Rekognition. Lo guiamos a través de la creación de una colección, el almacenamiento de vectores faciales en esa colección, la agregación de esos vectores faciales en vectores de usuario y luego la comparación de los resultados de la búsqueda con esos vectores faciales individuales y vectores de usuario.

Descripción general de la solución

Para esta solución, utilizamos una colección de usuarios de Amazon Rekognition, cada uno con sus vectores de rostros indexados asociados de varias imágenes diferentes de rostros para cada usuario.

Veamos el flujo de trabajo para crear una colección con usuarios y caras:

  1. Cree una colección de Amazon Rekognition.
  2. Para cada usuario, cree un usuario en la colección.
  3. Para cada imagen del usuario, agregue la cara a la colección (Índice de carasque devuelve el ID de cara correspondiente a cada vector de cara).
  4. Asocie todos los ID de rostro indexados con el usuario (esto es necesario para los vectores de usuario).

Luego, compararemos los siguientes flujos de trabajo:

Búsqueda con una nueva imagen de entrada determinada frente a vectores de caras individuales en nuestra colección:

  1. Obtener todas las caras de una imagen (Detectar caras).
  2. Para cada rostro, compárelo con rostros individuales de nuestra colección (Buscar caras por imagen).

Búsqueda con una nueva imagen de entrada determinada frente a vectores de usuario en nuestra colección:

  1. Obtener todas las caras de una imagen (Detectar caras).
  2. Para cada cara, compare con el vector del usuario (BuscarUsuariosPorImagen).

Ahora describamos la solución en detalle.

Requisitos previos

Agregue la siguiente política a su Gestión de acceso e identidad de AWS (IAM) usuario o rol. La política le otorga permiso para las API de Amazon Rekognition relevantes y le permite acceder a una Servicio de almacenamiento simple de Amazon (Amazon S3) depósito para almacenar las imágenes:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "RekognitionPermissions",
            "Effect": "Allow",
            "Action": [
                "rekognition:CreateCollection",
                "rekognition:DeleteCollection",
                "rekognition:CreateUser",
                "rekognition:IndexFaces",
                "rekognition:DetectFaces",
                "rekognition:AssociateFaces",
                "rekognition:SearchUsersByImage",
                "rekognition:SearchFacesByImage"
            ],
            "Resource": "*"
        },
        {
            "Sid": "S3BucketPermissions",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::<replace_with_your_bucket>/*",
                "arn:aws:s3:::<replace_with_your_bucket>"
            ]
        }
    ]
}

Cree una colección de Amazon Rekognition y agregue usuarios y rostros

Primero, creamos un depósito S3 para almacenar las imágenes de los usuarios. Organizamos el depósito creando una carpeta para cada usuario que contiene sus imágenes personales. Nuestro carpeta de imágenes se parece a la siguiente estructura:

── images
│   ├── photo.jpeg
│   ├── Swami
│   │   ├── Swami1.jpeg
│   │   └── Swami2.jpeg
│   └── Werner
│       ├── Werner1.jpeg
│       ├── Werner2.jpeg
│       └── Werner3.jpeg

Nuestro depósito S3 tiene un directorio para cada usuario que almacena sus imágenes. Actualmente hay dos carpetas y cada una contiene varias imágenes. Puede agregar más carpetas para sus usuarios, cada una de las cuales contiene una o más imágenes para indexar.

A continuación, creamos nuestra colección de Amazon Rekognition. hemos suministrado ayudantes.pyque contiene diferentes métodos que utilizamos:

  • crear_colección – Crear una nueva colección
  • eliminar_colección – Eliminar una colección
  • crear usuario – Crear un nuevo usuario en una colección.
  • agregar_caras_a_la_colección – Agregar caras a la colección
  • caras_asociadas – Asociar face_ids a un usuario en una colección
  • get_subdirs – Obtener todos los subdirectorios bajo el prefijo S3
  • obtener_archivos – Obtener todos los archivos bajo el prefijo S3

El siguiente es un método de ejemplo para crear una colección de Amazon Rekognition:

import boto3
session = boto3.Session()
client = session.client('rekognition')

def create_collection(collection_id):
    try:
        # 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...')
    except client.exceptions.ResourceAlreadyExistsException:
        print('Resource already exits...')

Crea la colección con el siguiente código:

import helpers
collection_id = "faces-collection"
helpers.create_collection(collection_id)

A continuación, agreguemos los vectores de caras a nuestra colección y agreguemoslos en vectores de usuario.

Para cada usuario en el directorio S3, creamos un vector de usuario en la colección. Luego indexamos las imágenes de rostros de cada usuario en la colección como vectores de rostros individuales, lo que genera identificaciones de rostros. Por último, asociamos los ID de rostro al vector de usuario apropiado.

Esto crea dos tipos de vectores en nuestra colección:

  • Vectores de caras individuales
  • Vectores de usuario, que se crean en función de los ID de vectores faciales proporcionados mediante el método associate_faces

Vea el siguiente código:

bucket="<replace_with_your_bucket>"
prefix = 'images/'

# Get all the users directories from s3 containing the images
folder_list = helpers.get_subdirs(bucket, prefix)
print(f"Found users folders: {folder_list}")
print()

for user_id in folder_list:
    face_ids = []
    helpers.create_user(collection_id, user_id)
    # Get all files per user under the s3 user directory
    images = helpers.get_files(bucket, prefix + user_id + "/")
    print (f"Found images={images} for {user_id}")
    for image in images:
        face_id = helpers.add_faces_to_collection(bucket, image, collection_id)
        face_ids.append(face_id)
    helpers.associate_faces(collection_id, user_id, face_ids)
    print()

Utilizamos los siguientes métodos:

  • get_subdirs – Devuelve una lista de todos los directorios de los usuarios. En nuestro ejemplo, el valor es [Swami,Werner].
  • obtener_archivos – Devuelve todos los archivos de imágenes bajo el prefijo S3 para el usuario.
  • face_ids – Esta es una lista que contiene todos los ID de rostro que pertenecen a un usuario. Usamos esta lista cuando llamamos al caras asociadas API.

Como se explicó anteriormente, puede agregar más usuarios agregando carpetas para ellos (la carpeta dicta la ID del usuario) y agregar sus imágenes en esa carpeta (no es necesario ordenar los archivos).

Ahora que nuestro entorno está configurado y tenemos vectores de caras individuales y vectores de usuario, comparemos nuestra calidad de búsqueda con cada uno de ellos. Para hacer eso, usamos una nueva foto con varias personas e intentamos hacer coincidir sus rostros con nuestra colección, primero con los vectores de rostros individuales y luego con los vectores de usuario.

Búsqueda de rostros de imágenes frente a una colección de vectores de rostros individuales

Para buscar en nuestros vectores faciales individuales, utilizamos Amazon Rekognition Buscar caras por imagen API. Esta función utiliza una imagen de rostro de origen para buscar vectores de rostros individuales en nuestra colección y devuelve rostros que coinciden con nuestro umbral de puntuación de similitud definido.

Una consideración importante es que la SearchFacesByImage La API solo funcionará en la cara más grande detectada en la imagen. Si hay varias caras, debe recortar cada cara individual y pasarla por separado al método de identificación.

Para extraer detalles de caras de una imagen (como su ubicación en la imagen), utilizamos Amazon Rekognition Detectar caras API.

La siguiente detectar_caras_en_imagen El método detecta caras en una imagen. Para cada cara realiza las siguientes acciones:

  • Imprima la ubicación del cuadro delimitador
  • Recorte la cara de la imagen y verifique si dicha cara existe en la colección e imprima el usuario o ‘Desconocido’
  • Imprimir la puntuación de similitud

El código Python de ejemplo utiliza el Almohada Biblioteca para realizar manipulaciones de imágenes (como imprimir, dibujar y recortar).

Utilizamos un umbral de puntuación de similitud del 99 %, que es una configuración común para los casos de uso de verificación de identidad.

Ejecute el siguiente código:

import detect_users
from PIL import Image

# The image we would like to match faces against our collection.
file_key= "images/photo.jpeg"

img = detect_users.detect_faces_in_image(
    bucket, 
    file_key, 
    collection_id, 
    threshold=99
)
img.show() # or in Jupyter use display(img)

file_key es la clave del objeto S3 que queremos comparar con nuestra colección. Hemos proporcionado una imagen de ejemplo (photo.jpeg) en la carpeta de imágenes.

La siguiente imagen muestra nuestros resultados.

Utilizando un umbral del 99%, sólo se identificó a una persona. El Dr. Werner Vogels fue marcado como Desconocido. Si ejecutamos el mismo código usando un umbral inferior de 90 (umbral establecido = 90), obtenemos los siguientes resultados.

Ahora vemos que el rostro del Dr. Werner Vogel tiene una puntuación de similitud del 96,86%. A continuación, verifiquemos si podemos obtener una puntuación de similitud por encima de nuestro umbral definido utilizando vectores de usuario.

Búsqueda facial de imágenes frente a una colección de vectores de usuario

Para buscar en nuestros vectores de usuario, utilizamos Amazon Rekognition BuscarUsuariosPorImagen API. Esta función utiliza una imagen facial de origen para buscar vectores de usuarios en nuestra colección y devuelve usuarios que coinciden con nuestro umbral de puntuación de similitud definido.

La misma consideración es relevante aquí: la SearchUsersByImage La API solo funcionará en la cara más grande detectada en la imagen. Si hay varias caras presentes, debe recortar cada cara individual y pasarla por separado al método de identificación.

Para extraer detalles de caras de una imagen (como su ubicación en la imagen), utilizamos Amazon Rekognition Detectar caras API.

La siguiente detectar_usuarios_en_imagen El método detecta caras en una imagen. Para cada cara realiza las siguientes acciones:

  • Imprima la ubicación del cuadro delimitador
  • Recorte la cara de la imagen y verifique si dicha cara de usuario existe en nuestra colección e imprima el usuario o ‘Desconocido’
  • Imprimir la puntuación de similitud

Vea el siguiente código:

import boto3
import io
import math
from PIL import Image, ImageDraw, ImageFont

def detect_users_in_image(bucket, key, collection_id, threshold=80):

    session = boto3.Session()
    client = session.client('rekognition')

    # Load image from S3 bucket
    s3_connection = boto3.resource('s3')
    s3_object = s3_connection.Object(bucket, key)
    s3_response = s3_object.get()

    stream = io.BytesIO(s3_response['Body'].read())
    image = Image.open(stream)

    # Call DetectFaces to find faces in image
    response = client.detect_faces(
        Image={'S3Object': {'Bucket': bucket, 'Name': key}},
        Attributes=['ALL']
    )

    imgWidth, imgHeight = image.size
    draw = ImageDraw.Draw(image)

    # Calculate and display bounding boxes for each detected face
    for faceDetail in response['FaceDetails']:
        print('The detected face is between ' + str(faceDetail['AgeRange']['Low'])
              + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old')

        box = faceDetail['BoundingBox']
        left = imgWidth * box['Left']
        top = imgHeight * box['Top']
        width = imgWidth * box['Width']
        height = imgHeight * box['Height']

        print('Left: ' + '{0:.0f}'.format(left))
        print('Top: ' + '{0:.0f}'.format(top))
        print('Face Width: ' + "{0:.0f}".format(width))
        print('Face Height: ' + "{0:.0f}".format(height))

        points = (
            (left, top),
            (left + width, top),
            (left + width, top + height),
            (left, top + height),
            (left, top)
        )

        # Crop the face box and convert it to byte array
        face = image.crop((left, top, left + width, top + height))
        imgByteArr = image_to_byte_array(face, image.format)

        # Search for a user in our collection using the cropped image
        user_response = client.search_users_by_image(
            CollectionId=collection_id,
            Image={'Bytes': imgByteArr},
            UserMatchThreshold=threshold
        )
        # print (user_response)

        # Extract user id and the similarity from the response
        if (user_response['UserMatches']):
            similarity = user_response['UserMatches'][0]['Similarity']
            similarity = (math.trunc(similarity * 100) / 100) if isinstance(similarity, float) else similarity
            user_id = user_response['UserMatches'][0]['User']['UserId']
            print(f"User {user_id} was found, similarity of {similarity}%")
            print("")
        else:
            user_id = "Unknown"
            similarity = 0

        draw.line(points, fill="#00d400", width=4)
        font = ImageFont.load_default(size=25)
        draw.text((left, top - 30), user_id, fill="#00d400", font=font)
        if similarity > 0:
            draw.text((left, top + 1), str(similarity), fill="#00d400", font=font)

    return image

La función devuelve una imagen modificada con los resultados que se pueden guardar en Amazon S3 o imprimir. La función también genera estadísticas sobre las edades estimadas de las caras en el terminal.

Ejecute el siguiente código:

import detect_users
from PIL import Image

# The image we would like to match faces against our collection.
file_key= "images/photo.jpeg"

img = detect_users.detect_users_in_image(
    bucket, 
    file_key, 
    collection_id, 
    threshold=99
)
img.show() # or in Jupyter use display(img)

La siguiente imagen muestra nuestros resultados.

Los usuarios que existen en nuestra colección fueron identificados correctamente con alta similitud (más del 99%).

Pudimos aumentar la puntuación de similitud utilizando tres vectores de caras por vector de usuario. A medida que aumentamos la cantidad de vectores de caras utilizados, esperamos que también aumente la puntuación de similitud para coincidencias verdaderas. Puede utilizar hasta 100 vectores de caras por vector de usuario.

Puede encontrar un código de ejemplo de un extremo a otro en el repositorio de GitHub. Incluye una detallada cuaderno jupyter en el que puedes correr Amazon SageMaker Estudio (u otras alternativas).

Limpiar

Para eliminar la colección, utilice el siguiente código:

helpers.delete_collection(collection_id)

Conclusión

En esta publicación, presentamos cómo utilizar los vectores de usuario de Amazon Rekognition para implementar la búsqueda de rostros en una colección de rostros de usuarios. Demostramos cómo mejorar la precisión de la búsqueda de rostros mediante el uso de múltiples imágenes de rostros por usuario y las comparamos con vectores de rostros individuales. Además, describimos cómo puede utilizar las diferentes API de Amazon Rekognition para detectar rostros. El código de ejemplo proporcionado sirve como una base sólida para construir un sistema de búsqueda de rostros funcional.

Para obtener más información sobre los vectores de usuario de Amazon Rekognition, consulte Buscando caras en una colección. Si es nuevo en Amazon Rekognition, puede utilizar nuestra capa gratuita, que tiene una duración de 12 meses e incluye el procesamiento de 5000 imágenes por mes y el almacenamiento de 1000 objetos vectoriales de usuario por mes.


Sobre los autores

Arik Porat es arquitecto senior de soluciones de startups en Amazon Web Services. Trabaja con empresas emergentes para ayudarlas a construir y diseñar sus soluciones en la nube y le apasiona el aprendizaje automático y las soluciones basadas en contenedores. En su tiempo libre, a Arik le gusta jugar al ajedrez y a los videojuegos.

Eliran Efron es arquitecto de soluciones de startups en Amazon Web Services. Eliran es un entusiasta de los datos y la informática y ayuda a las empresas emergentes a diseñar sus arquitecturas de sistemas. En su tiempo libre, a Eliran le gusta construir y correr autos en carreras Touring y construir dispositivos IoT.