Prerequisiti Creazione di una raccolta Registrazione di un nuovo utente Accesso utente esistente

Utilizzo di Amazon Rekognition per la verifica dell'identità

Amazon Rekognition offre agli utenti diverse operazioni che consentono la semplice creazione di sistemi di verifica dell'identità. Amazon Rekognition consente all'utente di rilevare i volti in un'immagine e quindi confrontare i volti rilevati con altri volti confrontando i dati dei volti. Questi dati relativi ai volti vengono archiviati in container lato server denominati Raccolte. Sfruttando le operazioni di riconoscimento facciale, confronto facciale e gestione delle raccolte di Amazon Rekognition, puoi creare un'applicazione con una soluzione di verifica dell'identità.

Questo tutorial illustrerà due flussi di lavoro comuni per la creazione di applicazioni che richiedono la verifica dell'identità.

Il primo flusso di lavoro prevede la registrazione di un nuovo utente in una raccolta. Il secondo flusso di lavoro prevede la ricerca di una raccolta esistente allo scopo di accedere a un utente abituale.

Utilizzerai l'AWS SDK per Python per questo tutorial. Puoi anche vedere il GitHub repository degli esempi di AWS Documentation SDK per altri tutorial su Python.

Prerequisiti

Prima di iniziare questo tutorial, devi installare Python e completare i passaggi necessari per configurare Python SDK. AWS Oltre a ciò, assicurati di:

Aver creato un account AWS e un ruolo IAM
Aver installato l'SDK Python (Boto3)
Hai configurato correttamente le tue credenziali di accesso AWS
Aver creato un bucket Amazon Simple Storage Service e caricato un'immagine che desideri utilizzare come ID ai fini della verifica dell'identità.
Aver selezionato una seconda immagine da utilizzare come immagine di destinazione per la verifica dell'identità.

Creazione di una raccolta

Prima di poter registrare un nuovo utente o cercare un utente in una raccolta, è necessario disporre di una raccolta su cui lavorare. Una raccolta Amazon Rekognition è un container lato server utilizzato per archiviare informazioni sui volti rilevati.

Creazione della raccolta

Inizierai scrivendo una funzione che crei una raccolta da utilizzare con la tua applicazione. Amazon Rekognition archivia le informazioni sui volti rilevati in un container lato server chiamato Raccolte. Puoi cercare volti noti nelle informazioni sui volti archiviate in una raccolta. Per memorizzare le informazioni sul volto, devi prima creare una raccolta utilizzando l'operazione CreateCollection.

Scegli un nome per la raccolta da creare. Nel codice seguente, sostituisci il valore di collection_id con il nome della raccolta che desideri creare e sostituisci il valore di region con il nome della regione definita nelle credenziali utente. Puoi usare l'argomento Tags per applicare tutti i tag che desideri alla raccolta, sebbene ciò non sia obbligatorio. L'operazione CreateCollection restituirà informazioni sulla raccolta che hai creato, incluso il relativo Arn. Prendi nota dell'Arn che ricevi come risultato dell'esecuzione del codice.


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)

Salva ed esegui il codice. Copia l'Arn della raccolta.

Ora che la raccolta Rekognition è stata creata, puoi memorizzare informazioni facciali e identificatori in quella raccolta. Potrai anche confrontare i volti con le informazioni memorizzate a scopo di verifica.

Registrazione di un nuovo utente

Ti consigliamo di poter registrare nuovi utenti e aggiungere le loro informazioni a una raccolta. Il processo di registrazione di un nuovo utente prevede in genere i seguenti passaggi:

Richiama l'operazione `DetectFaces`

Scrivi il codice per verificare la qualità dell'immagine del volto tramite l'operazione DetectFaces. Utilizzerai l'operazione DetectFaces per determinare se un'immagine catturata dalla fotocamera è adatta per l'elaborazione da parte dell'operazione SearchFacesByImage. L'immagine deve contenere solo un volto. Fornirai un file di immagine di input locale all'operazione DetectFaces e riceverai i dettagli per i volti rilevati nell'immagine. Il codice di esempio seguente fornisce l'immagine di input a DetectFaces e quindi verifica se nell'immagine è stato rilevato solo un volto.

Nel seguente esempio di codice, sostituisci photo con il nome dell'immagine di destinazione in cui desideri rilevare i volti. Dovrai anche sostituire il valore di region con il nome della regione associata al tuo account.


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

Salva ed esegui il codice in corso.

Richiama l'operazione `CompareFaces`

L'applicazione dovrà essere in grado di registrare nuovi utenti in una raccolta e confermare l'identità degli utenti abituali. Creerai prima le funzioni utilizzate per registrare un nuovo utente. Inizierai utilizzando l'CompareFacesoperazione per confrontare un'input/target image of the user and a ID/storedimmagine locale. Se viene rilevata una corrispondenza tra il volto in entrambe le immagini, puoi cercare nella raccolta per vedere se l'utente è registrato.

Inizia scrivendo una funzione che confronti un'immagine di input con l'immagine ID che hai archiviato nel tuo bucket Amazon S3. Nel seguente esempio di codice, dovrai fornire tu stesso l'immagine di input, che dovrebbe essere acquisita dopo aver utilizzato una qualche forma di rilevatore di vivacità. Dovrai anche passare il nome di un'immagine archiviata nel bucket Amazon S3.

Sostituisci il valore di bucket con il nome del bucket Amazon S3 che contiene il file sorgente. Dovrai inoltre sostituire il valore di source_file con il nome dell'immagine sorgente che stai utilizzando. Sostituisci il valore di target_file con il nome del file di destinazione che hai fornito. Sostituisci il valore di region con il nome della region definita nelle credenziali utente.

Per specificare il livello minimo di affidabilità della corrispondenza che desideri ottenere nella risposta, utilizza similarityThreshold nella richiesta. I volti rilevati verranno restituiti nell'array FaceMatches solo se la confidenza è superiore a questa soglia. La scelta similarityThreshold deve riflettere la natura del processo di utilizzo specifico. Qualsiasi caso d'uso che coinvolga applicazioni di sicurezza critiche deve utilizzare 99 come soglia selezionata.


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

Salva ed esegui il codice in corso.

Ti verrà restituito un oggetto di risposta contenente informazioni sul volto corrispondente e sul livello di confidenza.

Richiama l'operazione `SearchFacesByImage`

Se il livello di confidenza dell'operazione CompareFaces è superiore a quello scelto SimilarityThreshold, ti consigliamo di cercare nella raccolta un volto che potrebbe corrispondere all'immagine di input. Se viene trovata una corrispondenza nella tua raccolta, significa che probabilmente l'utente è già registrato in essa e non è necessario registrare un nuovo utente nella raccolta. Se non c'è nessuna corrispondenza, puoi registrare il nuovo utente nella raccolta.

Inizia scrivendo il codice che richiamerà l'operazione SearchFacesByImage. L'operazione prenderà come argomento un file di immagine locale e quindi cercherà un volto che corrisponda ai Collection volti più grandi rilevati nell'immagine fornita.

Nel seguente esempio di codice, modifica il valore di collectionId nella raccolta in cui desideri cercare. Sostituisci il valore di region con il nome della regione associata al tuo account. Dovrai inoltre sostituire il valore di photo con il nome del file di input. Dovrai anche specificare una soglia di somiglianza sostituendo il valore di threshold con un percentile scelto.


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

Salva ed esegui il codice in corso. Se c'è stata una corrispondenza, significa che la persona riconosciuta nell'immagine fa già parte della raccolta e non è necessario passare ai passaggi successivi. In questo caso, puoi semplicemente consentire all'utente di accedere all'applicazione.

Richiama l'operazione `IndexFaces`

Supponendo che non sia stata trovata alcuna corrispondenza nella raccolta che hai cercato, ti consigliamo di aggiungere il volto dell'utente alla tua raccolta. Puoi farlo chiamando l'operazione IndexFaces. Quando chiami IndexFaces, Amazon Rekognition estrae i tratti del viso di un volto identificato nell'immagine di input, archiviando i dati nella raccolta specificata.

Inizia scrivendo il codice per chiamare IndexFaces. Sostituisci il valore di image con il nome del file locale che desideri utilizzare come immagine di input per l'operazione. IndexFaces Dovrai inoltre sostituire il valore di photo_name con il nome desiderato per l’immagine di input. Assicurati di sostituire il valore di collection_id con l’IDE della raccolta creata in precedenza. Poi, sostituisci il valore di region con il nome della regione associata al tuo account. Dovrai anche specificare un valore per il parametro MaxFaces di input, che definisce il numero massimo di volti in un'immagine che devono essere indicizzati. Il valore predefinito per questo parametro è 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))

Salva ed esegui il codice in corso. Determina se desideri salvare i dati restituiti dall'operazione IndexFaces, ad esempio il FaceID assegnato alla persona nell'immagine. La prossima sezione esaminerà come salvare questi dati. Copia i valori restituiti FaceId, ImageId e Confidence prima di procedere.

Salva immagini e dati FaceID in Amazon S3 e Amazon DynamoDB

Una volta ottenuto il Face ID per l'immagine di input, i dati dell'immagine possono essere salvati in Amazon S3, mentre i dati del volto e l'URL dell'immagine possono essere inseriti in un database come DynamoDB.

Scrivi il codice per caricare l'immagine di input nel database Amazon S3. Nell'esempio di codice che segue, sostituisci il valore di bucket con il nome del bucket in cui desideri caricare il file, quindi sostituisci il valore di file_name con il nome del file locale che desideri archiviare nel tuo bucket Amazon S3. Fornisci un nome chiave che identifichi il file nel bucket Amazon S3 sostituendo il valore di key_name con un nome che desideri assegnare al file di immagine. Il file da caricare è lo stesso definito negli esempi di codice precedenti, ovvero il file di input per cui è stato utilizzato IndexFaces. Infine, sostituisci il valore di region con il nome della regione associata al tuo account.
```
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)
```
Salva ed esegui il seguente esempio di codice per caricare l'immagine di input su Amazon S3.

Ti consigliamo di salvare anche il Face ID restituito in un database. Questo può essere fatto creando una tabella di database DynamoDB e quindi caricando il Face ID su quella tabella. Nell'esempio di codice seguente viene creata una tabella DynamoDB. Nota che devi eseguire il codice che crea questa tabella solo una volta. Nel codice seguente, sostituisci il valore di region con il valore della regione associata al tuo account. Dovrai anche sostituire il valore di database_name con il nome che desideri assegnare alla tabella 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)

Salva ed esegui il codice procedente per creare la tua tabella.

Dopo aver creato la tabella, puoi FaceId caricarvi i dati restituiti. Per fare ciò, stabilirai una connessione alla tabella con la funzione Tabella e quindi utilizzerai la funzione put_item per caricare i dati.

Nel seguente esempio di codice, sostituisci il valore di bucket con il nome del bucket contenente l'immagine di input che hai caricato su Amazon S3. Dovrai inoltre sostituire il valore di file_name con il nome del file di input che hai caricato nel tuo bucket Amazon S3 e il valore di key_name con la chiave che hai usato in precedenza per identificare il file di input. Infine, sostituisci il valore di region con il nome della regione associata al tuo account. Questi valori devono corrispondere a quelli forniti nel passaggio 1.

AddDBEntryMemorizza i valori FaceId ImageId, e Confidence assegnati a un volto in una raccolta. Fornisci alla funzione seguente i valori che hai salvato durante la fase 2 della sezione successiva IndexFaces.


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)

Salva ed esegui l'esempio di codice procedente per memorizzare i dati Face ID restituiti in una tabella.

Accesso utente esistente

Dopo che un utente è stato registrato in una raccolta, può essere autenticato al suo ritorno utilizzando l'operazione SearchFacesByImage. È necessario ottenere un'immagine di input e quindi verificare la qualità dell'immagine di input utilizzata DetectFaces. Ciò determina se è stata utilizzata un'immagine adatta prima di eseguire l'operazione SearchFacesbyImage.

Chiama l' DetectFaces operazione

Utilizzerai l'operazione DetectFaces per controllare la qualità dell’immagine del volto e determinare se un'immagine catturata dalla fotocamera è adatta per l'elaborazione da parte dell'operazione SearchFacesByImage. L'immagine deve contenere solo un volto. Il seguente esempio di codice prende un'immagine di input e la fornisce all'operazione DetectFaces.

Nell'esempio di codice seguente, sostituisci il valore di photo con il nome dell’immagine di destinazione e sostituisci il valore di region con il nome della regione associata al tuo account.


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

Salva ed esegui il codice.

Chiama l' SearchFacesByImage operazione

Scrivi il codice per confrontare il volto rilevato con i volti della raccolta con SearchFacesByImage. Utilizzerai il codice mostrato nella sezione Procedura di registrazione di un nuovo utente e fornirai l'immagine di input per l'operazione SearchFacesByImage.

Nel seguente esempio di codice, modifica il valore di collectionId nella raccolta in cui desideri cercare. Modificherai anche il valore di bucket con il nome di un bucket Amazon S3 e il valore di un file fileName di immagine in quel bucket. Sostituisci il valore di region con il nome della regione associata al tuo account. Dovrai anche specificare una soglia di somiglianza sostituendo il valore di threshold con un percentile scelto.
```
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)
```
Salva ed esegui il codice.

Verifica il FaceID restituito e il livello di confidenza

Ora puoi verificare le informazioni sulla corrispondenza FaceId stampando elementi di risposta come gli FaceId attributi Similarity e Confidence.


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Creazione di una funzione Lambda Amazon Rekognition

Utilizzo di Amazon Rekognition (REK) per rilevare le etichette per le applicazioni di marketing