Pré-requisitos Criar uma coleção Registro do novo usuário Login de usuário existente

Como usar o Amazon Rekognition para verificação de identidade

O Amazon Rekognition oferece aos usuários várias operações que permitem a criação simples de sistemas de verificação de identidade. O Amazon Rekognition permite que o usuário detecte faces em uma imagem e compare as faces detectadas com outras, comparando dados de faces. Esses dados faciais são armazenados em contêineres ao lado do servidor chamados Coleções. Ao usar as operações de detecção facial, comparação facial e gerenciamento de coleções do Amazon Rekognition, você pode criar um aplicativo com uma solução de verificação de identidade.

Este tutorial demonstrará dois fluxos de trabalho comuns para a criação de aplicativos que exigem verificação de identidade.

O primeiro fluxo de trabalho envolve o registro de um novo usuário em uma coleção. O segundo fluxo de trabalho envolve a pesquisa em uma coleção que já existe para registrar um usuário retornado.

Você usará o AWS SDK para Python neste tutorial. Você também pode ver o GitHub repositório de exemplos do SDK de AWS documentação para ver mais tutoriais em Python.

Pré-requisitos

Antes de começar este tutorial, você precisará instalar o Python e concluir as etapas necessárias para configurar o SDK do Python. AWS Além disso, confira se você:

Criou uma conta na AWS e um perfil do IAM
Instalou o SDK para Python (Boto3)
Configure corretamente suas credenciais de AWS acesso
Criou um bucket do Amazon Simple Storage Service e fez o upload da imagem que você quer usar como ID para a verificação de identidade.
Selecionei uma segunda imagem como imagem de destino para a verificação de identidade.

Criar uma coleção

Antes de registrar ou pesquisar um usuário em uma Coleção, você precisa ter uma Coleção para trabalhar. Uma coleção do Amazon Rekognition é um contêiner do lado do servidor usado para armazenar informações sobre as faces detectadas.

Criar a coleção

Você começará escrevendo uma função que cria uma coleção para ser usada pelo seu aplicativo. O Amazon Rekognition armazena informações sobre as faces detectadas em contêineres do lado do servidor chamados Coleções. Você pode pesquisar informações armazenadas em uma Coleção para encontrar as faces conhecidas. Para armazenar informações de daces, primeiro é necessário criar uma coleção usando a operação CreateCollection.

Selecione um nome para a coleção que você deseja criar. No código a seguir, substitua o valor de collection_id pelo nome da coleção que você deseja criar e substitua o valor de region pelo nome da região definida nas suas credenciais de usuário. Você pode usar o argumento Tags para aplicar as tags que quiser à coleção, embora isso não seja obrigatório. A operação CreateCollection retornará informações sobre a coleção que você criou, incluindo o ARN da coleção. Anote o Arn recebido como resultado da execução do 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)

Salve e execute o código. Copie o Arn da coleção.

Agora que a Coleção do Rekognition foi criada, você pode armazenar informações e identificadores faciais nessa Coleção. Você também poderá comparar as faces com as informações armazenadas para verificação.

Registro do novo usuário

Agora, você pode registrar novos usuários e adicionar suas informações a uma coleção. O processo de registro de um novo usuário normalmente envolve as seguintes etapas:

Chame a operação `DetectFaces`

Escreva o código para verificar a qualidade da imagem da face por meio da operação DetectFaces. Você usará a operação DetectFaces para determinar se uma imagem capturada pela câmera é adequada para ser processada pela operação SearchFacesByImage. A imagem deve conter apenas uma face. Você fornecerá um arquivo de imagem de entrada local para a operação DetectFaces e receberá detalhes das faces detectadas na imagem. O código de exemplo a seguir indica a imagem de entrada para DetectFaces e, em seguida, verifica se apenas uma face foi detectada na imagem.

No exemplo de código a seguir, substitua photo pelo nome da imagem de destino que detectará as faces. Você também precisará substituir o valor de region pelo nome da região associada à sua conta.


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.")

Salve o código e o execute.

Chame a operação `CompareFaces`

Seu aplicativo precisará registrar novos usuários em uma coleção e confirmar a identidade dos usuários retornados. Primeiro, você criará as funções usadas para registrar um novo usuário. Você começará usando a CompareFaces operação para comparar uma input/target image of the user and a ID/stored imagem local. Se houver uma correspondência entre a face detectada nas duas imagens, você pode pesquisar na Coleção para ver se o usuário foi registrado com ela.

Comece escrevendo uma função que compara uma imagem de entrada com a imagem de ID que você armazenou em seu bucket do Amazon S3. No exemplo de código a seguir, você mesmo precisará fornecer a imagem de entrada, que deve ser capturada após o uso de alguma forma de detector de vivacidade. Você também precisará passar o nome de uma imagem armazenada no bucket do Amazon S3.

Substitua o valor de bucket pelo nome do bucket do Amazon S3 que contém o arquivo de origem. Você também precisará substituir o valor de source_file pelo nome da imagem de origem que você está usando. Substitua o valor de target_file pelo nome do arquivo de destino que você informou. Substitua o valor de region pelo nome de region definido nas credenciais de usuário.

Você também deve especificar um nível mínimo de confiança na correspondência que é retornada na resposta, usando o argumento similarityThreshold. As faces detectadas só serão retornadas na matriz FaceMatches se a confiança estiver acima desse limite. Sua escolha de similarityThreshold deve refletir a natureza de seu caso de uso específico. Qualquer caso de uso que envolva aplicativos críticos de segurança deve usar 99 como o limite selecionado.


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.")

Salve o código e o execute.

Você receberá um objeto de resposta contendo informações sobre a face correspondente e o nível de confiança.

Chame a operação `SearchFacesByImage`

Se o nível de confiança da operação CompareFaces estiver acima do SimilarityThreshold escolhido, você deve pesquisar em sua coleção um rosto que possa corresponder à imagem de entrada. Se uma correspondência for encontrada em sua coleção, isso significa que o usuário provavelmente já está registrado na Coleção e não há necessidade de registrar um novo usuário. Se não houver uma correspondência, você pode registrar o novo usuário em sua Coleção.

Comece escrevendo o código que invocará a operação SearchFacesByImage. A operação receberá um arquivo de imagem local como argumento e, em seguida, pesquisará em Collection uma face que corresponda às principais faces detectadas na imagem fornecida.

No exemplo de código a seguir, altere o valor de collectionId para a Coleção que você deseja pesquisar. Substitua o valor de region pelo nome da região associada à sua conta. Você também precisará substituir o valor de photo pelo nome do seu arquivo de entrada. Especifique um limite de similaridade substituindo o valor de por uma porcentagem do threshold escolhido.


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

Salve o código e o execute. Se houver uma correspondência, isso significa que a pessoa reconhecida na imagem já faz parte da Coleção e não há necessidade de passar para as próximas etapas. Nesse caso, você pode simplesmente permitir que o usuário acesse o aplicativo.

Chame a operação `IndexFaces`

Supondo que nenhuma correspondência tenha sido encontrada na Coleção pesquisada, você precisará adicionar a face do usuário à sua coleção. Faça isso chamando a operação IndexFaces. Quando você liga IndexFaces, o Amazon Rekognition extrai as características faciais de um rosto identificado na sua imagem de entrada, armazenando os dados na coleção especificada.

Comece escrevendo o código para chamar a operação IndexFaces. Substitua o valor de image pelo nome do arquivo local que você deseja usar como imagem de entrada para a IndexFaces operação. Você também precisará substituir o valor de photo_name pelo nome do arquivo de entrada. Substitua o valor de collection_id pelo ID da coleção que você criou anteriormente. Em seguida, substitua o valor de region pelo nome da região associada à sua conta. Especifique um valor para o parâmetro de entrada MaxFaces, que define o número máximo de faces que devem ser indexadas em uma imagem. O valor padrão desse parâmetro é 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))

Salve o código e o execute. Determine se você gostaria de salvar algum dos dados retornados pela operação IndexFaces, como o FaceID atribuído à pessoa na imagem. A próxima seção explicará como salvar esses dados. Antes de continuar, copie os valores FaceId, ImageId e Confidence retornados.

Armazene dados de imagem e FaceID no Amazon S3 e no Amazon DynamoDB

Após obter o Face ID para a imagem de entrada, os dados da imagem podem ser salvos no Amazon S3, enquanto os dados da face e o URL da imagem podem ser inseridos em um banco de dados como o DynamoDB.

Escreva o código para fazer upload da imagem de entrada para o banco de dados do Amazon S3. No exemplo de código a seguir, substitua o valor de bucket pelo nome do bucket em que será feito o upload do arquivo e, em seguida, substitua o valor de file_name pelo nome do arquivo local que armazenará o bucket do Amazon S3. Forneça um nome de chave que identificará o arquivo no bucket do Amazon S3 substituindo o valor de key_name por um nome que você gostaria de dar ao arquivo de imagem. O arquivo que você deseja carregar é o mesmo que foi definido nas amostras de código anteriores, que é o arquivo de entrada usado IndexFaces. Por fim, substitua o valor de region pelo nome da região associada à sua conta.
```
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)
```
Salve e execute o exemplo de código a seguir para fazer upload da sua imagem de entrada no Amazon S3.

Salve o Face ID retornado em um banco de dados. Isso pode ser feito criando uma tabela de banco de dados DynamoDB e, em seguida, fazendo o upload do Face ID para essa tabela. O exemplo de código a seguir cria uma tabela do DynamoDB. Observe que você só precisa executar o código que cria essa tabela uma vez. No código a seguir, substitua o valor de region pelo valor da região associada à sua conta. Você também precisará substituir o valor de database_name pelo nome que gostaria de dar à tabela do 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)

Salve e execute o código a seguir para criar sua tabela.

Depois de criar a tabela, você pode fazer o upload da tabela retornada FaceId para ela. Para fazer isso, você estabelecerá uma conexão com a tabela usando a função Table e, em seguida, usará a função put_item para fazer upload dos dados.

No exemplo de código a seguir, substitua o valor de bucket pelo nome do bucket que contém a imagem de entrada que você fez upload no Amazon S3. Substitua o valor de file_name pelo nome do arquivo de entrada carregado no bucket do Amazon S3 e o valor de pela key_name chave usada anteriormente para identificar o arquivo de entrada. Por fim, substitua o valor de region pelo nome da região associada à sua conta. Esses valores devem corresponder aos informados na etapa 1.

AddDBEntryArmazena os valores FaceId, ImageId, e de confiança atribuídos a um rosto em uma coleção. Informe os valores que você salvou na Etapa 2 da seção IndexFaces do processo na função abaixo.


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)

Salve e execute o exemplo de código a seguir para armazenar os dados do Face ID retornados em uma tabela.

Login de usuário existente

Depois que um usuário é registrado em uma Coleção, é possível autenticá-lo usando a operação SearchFacesByImage quando ele retornar. Para isso, basta obter uma imagem de entrada e verificar a qualidade dela usando DetectFaces. Esse procedimento verifica se uma imagem adequada foi usada antes de executar a operação SearchFacesbyImage.

Ligue para a DetectFaces operação

Você usará a operação DetectFaces para definir se uma imagem capturada pela câmera é adequada para ser processada pela operação SearchFacesByImage. A imagem de entrada deve conter apenas uma face. O exemplo de código a seguir recebe uma imagem de entrada e a envia para a operação DetectFaces.

No exemplo de código a seguir, substitua o valor de photo pelo nome da imagem de destino local e substitua o valor de region pelo nome da região associada à sua conta.


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.")

Salve e execute o código.

Ligue para a SearchFacesByImage operação

Escreva o código para comparar a face detectada com as faces da Coleção com SearchFacesByImage. A seguir, você usará o código mostrado na seção Registro de novo usuário, indicando a imagem de entrada para a operação SearchFacesByImage.

No exemplo de código a seguir, altere o valor de collectionId para a Coleção que deverá ser pesquisada. Altere o valor de bucket para o nome de um bucket do Amazon S3 e o valor de fileName para um arquivo de imagem nesse bucket. Substitua o valor de region pelo nome da região associada à sua conta. Especifique um limite de similaridade substituindo o valor de por uma porcentagem do threshold escolhido.
```
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)
```
Salve e execute o código.

Verificar o FaceID retornado e o nível de confiança

Agora você pode verificar as informações sobre a correspondência FaceId imprimindo elementos de resposta FaceId, como os atributos Similaridade e Confiança.


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criar uma função do Amazon Rekognition Lambda

Usar o Amazon Rekognition (REK) para detectar rótulos para aplicativos de marketing