Prérequis Création d’une collection Enregistrement d’un nouvel utilisateur Connexion utilisateur existante

Utilisation d’Amazon Rekognition pour la vérification d’identité

Amazon Rekognition propose aux utilisateurs plusieurs opérations qui permettent de créer facilement des systèmes de vérification d’identité. Amazon Rekognition permet à l’utilisateur de détecter des visages sur une image, puis de les comparer à d’autres visages en confrontant les données faciales. Ces données faciales sont stockées dans des conteneurs côté serveur appelés collections. En utilisant les opérations de détection des visages, de comparaison des visages et de gestion des collections d’Amazon Rekognition, vous pouvez créer une application avec une solution de vérification d’identité.

Ce didacticiel présente deux flux de travail courants pour la création d’applications nécessitant une vérification d’identité.

Le premier flux de travail implique l’enregistrement d’un nouvel utilisateur dans une collection. Le deuxième flux de travail consiste à rechercher une collection existante dans le but de connecter un utilisateur récurrent.

Vous allez utiliser l’AWS SDK pour Python dans ce didacticiel. Vous pouvez également consulter le GitHub référentiel d'exemples du SDK de AWS documentation pour d'autres didacticiels Python.

Prérequis

Avant de commencer ce didacticiel, vous devez installer Python et suivre les étapes requises pour configurer le AWS SDK Python. En outre, vérifiez que vous avez effectué les opérations suivantes :

Création d’un compte AWS et d’un rôle IAM
Installation de SDK Python (Boto3)
Configurez correctement vos informations d' AWS accès
Création d’un compartiment Amazon Simple Storage Service et téléchargement d’une image que vous souhaitez utiliser comme identifiant à des fins de vérification d’identité.
Sélection d’une deuxième image servant d’image cible pour la vérification d’identité.

Création d’une collection

Avant de pouvoir enregistrer ou rechercher un nouvel utilisateur dans une collection, vous devez disposer d’une collection avec laquelle travailler. Une collection Amazon Rekognition est un conteneur côté serveur qui sert à stocker des informations sur les visages détectés.

Création de la collection

Vous allez commencer par écrire une fonction qui crée une collection qu’utilisera votre application. Amazon Rekognition stocke des informations sur les visages détectés dans des conteneurs côté serveur appelés collections. Vous pouvez rechercher des informations faciales stockées dans une collection pour trouver des visages connus. Pour stocker des informations faciales, vous devez d’abord créer une collection à l’aide de l’opération CreateCollection.

Sélectionnez un nom pour la collection que vous souhaitez créer. Dans le code suivant, remplacez la valeur de collection_id par le nom de la collection que vous souhaitez créer, et remplacez la valeur de region par le nom de la région définie dans vos informations d’identification utilisateur. Vous pouvez utiliser l’argument Tags pour appliquer les balises de votre choix à la collection, bien que cela ne soit pas obligatoire. L’opération CreateCollection renvoie des informations sur la collection que vous avez créée, y compris l’ARN de la collection. Notez l’ARN que vous recevez à la suite de l’exécution du code.
```
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)
```
Enregistrez et exécutez le code. Copiez l’ARN de la collection.

Maintenant que la collection Rekognition a été créée, vous pouvez y stocker des informations faciales et des identifiants. Vous allez également pouvoir comparer les visages aux informations enregistrées à des fins de vérification.

Enregistrement d’un nouvel utilisateur

Vous devez être en mesure d’enregistrer de nouveaux utilisateurs et d’ajouter leurs informations à une collection. Le processus d’enregistrement d’un nouvel utilisateur implique généralement les étapes suivantes :

Appelez l’opération `DetectFaces`

Écrivez le code pour vérifier la qualité de l’image du visage via l’opération DetectFaces. Vous allez utiliser cette opération DetectFaces pour déterminer si une image capturée par l’appareil photo peut être traitée par l’opération SearchFacesByImage. L’image ne doit contenir qu’un seul visage. Vous fournissez un fichier image d’entrée local à l’opération DetectFaces et recevez des informations sur les visages détectés sur l’image. L’exemple de code suivant fournit l’image d’entrée à DetectFaces puis vérifie si un seul visage a été détecté dans l’image.

Dans l’exemple de code suivant, remplacez photo par le nom de l’image cible dans laquelle vous souhaitez détecter des visages. Vous devez aussi remplacer la valeur de region par le nom de la région d’exploitation associée à votre compte.


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

Enregistrez, puis exécutez le code suivant.

Appelez l’opération `CompareFaces`.

Votre application doit être en mesure d’enregistrer de nouveaux utilisateurs dans une collection et de confirmer l’identité des utilisateurs récurrents. Vous allez d’abord créer les fonctions qui servent à enregistrer un nouvel utilisateur. Vous allez commencer par utiliser cette CompareFaces opération pour comparer une input/target image of the user and a ID/stored image locale. S’il existe une correspondance entre le visage détecté sur les deux images, vous pouvez effectuer une recherche dans la collection pour voir si l’utilisateur y est enregistré.

Commencez par écrire une fonction qui compare une image d’entrée à l’image d’identification que vous avez stockée dans votre compartiment Amazon S3. Dans l’exemple de code suivant, vous devez fournir vous-même l’image d’entrée, qui doit être capturée après l’utilisation d’un type de détecteur de vivacité. Vous devez également transmettre le nom d’une image stockée dans votre compartiment Amazon S3.

Remplacez la valeur de bucket par le nom du compartiment Amazon S3 qui contient votre fichier source. Vous devez également remplacer la valeur de source_file par le nom de l’image source que vous utilisez. Remplacez la valeur de target_file par le nom du fichier cible que vous avez fourni. Remplacez la valeur de region par le nom de la region définie dans vos informations d’identification utilisateur.

Vous devez également spécifier le niveau minimal de fiabilité de la correspondance que vous souhaitez voir incluse dans la réponse à l’aide de l’argument similarityThreshold. Les visages détectés ne sont renvoyés dans le tableau FaceMatches que si le niveau de confiance est supérieur à ce seuil. Votre choix similarityThreshold doit refléter la nature de votre cas d’utilisation spécifique. Tout cas d’utilisation impliquant des applications de sécurité critiques doit utiliser 99 comme seuil sélectionné.


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

Enregistrez, puis exécutez le code suivant.

Vous recevez un objet de réponse contenant des informations sur le visage correspondant et le niveau de confiance.

Appelez l’opération `SearchFacesByImage`.

Si le niveau de confiance de l’opération CompareFaces est supérieur au SimilarityThreshold que vous avez choisi, vous devez rechercher dans votre collection un visage susceptible de correspondre à l’image d’entrée. Si une correspondance est trouvée dans votre collection, cela signifie que l’utilisateur est probablement déjà enregistré dans la collection, et qu’il n’est pas nécessaire d’enregistrer un nouvel utilisateur dans votre collection. S’il n’y a pas de correspondance, vous pouvez enregistrer le nouvel utilisateur dans votre collection.

Commencez par écrire le code invoquant l’opération SearchFacesByImage. L’opération prend un fichier image local comme argument, puis recherche dans votre Collection un visage qui correspond aux plus grands visages détectés dans l’image fournie.

Dans l’exemple de code suivant, modifiez la valeur collectionId de la collection où vous souhaitez faire la recherche. Remplacez la valeur de region par le nom de la région d’exploitation associée à votre compte. Vous devez également remplacer la valeur de photo par le nom de votre fichier d’entrée. Vous souhaiterez également spécifier un seuil de similarité en remplaçant la valeur de threshold par un percentile choisi.


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

Enregistrez, puis exécutez le code suivant. S’il y a une correspondance, cela signifie que la personne reconnue sur l’image fait déjà partie de la collection, et qu’il n’est pas nécessaire de passer aux étapes suivantes. Dans ce cas, vous pouvez simplement autoriser l’utilisateur à accéder à l’application.

Appelez l’opération `IndexFaces`.

En supposant qu’aucune correspondance n’ait été trouvée dans la collection que vous recherchez, vous souhaitez ajouter le visage de l’utilisateur à votre collection. Vous pouvez le faire en appelant l’opération IndexFaces. Lorsque vous appelez IndexFaces, Amazon Rekognition extrait les traits du visage d'un visage identifié sur votre image d'entrée et stocke les données dans la collection spécifiée.

Commencez par écrire le code à appeler IndexFaces. Remplacez la valeur image de par le nom du fichier local que vous souhaitez utiliser comme image d'entrée pour l' IndexFaces opération. Vous devrez également remplacer la valeur de photo_name par le nom souhaité pour votre image d’entrée. Remplacez la valeur de collection_id par l’ID de la collection que vous avez créée précédemment. Enfin, remplacez la valeur de region par le nom de la région d’exploitation associée à votre compte. Vous avez également besoin de spécifier une valeur pour le paramètre MaxFaces d’entrée, qui définit le nombre maximum de visages à indexer dans une image. La valeur par défaut de ce paramètre est 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))

Enregistrez, puis exécutez le code suivant. Déterminez si vous souhaitez enregistrer les données renvoyées par l’opération IndexFaces, telles que le FaceID attribué à la personne sur l’image. La section suivante examine comment enregistrer ces données. Copiez les valeurs renvoyées FaceId, ImageId et Confidence avant de continuer.

Stockez des données d’image et d’identification faciale dans Amazon S3 et Amazon DynamoDB

Une fois que l’identifiant facial de l’image d’entrée a été obtenu, les données de l’image peuvent être enregistrées dans Amazon S3, tandis que les données faciales et l’URL de l’image peuvent être saisies dans une base de données telle que DynamoDB.

Écrivez le code pour charger l’image d’entrée dans votre base de données Amazon S3. Dans l’exemple de code suivant, remplacez la valeur de bucket par le nom du compartiment dans lequel vous souhaitez télécharger le fichier, puis remplacez la valeur de file_name par le nom du fichier local que vous souhaitez stocker dans votre compartiment Amazon S3. Fournissez un nom de clé qui permettra d’identifier le fichier dans le compartiment Amazon S3 en remplaçant la valeur de key_name par le nom que vous souhaitez donner au fichier image. Le fichier que vous souhaitez télécharger est le même que celui défini dans les exemples de code précédents, à savoir le fichier d'entrée que vous avez utilisé IndexFaces. Enfin, remplacez la valeur de region par le nom de la région d’exploitation associée à votre compte.
```
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)
```
Enregistrez et exécutez l’exemple de code suivant pour télécharger votre image d’entrée sur Amazon S3.

Vous devez également enregistrer l’identifiant facial renvoyé dans une base de données. Pour ce faire, créez un tableau de base de données DynamoDB et téléchargez l’identifiant facial dans ce tableau. L’exemple de code suivant crée un tableau DynamoDB. Notez que vous ne devez exécuter qu’une seule fois le code qui crée ce tableau. Enfin, remplacez la valeur de region par le nom de la région d’exploitation associée à votre compte. Vous devrez également remplacer la valeur de database_name par le nom que vous souhaitez attribuer au tableau 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)

Enregistrez et exécutez le code suivant pour créer votre tableau.

Après avoir créé la table, vous pouvez y télécharger le FaceId contenu renvoyé. Pour ce faire, vous allez établir une connexion au tableau à l’aide de la fonction Tableau, puis utiliser cette fonction put_item pour télécharger les données.

Dans l’exemple de code suivant, remplacez la valeur de bucket par le nom du compartiment contenant l’image d’entrée que vous avez chargée sur Amazon S3. Vous devez également remplacer la valeur de file_name par le nom du fichier d’entrée que vous avez chargé dans votre compartiment Amazon S3, et la valeur de key_name par la clé que vous avez précédemment utilisée pour identifier le fichier d’entrée. Enfin, remplacez la valeur de region par le nom de la région d’exploitation associée à votre compte. Ces valeurs doivent correspondre à celles fournies à l’étape 1.

AddDBEntryStocke les valeurs FaceId ImageId,, et Confidence attribuées à un visage dans une collection. Fournissez à la fonction ci-dessous les valeurs que vous avez enregistrées à l’étape 2 de la section IndexFaces suivante.


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)

Enregistrez et exécutez l’exemple de code suivant pour stocker les données d’identifiant facial renvoyées dans un tableau.

Connexion utilisateur existante

Une fois qu’un utilisateur a été enregistré dans une collection, il peut être authentifié à son retour en utilisant l’opération SearchFacesByImage. Vous devrez obtenir une image d’entrée, puis vérifier la qualité de l’image d’entrée à l’aide de DetectFaces. Cela permet de déterminer si une image appropriée a été utilisée avant d’exécuter l’opération SearchFacesbyImage.

Appelez l' DetectFaces opération

Vous allez utiliser cette opération DetectFaces pour vérifier la qualité de l’image du visage et déterminer si une image capturée par l’appareil photo peut être traitée par l’opération SearchFacesByImage. L’image d’entrée ne doit contenir qu’un seul visage. L’exemple de code suivant prend une image d’entrée et la fournit à l’opération DetectFaces.

Dans l’exemple de code suivant, remplacez la valeur de photo par le nom de l’image cible locale, et remplacez la valeur de region par le nom de la région associée à votre compte.


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

Enregistrez et exécutez le code.

Appelez l' SearchFacesByImage opération

Écrivez le code pour comparer le visage détecté aux visages de la collection avec le SearchFacesByImage. Vous allez utiliser le code affiché dans la section « Enregistrement d’un nouvel utilisateur » et fournir l’image d’entrée pour l’opération SearchFacesByImage.

Dans l’exemple de code suivant, remplacez la valeur de collectionId par la collection où vous souhaitez effectuer la recherche. Vous allez également remplacer la valeur de bucket par le nom d’un compartiment Amazon S3, et la valeur de fileName par un fichier image dans ce compartiment. Enfin, remplacez la valeur de region par le nom de la région d’exploitation associée à votre compte. Vous allez également devoir spécifier un seuil de similarité en remplaçant la valeur de threshold par un percentile choisi.
```
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)
```
Enregistrez et exécutez le code.

Vérifiez l’identifiant facial renvoyé et le niveau de confiance

Vous pouvez désormais vérifier les informations relatives à la correspondance FaceId en imprimant des éléments de réponse tels que FaceId les attributs Similarité et Confiance.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création d’une fonction Lambda Amazon Rekognition

Utilisation d'Amazon Rekognition (REK) pour détecter les étiquettes destinées aux applications marketing