Requisitos previos Creación de una colección Nuevo registro de usuarios Inicio de sesión de usuario existente

Uso de Amazon Rekognition para la verificación de identidad

Amazon Rekognition proporciona a los usuarios varias operaciones que permiten la creación sencilla de sistemas de verificación de identidad. Amazon Rekognition permite al usuario detectar rostros en una imagen y, a continuación, comparar los rostros detectados con otros mediante la comparación de los datos de los rostros. Estos datos faciales se almacenan en contenedores del lado del servidor denominados colecciones. Al utilizar las operaciones de detección de rostros, comparación de rostros y gestión de colecciones de Amazon Rekognition, puede crear una aplicación con una solución de verificación de identidad.

Este tutorial mostrará dos flujos de trabajo comunes para la creación de aplicaciones que requieren la verificación de identidad.

El primer flujo de trabajo implica el registro de un nuevo usuario en una colección. El segundo flujo de trabajo implica buscar en una colección existente con el fin de iniciar sesión como usuario habitual.

Usará el AWS SDK para Python en este tutorial. También puedes consultar el GitHub repositorio de ejemplos del SDK de AWS documentación para ver más tutoriales de Python.

Requisitos previos

Antes de comenzar este tutorial, necesitará instalar Python y completar los pasos necesarios para configurar el AWS SDK de Python. Además de esto, asegúrese de que:

Ha creado una cuenta de AWS y un rol de IAM
Ha instalado el SDK para Python (Boto3)
Has configurado correctamente tus credenciales de AWS acceso
Ha creado un bucket de Amazon Simple Storage Service y subido una imagen que desee utilizar como identificador a efectos de verificación de identidad.
Ha seleccionado una segunda imagen para que sirva como imagen de destino para la verificación de identidad.

Creación de una colección

Para poder registrar un nuevo usuario o buscar un usuario en una colección o buscar un usuario, es necesario disponer de una colección con la que trabajar. Una colección de Amazon Rekognition es un contenedor del lado del servidor que se utiliza para almacenar información sobre los rostros detectados.

Crear la colección

El primer paso es escribir una función que cree una colección para que la utilice su aplicación. Amazon Rekognition almacena información sobre los rostros que se han detectado en contenedores del lado del servidor denominados Colecciones. Puede buscar rostros conocidos en la información facial almacenada en una colección. Para almacenar información facial, primero debe crear una colección mediante la operación CreateCollection.

Seleccione un nombre para la colección que le gustaría crear. En el código siguiente, sustituya el valor de collection_id por el nombre de la colección que desee crear y sustituya el valor de region por el nombre de la región definida en sus credenciales de usuario. Puede usar el argumento Tags para aplicar las etiquetas que desee a la colección, aunque no es obligatorio. La operación CreateCollection devolverá información sobre la colección que ha creado, incluido el ARN de la colección. Anote el ARN que reciba al ejecutar el código.


import boto3

def create_collection(collection_id, region):
    client = boto3.client('rekognition', region_name=region)

    # Create a collection
    print('Creating collection:' + collection_id)
    response = client.create_collection(CollectionId=collection_id, 
    Tags={"SampleKey1":"SampleValue1"})
    print('Collection ARN: ' + response['CollectionArn'])
    print('Status code: ' + str(response['StatusCode']))
    print('Done...')

collection_id = 'collection-id-name'
region = "region-name"
create_collection(collection_id, region)

Guarde y ejecute el código. Copie el ARN de la colección.

Ahora que se ha creado la colección de Rekognition, puede almacenar información facial e identificadores en esa colección. También podrá comparar los rostros con la información almacenada para su verificación.

Nuevo registro de usuarios

Querrá poder registrar nuevos usuarios y añadir su información a una colección. El proceso de registro de un nuevo usuario suele incluir los siguientes pasos:

Llamar a la operación `DetectFaces`

Escriba el código para comprobar la calidad de la imagen del rostro mediante la operación DetectFaces. Utilizará la operación DetectFaces para determinar si una imagen capturada por la cámara es adecuada para procesarla mediante la operación SearchFacesByImage. La imagen debe contener solo una cara. Proporcionará un archivo de imagen de entrada local a la operación DetectFaces y recibirá los detalles de los rostros detectados en la imagen. El siguiente código de ejemplo proporciona la imagen de entrada DetectFaces y, a continuación, comprueba si solo se ha detectado un rostro en la imagen.

En el siguiente ejemplo de código, sustituya photo por el nombre de la imagen de destino en la que quiere detectar rostros. También tendrá que sustituir el valor de region por el nombre de la región asociada a su cuenta.


import boto3
import json

def detect_faces(target_file, region):

    client=boto3.client('rekognition', region_name=region)

    imageTarget = open(target_file, 'rb')

    response = client.detect_faces(Image={'Bytes': imageTarget.read()}, 
    Attributes=['ALL'])

    print('Detected faces for ' + photo)
    for faceDetail in response['FaceDetails']:
        print('The detected face is between ' + str(faceDetail['AgeRange']['Low'])
              + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old')

        print('Here are the other attributes:')
        print(json.dumps(faceDetail, indent=4, sort_keys=True))

        # Access predictions for individual face details and print them
        print("Gender: " + str(faceDetail['Gender']))
        print("Smile: " + str(faceDetail['Smile']))
        print("Eyeglasses: " + str(faceDetail['Eyeglasses']))
        print("Emotions: " + str(faceDetail['Emotions'][0]))

    return len(response['FaceDetails'])

photo = 'photo-name'
region = 'region-name'
face_count=detect_faces(photo, region)
print("Faces detected: " + str(face_count))

if face_count == 1:
    print("Image suitable for use in collection.")
else:
    print("Please submit an image with only one face.")

Guarde y ejecute el código de procedimiento.

Llamar a la operación `CompareFaces`

Su aplicación deberá poder registrar nuevos usuarios en una colección y confirmar la identidad de los usuarios recurrentes. Primero creará las funciones que se utilizan para registrar un nuevo usuario. Empezará por utilizar la CompareFaces operación para comparar una input/target image of the user and a ID/stored imagen local. Si hay una coincidencia entre el rostro detectado en ambas imágenes, puede buscar en la colección para ver si el usuario está registrado en ella.

Comience por escribir una función que compare una imagen de entrada con la imagen de ID que ha almacenado en su bucket de Amazon S3. En el siguiente ejemplo de código, tendrá que proporcionar la imagen de entrada, que debería capturar después de utilizar algún tipo de detector de prueba de vida. También tendrá que pasar el nombre de una imagen almacenada en el bucket de Amazon S3.

Reemplace el valor de bucket por el nombre del bucket de Amazon S3 que contiene el archivo fuente. También tendrá que reemplazar el valor de source_file por el nombre de la imagen de origen que está utilizando. Reemplace el valor de target_file por el nombre del archivo de destino que ha proporcionado. Sustituya el valor de region de por el nombre de la region definida en sus credenciales de usuario.

También querrá especificar un nivel mínimo de confianza en la coincidencia que se devuelve en la respuesta, utilizando el argumento similarityThreshold. Los rostros detectados solo se devolverán a la matriz FaceMatches si la confianza está por encima de este umbral. Su similarityThreshold elegido debe reflejar la naturaleza de su caso de uso específico. Cualquier caso de uso que involucre aplicaciones de seguridad críticas debe usar 99 como el umbral seleccionado.


import boto3

def compare_faces(bucket, sourceFile, targetFile, region):
    client = boto3.client('rekognition', region_name=region)

    imageTarget = open(targetFile, 'rb')

    response = client.compare_faces(SimilarityThreshold=99,
                                    SourceImage={'S3Object':{'Bucket':bucket,'Name':sourceFile}},
                                    TargetImage={'Bytes': imageTarget.read()})

    for faceMatch in response['FaceMatches']:
        position = faceMatch['Face']['BoundingBox']
        similarity = str(faceMatch['Similarity'])
        print('The face at ' +
              str(position['Left']) + ' ' +
              str(position['Top']) +
              ' matches with ' + similarity + '% confidence')

    imageTarget.close()
    return len(response['FaceMatches'])

bucket = 'bucket-name'
source_file = 'source-file-name'
target_file = 'target-file-name'
region = "region-name"
face_matches = compare_faces(bucket, source_file, target_file, region)
print("Face matches: " + str(face_matches))

if str(face_matches) == "1":
    print("Face match found.")
else:
    print("No face match found.")

Guarde y ejecute el código de procedimiento.

Se le devolverá un objeto de respuesta que contiene información sobre el rostro coincidente y el nivel de confianza.

Llamar a la operación `SearchFacesByImage`

Si el nivel de confianza de la operación CompareFaces es superior al SimilarityThreshold que ha elegido, querrá buscar en su colección un rostro que pueda coincidir con la imagen introducida. Si se encuentra una coincidencia en su colección, significa que es probable que el usuario ya esté registrado en la colección y que no sea necesario registrar un nuevo usuario en la colección. Si no hay ninguna coincidencia, puede registrar al nuevo usuario en su colección.

Comience por escribir el código que invocará la operación SearchFacesByImage. La operación tomará como argumento un archivo de imagen local y, a continuación, buscará en su Collection un rostro que coincida con los rostros más grandes detectados en la imagen proporcionada.

En el siguiente ejemplo de código, cambie el valor de collectionId a la colección en la que desee buscar. Sustituya el valor de region por el nombre de la región asociada a su cuenta. También tendrá que reemplazar el valor de photo por el nombre del archivo de entrada. También querrá especificar un umbral de similitud sustituyendo el valor de threshold por un percentil elegido.


import boto3

collectionId = 'collection-id-name'
region = "region-name"
photo = 'photo-name'
threshold = 99
maxFaces = 1
client = boto3.client('rekognition', region_name=region)

# input image should be local file here, not s3 file
with open(photo, 'rb') as image:
    response = client.search_faces_by_image(CollectionId=collectionId,
    Image={'Bytes': image.read()},
    FaceMatchThreshold=threshold, MaxFaces=maxFaces)

faceMatches = response['FaceMatches']
print(faceMatches)

for match in faceMatches:
    print('FaceId:' + match['Face']['FaceId'])
    print('ImageId:' + match['Face']['ImageId'])
    print('Similarity: ' + "{:.2f}".format(match['Similarity']) + "%")
    print('Confidence: ' + str(match['Face']['Confidence']))

Guarde y ejecute el código de procedimiento. Si ha habido una coincidencia, significa que la persona reconocida en la imagen ya forma parte de la colección y no es necesario continuar con los siguientes pasos. En este caso, solo tiene que permitir que el usuario acceda a la aplicación.

Llamar a la operación `IndexFaces`

Suponiendo que no se haya encontrado ninguna coincidencia en la colección que ha buscado, querrá añadir el rostro del usuario a su colección. Para ello, llame a la operación IndexFaces. Cuando llamas IndexFaces, Amazon Rekognition extrae los rasgos faciales de un rostro identificado en la imagen de entrada y guarda los datos en la colección especificada.

Comience por escribir el código para llamar a IndexFaces. Sustituya el valor image de por el nombre del archivo local que desee utilizar como imagen de entrada para la operación. IndexFaces También tendrá que sustituir el valor de photo_name por el nombre deseado para la imagen de entrada. Asegúrese de reemplazar el valor de collection_id por el ID de la colección que ha creado anteriormente. Después, sustituya el valor de region por el nombre de la región asociada a su cuenta. También querrá especificar un valor para el parámetro de entrada MaxFaces, que define el número máximo de caras de una imagen que se deben indexar. El valor predeterminado para este parámetro es 1.


import boto3

def add_faces_to_collection(target_file, photo, collection_id, region):
    client = boto3.client('rekognition', region_name=region)

    imageTarget = open(target_file, 'rb')

    response = client.index_faces(CollectionId=collection_id,
                                  Image={'Bytes': imageTarget.read()},
                                  ExternalImageId=photo,
                                  MaxFaces=1,
                                  QualityFilter="AUTO",
                                  DetectionAttributes=['ALL'])
    print(response)

    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('  Image ID: {}'.format(faceRecord['Face']['ImageId']))
        print('  External Image ID: {}'.format(faceRecord['Face']['ExternalImageId']))
        print('  Confidence: {}'.format(faceRecord['Face']['Confidence']))

    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'])

image = 'image-file-name'
collection_id = 'collection-id-name'
photo_name = 'desired-image-name'
region = "region-name"

indexed_faces_count = add_faces_to_collection(image, photo_name, collection_id, region)
print("Faces indexed count: " + str(indexed_faces_count))

Guarde y ejecute el código de procedimiento. Determine si desea guardar alguno de los datos devueltos por la operación IndexFaces, como el FaceID asignado a la persona de la imagen. En la siguiente sección se examinará cómo guardar estos datos. Copie los valores FaceId, ImageId y Confidence devueltos antes de continuar.

Guardar y almacenar datos de imagen y de FaceID en Amazon S3 y Amazon DynamoDB

Una vez obtenido el ID de rostro de la imagen de entrada, los datos de la imagen se pueden guardar en Amazon S3, mientras que los datos faciales y la URL de la imagen se pueden introducir en una base de datos como DynamoDB.

Guarde y cargue el código para subir la imagen de entrada en la base de datos de Amazon S3. En el ejemplo de código que aparece a continuación, sustituya el valor de bucket por el nombre del bucket en el que desea subir el archivo y, a continuación, sustituya el valor de file_name por el nombre del archivo local que desea almacenar en su bucket de Amazon S3. Proporcione un nombre clave que identifique el archivo en el bucket de Amazon S3 sustituyendo el valor de key_name por el nombre que desee asignar al archivo de imagen. El archivo que desea cargar es el mismo que se definió en los ejemplos de código anteriores, que es el archivo de entrada que utilizó IndexFaces. Por último, sustituya el valor de region por el nombre de la región asociada a su cuenta.
```
import boto3
import logging
from botocore.exceptions import ClientError

# store local file in S3 bucket
bucket = "amzn-s3-demo-bucket"
file_name = "file-name"
key_name = "key-name"
region = "region-name"
s3 = boto3.client('s3', region_name=region)
# Upload the file
try:
    response = s3.upload_file(file_name, bucket, key_name)
    print("File upload successful!")
except ClientError as e:
    logging.error(e)
```
Guarde y ejecute el ejemplo de código correspondiente para subir la imagen de entrada en Amazon S3.

También querrá guardar el ID de rostro devuelto en una base de datos. Para ello, puede crear una tabla de base de datos de DynamoDB y, a continuación, subir el ID de rostro en esa tabla. En el siguiente ejemplo de código se crea una tabla de DynamoDB. Tenga en cuenta que solo necesita ejecutar el código que crea esta tabla una vez. En el código siguiente, sustituya el valor de region por el valor de la región asociada a su cuenta. También tendrá que sustituir el valor de database_name por el nombre que desee asignar a la tabla de DynamoDB.


import boto3

# Create DynamoDB database with image URL and face data, face ID

def create_dynamodb_table(table_name, region):
    dynamodb = boto3.client("dynamodb", region_name=region)

    table = dynamodb.create_table(
        TableName=table_name,   
        KeySchema=[{
                'AttributeName': 'FaceID', 'KeyType': 'HASH'  # Partition key  
                },],        
            AttributeDefinitions=[
            {
                'AttributeName': 'FaceID', 'AttributeType': 'S'  }, ],        
                ProvisionedThroughput={
            'ReadCapacityUnits': 10, 'WriteCapacityUnits': 10  }
    )
    print(table)
    return table

region = "region-name"
database_name = 'database-name'
dynamodb_table = create_dynamodb_table(database_name, region)
print("Table status:", dynamodb_table)

Guarde y ejecute el código siguiente para crear la tabla.

Tras crear la tabla, puede cargar en ella FaceId lo devuelto. Para ello, deberá establecer una conexión con la tabla con la función Table y, a continuación, utilizar la función put_item para subir los datos.

En el siguiente ejemplo de código, sustituya el valor de bucket por el nombre del bucket que contiene la imagen de entrada que ha subido a Amazon S3. También tendrá que sustituir el valor de file_name por el nombre del archivo de entrada que has subido a su bucket de Amazon S3 y el valor de key_name por la clave que utilizó anteriormente para identificar el archivo de entrada. Por último, sustituya el valor de region por el nombre de la región asociada a su cuenta. Estos valores deben coincidir con los proporcionados en el paso 1.

AddDBEntryAlmacena los valores de confianza FaceId ImageId, y asignados a un rostro de una colección. Proporcione a la siguiente función los valores que guardó durante el paso 2 de la sección IndexFaces anterior.


import boto3
from pprint import pprint
from decimal import Decimal
import json

# The local file that was stored in S3 bucket
bucket = "amzn-s3-demo-bucket"
file_name = "file-name"
key_name = "key-name"
region = "region-name"
# Get URL of file
file_url = "https://s3.amazonaws.com/{}/{}".format(bucket, key_name)
print(file_url)

# upload face-id, face info, and image url
def AddDBEntry(file_name, file_url, face_id, image_id, confidence):
    dynamodb = boto3.resource('dynamodb', region_name=region)
    table = dynamodb.Table('FacesDB-4')
    response = table.put_item(
       Item={
            'ExternalImageID': file_name,
            'ImageURL': file_url,
            'FaceID': face_id,
            'ImageID': image_id, 
            'Confidence': json.loads(json.dumps(confidence), parse_float=Decimal)
       }
    )
    return response

# Mock values for face ID, image ID, and confidence - replace them with actual values from your collection results
dynamodb_resp = AddDBEntry(file_name, file_url, "FACE-ID-HERE",  
    "IMAGE-ID-HERE", confidence-here)
print("Database entry successful.")
pprint(dynamodb_resp, sort_dicts=False)

Guarde y ejecute el ejemplo de código siguiente para almacenar los datos de ID de rostro devueltos en una tabla.

Inicio de sesión de usuario existente

Una vez que un usuario se ha registrado en una colección, se puede autenticar cuando vuelva mediante la operación SearchFacesByImage. Necesitará obtener una imagen de entrada y, a continuación, comprobar la calidad de la imagen de entrada utilizando DetectFaces. Esto determina si se ha utilizado una imagen adecuada antes de ejecutar la operación SearchFacesbyImage.

Llame a la DetectFaces operación

Utilizará la operación DetectFaces para comprobar la calidad de la imagen del rostro y determinar si una imagen capturada por la cámara es adecuada para ser procesada por la operación SearchFacesByImage. La imagen de entrada debe contener solo un rostro. En el siguiente ejemplo de código se toma una imagen de entrada que se proporciona a la operación DetectFaces.

En el siguiente ejemplo de código, sustituya el valor de photo por el nombre de la imagen de destino local y sustituya el valor de region por el nombre de la región asociada a su cuenta.


import boto3
import json

def detect_faces(target_file, region):

    client=boto3.client('rekognition', region_name=region)

    imageTarget = open(target_file, 'rb')

    response = client.detect_faces(Image={'Bytes': imageTarget.read()}, 
    Attributes=['ALL'])

    print('Detected faces for ' + photo)
    for faceDetail in response['FaceDetails']:
        print('The detected face is between ' + str(faceDetail['AgeRange']['Low'])
              + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old')

        print('Here are the other attributes:')
        print(json.dumps(faceDetail, indent=4, sort_keys=True))

        # Access predictions for individual face details and print them
        print("Gender: " + str(faceDetail['Gender']))
        print("Smile: " + str(faceDetail['Smile']))
        print("Eyeglasses: " + str(faceDetail['Eyeglasses']))
        print("Emotions: " + str(faceDetail['Emotions'][0]))

    return len(response['FaceDetails'])

photo = 'photo-name'
region = 'region-name'
face_count=detect_faces(photo, region)
print("Faces detected: " + str(face_count))

if face_count == 1:
    print("Image suitable for use in collection.")
else:
    print("Please submit an image with only one face.")

Guarde y ejecute el código.

Llama a la SearchFacesByImage operación

Escriba el código para comparar el rostro detectado con los rostros de la colección con SearchFacesByImage. Utilizará el código que se muestra en la siguiente sección de registro de nuevos usuarios y proporcionará la imagen de entrada para la operación SearchFacesByImage.

En el siguiente ejemplo de código, cambie el valor de collectionId por la colección en la que desee buscar. También cambiará el valor de bucket por el nombre de un bucket de Amazon S3 y el valor de fileName por un archivo de imagen de ese bucket. Sustituya el valor de region por el nombre de la región asociada a su cuenta. También querrá especificar un umbral de similitud sustituyendo el valor de threshold por un percentil elegido.
```
import boto3

bucket = 'amzn-s3-demo-bucket'
collectionId = 'collection-id-name'
region = "region-name"
fileName = 'file-name'
threshold = 70
maxFaces = 1
client = boto3.client('rekognition', region_name=region)

# input image should be local file here, not s3 file
with open(fileName, 'rb') as image:
    response = client.search_faces_by_image(CollectionId=collectionId,
    Image={'Bytes': image.read()},
    FaceMatchThreshold=threshold, MaxFaces=maxFaces)
```
Guarde y ejecute el código.

Comprobar el FaceId devuelto y el nivel de confianza

Ahora puede comprobar la información sobre las coincidencias FaceId imprimiendo elementos de respuesta como los FaceId atributos de similitud y confianza.


faceMatches = response['FaceMatches']
print(faceMatches)

for match in faceMatches:
    print('FaceId:' + match['Face']['FaceId'])
    print('ImageId:' + match['Face']['ImageId'])
    print('Similarity: ' + "{:.2f}".format(match['Similarity']) + "%")
    print('Confidence: ' + str(match['Face']['Confidence']))

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación de una función de Lambda de Amazon Rekognition

Uso de Amazon Rekognition (REK) para detectar etiquetas de aplicaciones de marketing