As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# 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](https://aws.amazon.com/sdk-for-python/) neste tutorial. Você também pode ver o [GitHub repositório](https://github.com/awsdocs/aws-doc-sdk-examples) de exemplos do SDK de AWS documentação para ver mais tutoriais em Python.
**Topics**
+ [Pré-requisitos](#tutorial-prerequisites)
+ [Criar uma coleção](#tutorial-step1)
+ [Registro do novo usuário](#tutorial-step1.3.1)
+ [Login de usuário existente](#tutorial-step1.4)
## 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](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html). AWS Além disso, confira se você:
+ [Criou uma conta na AWS e um perfil do IAM](https://docs.aws.amazon.com/rekognition/latest/dg/setting-up.html)
+ [Instalou o SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/)
+ [Configure corretamente suas credenciais de AWS acesso](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html)
+ [Criou um bucket do Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) 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`.
1. 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)
```
1. 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: Verificar se uma imagem de entrada (normalmente capturada por uma câmera) corresponde a uma imagem de referência usando o comando `CompareFaces`. Neste tutorial, você usará uma imagem local como imagem e a input/target imagem em seu bucket do Amazon S3 como imagem de referência. Pesquise em sua Coleção uma possível correspondência para garantir que o novo usuário não esteja registrado usando o comando `SearchFacesByImage`. Se o usuário ainda não estiver na Coleção, registre a face encontrado na imagem de entrada em sua coleção usando o comando `IndexFaces`. Armazene os dados da imagem de entrada e os dados do `FaceID` no Amazon S3 e no DynamoDB, respectivamente.
### 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.
1. 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.")
```
1. 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 imagem local do usuário e uma ID/stored imagem. 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.
1. 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.")
```
1. 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.
1. 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']))
```
1. 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.
1. 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))
```
1. 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.
1. 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)
```
1. Salve e execute o exemplo de código a seguir para fazer upload da sua imagem de entrada no Amazon S3.
1. 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)
```
1. Salve e execute o código a seguir para criar sua tabela.
1. 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.
`AddDBEntry`Armazena 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)
```
1. 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
1. 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.")
```
1. Salve e execute o código.
### Ligue para a SearchFacesByImage operação
1. 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)
```
1. 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']))
```