Voraussetzungen Erstellen einer Sammlung Registrierung neuer Benutzer Anmeldung bestehender Benutzer

Amazon Rekognition zur Identitätsprüfung verwenden

Amazon Rekognition bietet Benutzern verschiedene Funktionen, die die einfache Erstellung von Systemen zur Identitätsverifizierung ermöglichen. Amazon Rekognition ermöglicht es dem Benutzer, Gesichter in einem Bild zu erkennen und dann alle erkannten Gesichter mit anderen Gesichtern zu vergleichen, indem Gesichtsdaten verglichen werden. Diese Gesichtsdaten werden in serverseitigen Containern gespeichert, die als Sammlungen bezeichnet werden. Mithilfe der Funktionen Gesichtserkennung, Gesichtsvergleich und Sammlungsverwaltung von Amazon Rekognition können Sie eine Anwendung mit einer Lösung zur Identitätsprüfung erstellen.

In diesem Tutorial werden zwei gängige Workflows für die Erstellung von Anwendungen demonstriert, für die eine Identitätsprüfung erforderlich ist.

Der erste Workflow beinhaltet die Registrierung eines neuen Benutzers in einer Sammlung. Der zweite Workflow beinhaltet das Durchsuchen einer vorhandenen Sammlung, um einen wiederkehrenden Benutzer anzumelden.

Für dieses Tutorial verwenden Sie das AWS -SDK für Python. Weitere Python-Tutorials finden Sie auch im AWS Documentation SDK Examples GitHub Repo.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, müssen Sie Python installieren und die zur Einrichtung des AWS Python-SDK erforderlichen Schritte ausführen. Stellen Sie darüber hinaus sicher, dass Sie über Folgendes verfügen:

Sie haben ein AWS -Konto und eine IAM-Rolle erstellt
Sie haben das Python-SDK (Boto3) installiert
Haben Sie Ihre AWS Zugangsdaten richtig konfiguriert
Sie haben einen Amazon-Simple-Storage-Service-Bucket erstellt und ein Bild hochgeladen, das Sie als ID für die Identitätsprüfung verwenden möchten.
Sie haben ein zweites Bild ausgewählt, das als Zielbild für die Identitätsprüfung dienen soll.

Erstellen einer Sammlung

Bevor Sie einen neuen Benutzer in einer Sammlung registrieren oder in einer Sammlung nach einem Benutzer suchen können, benötigen Sie eine Sammlung, mit der Sie arbeiten können. Eine Amazon-Rekognition-Sammlung ist ein serverseitiger Container, in dem Informationen über erkannte Gesichter gespeichert werden.

Erstellen der Sammlung

Sie beginnen damit, eine Funktion zu schreiben, die eine Sammlung zur Verwendung durch Ihre Anwendung erstellt. Amazon Rekognition speichert Informationen über erkannte Gesichter in serverseitigen Containern namens Sammlungen. Sie können in einer Sammlung gespeicherte Gesichtsinformationen nach bekannten Gesichtern durchsuchen. Um Gesichtsinformationen zu speichern, müssen Sie zunächst mithilfe dieser CreateCollection-Operation eine Sammlung erstellen.

Wählen Sie einen Namen für die Sammlung aus, die Sie erstellen möchten. Ersetzen Sie im folgenden Code den Wert von collection_id durch den Namen der Sammlung, die Sie erstellen möchten, und ersetzen Sie den Wert von region durch den Namen der Region, die in Ihren Benutzeranmeldeinformationen definiert ist. Sie können das Tags-Argument verwenden, um beliebige Tags auf die Sammlung anzuwenden, obwohl dies nicht erforderlich ist. Die CreateCollection-Operation gibt Informationen über die von Ihnen erstellte Sammlung zurück, einschließlich des ARN der Sammlung. Notieren Sie sich den ARN, den Sie als Ergebnis der Ausführung des Codes erhalten.
```
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)
```
Speichern Sie den Code und führen Sie ihn aus. Schreiben Sie den Sammlungs-ARN auf.

Nachdem die Rekognition-Sammlung erstellt wurde, können Sie Gesichtsinformationen und -identifikatoren in dieser Sammlung speichern. Zur Überprüfung können Sie auch Gesichter mit den gespeicherten Informationen vergleichen.

Registrierung neuer Benutzer

Sie sollten in der Lage sein, neue Benutzer zu registrieren und ihre Informationen zu einer Sammlung hinzuzufügen. Die Registrierung eines neuen Benutzers umfasst in der Regel die folgenden Schritte:

Aufrufen der `DetectFaces`-Operation

Schreiben Sie den Code, um die Qualität des Gesichtsbildes während der DetectFaces-Operation zu überprüfen. Mithilfe der DetectFaces-Operation können Sie feststellen, ob ein mit der Kamera aufgenommenes Bild für die Verarbeitung durch die SearchFacesByImage-Operation geeignet ist. Das Bild sollte nur ein Gesicht enthalten. Sie stellen der DetectFaces Operation eine lokale Eingabebilddatei zur Verfügung und erhalten Details zu den im Bild erkannten Gesichtern. Der folgende Beispielcode stellt das Eingabebild an DetectFaces bereit und überprüft dann, ob im Bild nur ein Gesicht erkannt wurde.

Ersetzen Sie im folgenden Codebeispiel photo durch den Namen des Zielbilds, in dem Sie Gesichter erkennen möchten. Außerdem müssen Sie den Wert von region durch den Namen der Region ersetzen, die Ihrem Konto zugeordnet ist.


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

Speichern Sie den nachfolgenden Code und führen Sie ihn aus.

Aufrufen der `CompareFaces`-Operation

Ihre Anwendung muss in der Lage sein, neue Benutzer in einer Sammlung zu registrieren und die Identität wiederkehrender Benutzer zu bestätigen. Sie erstellen zunächst die Funktionen, mit denen ein neuer Benutzer registriert wird. Zunächst verwenden Sie den CompareFaces Vorgang, um ein lokales input/target image of the user and a ID/stored Bild zu vergleichen. Wenn es eine Übereinstimmung zwischen dem auf beiden Bildern erkannten Gesicht gibt, können Sie die Sammlung durchsuchen, um zu sehen, ob der Benutzer darin registriert ist.

Schreiben Sie zunächst eine Funktion, die ein Eingabebild mit dem ID-Bild vergleicht, das Sie in Ihrem Amazon-S3-Bucket gespeichert haben. Im folgenden Codebeispiel müssen Sie das Eingabebild selbst angeben, das nach der Verwendung eines Echtheitsdetektors aufgenommen werden sollte. Sie müssen auch den Namen eines Bildes übergeben, das in Ihrem Amazon-S3-Bucket gespeichert ist.

Ersetzen Sie den Wert von bucket durch den Namen des Amazon-S3-Buckets, der Ihre Quelldatei enthält. Sie müssen auch den Wert von source_file durch den Namen des Quellbilds ersetzen, das Sie verwenden. Ersetzen Sie den Wert von target_file durch den Namen der Zieldatei, die Sie angegeben haben. Ersetzen Sie den Wert von region durch den Namen der region, die in Ihren Benutzeranmeldeinformationen definiert ist.

Sie werden auch eine Mindestwahrscheinlichkeit für die in der Antwort zurückgegebene Übereinstimmung angeben wollen, indem Sie das similarityThreshold-Argument verwenden. Erkannte Gesichter werden im FaceMatches-Array nur zurückgegeben, wenn die Zuverlässigkeit über diesem Schwellenwert liegt. Ihr ausgewählter similarityThreshold sollte die Art Ihres spezifischen Anwendungsfalls widerspiegeln. Für jeden Anwendungsfall, der kritische Sicherheitsanwendungen betrifft, sollte 99 als ausgewählter Schwellenwert verwendet werden.


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

Speichern Sie den nachfolgenden Code und führen Sie ihn aus.

Es wird ein Antwortobjekt zurückgegeben, das Informationen über das übereinstimmende Gesicht und das Zuverlässigkeitsniveau enthält.

Aufrufen der `SearchFacesByImage`-Operation

Wenn das Zuverlässigkeitsniveau der CompareFaces-Operation über dem von Ihnen ausgewählten SimilarityThreshold liegt, sollten Sie Ihre Sammlung nach einem Gesicht durchsuchen, das dem Eingabebild entsprechen könnte. Wenn in Ihrer Sammlung eine Übereinstimmung gefunden wird, bedeutet das, dass der Benutzer wahrscheinlich bereits in der Sammlung registriert ist und es nicht notwendig ist, einen neuen Benutzer in Ihrer Sammlung zu registrieren. Wenn es keine Übereinstimmung gibt, können Sie den neuen Benutzer in Ihrer Sammlung registrieren.

Schreiben Sie zunächst den Code, der die SearchFacesByImage-Operation aufruft. Die Operation verwendet eine lokale Bilddatei als Argument und durchsucht dann Ihre Collection nach einem Gesicht, das den größten erkannten Gesichtern im bereitgestellten Bild entspricht.

Ändern Sie im folgenden Codebeispiel den Wert von collectionId in die Sammlung, nach der Sie suchen möchten. Ersetzen Sie den Wert von region durch den Namen der Region, die Ihrem Konto zugeordnet ist. Sie müssen auch den Wert von photo durch den Namen Ihrer Eingabedatei ersetzen. Sie sollten auch einen Ähnlichkeitsschwellenwert angeben, indem Sie den Wert von threshold durch ein ausgewähltes Perzentil ersetzen.


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

Speichern Sie den nachfolgenden Code und führen Sie ihn aus. Wenn eine Übereinstimmung gefunden wurde, bedeutet dies, dass die Person, die auf dem Bild erkannt wird, bereits Teil der Sammlung ist und Sie nicht mit den nächsten Schritten fortfahren müssen. In diesem Fall können Sie dem Benutzer einfach Zugriff auf die Anwendung gewähren.

Aufrufen der `IndexFaces`-Operation

Unter der Annahme, dass in der von Ihnen gesuchten Sammlung keine Übereinstimmung gefunden wurde, sollten Sie das Gesicht des Benutzers zu Ihrer Sammlung hinzufügen. Sie tun dies, indem Sie die IndexFaces-Operation aufrufen. Wenn Sie anrufen IndexFaces, extrahiert Amazon Rekognition die Gesichtszüge eines Gesichts, das in Ihrem Eingabebild identifiziert wurde, und speichert die Daten in der angegebenen Sammlung.

Schreiben Sie zunächst den Code für den Aufruf von IndexFaces. Ersetzen Sie den Wert von image durch den Namen der lokalen Datei, die Sie als Eingabebild für den IndexFaces Vorgang verwenden möchten. Sie müssen auch den Wert von photo_name durch den gewünschten Namen für Ihr Eingabebild ersetzen. Achten Sie darauf, dass Sie den Wert von collection_id durch die ID der Sammlung ersetzen, die Sie zuvor erstellt haben. Ersetzen Sie dann den Wert von region durch den Namen der Region, die Ihrem Konto zugeordnet ist. Sie sollten auch einen Wert für den MaxFaces-Eingabeparameter angeben, der die maximale Anzahl von Gesichtern in einem Bild definiert, die indexiert werden sollen. Der Standardwert für diesen Parameter ist 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))

Speichern Sie den nachfolgenden Code und führen Sie ihn aus. Stellen Sie fest, ob Sie die durch die IndexFaces-Operation zurückgegebenen Daten speichern möchten, z. B. die Gesichts-ID, die der Person im Bild zugewiesen wurde. Im nächsten Abschnitt wird untersucht, wie diese Daten gespeichert werden. Kopieren Sie die zurückgegebenen FaceId-, ImageId- und Confidence-Werte, bevor Sie fortfahren.

Speichern Sie Bild- und Gesichts–ID-Daten in Amazon S3 und Amazon DynamoDB

Sobald die Gesichts-ID für das Eingabebild abgerufen wurde, können die Bilddaten in Amazon S3 gespeichert werden, während die Gesichtsdaten und die Bild-URL in eine Datenbank wie DynamoDB eingegeben werden können.

Schreiben Sie den Code, um das Eingabebild in Ihre Amazon-S3-Datenbank hochzuladen. Ersetzen Sie im folgenden Codebeispiel den Wert von bucket durch den Namen des Buckets, in den Sie die Datei hochladen möchten, und ersetzen Sie dann den Wert von file_name durch den Namen der lokalen Datei, die Sie in Ihrem Amazon-S3-Bucket speichern möchten. Geben Sie einen Schlüsselnamen an, der die Datei im Amazon-S3-Bucket identifiziert, indem Sie den Wert von key_name durch einen Namen ersetzen, den Sie der Bilddatei geben möchten. Die Datei, die Sie hochladen möchten, ist dieselbe, die in früheren Codebeispielen definiert wurde. Dies ist die Eingabedatei, für die Sie verwendet haben IndexFaces. Ersetzen Sie zum Schluss den Wert von region durch den Namen der Region, die Ihrem Konto zugeordnet ist.
```
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)
```
Speichern Sie das nachfolgende Codebeispiel und führen Sie es aus, um Ihr Eingabebild auf Amazon S3 hochzuladen.

Sie sollten die zurückgegebene Gesichts-ID auch in einer Datenbank speichern. Dies kann erreicht werden, indem eine DynamoDB-Datenbanktabelle erstellt und dann die Gesichts-ID in diese Tabelle hochgeladen wird. Im folgenden Codebeispiel wird eine DynamoDB-Tabelle erstellt. Beachten Sie, dass Sie den Code, der diese Tabelle erstellt, nur einmal ausführen müssen. Ersetzen Sie im folgenden Code den Wert von region durch den Wert der Region, die Ihrem Konto zugeordnet ist. Außerdem müssen Sie den Wert von database_name durch den Namen ersetzen, den Sie der DynamoDB-Tabelle geben möchten.


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)

Speichern Sie den nachfolgenden Code und führen Sie ihn aus, um Ihre Tabelle zu erstellen.

Nachdem Sie die Tabelle erstellt haben, können Sie die FaceId zurückgegebene Datei hochladen. Dazu stellen Sie mit der Tabellenfunktion eine Verbindung zur Tabelle her und verwenden dann die put_item-Funktion, um die Daten hochzuladen.

Ersetzen Sie im folgenden Codebeispiel den Wert von bucket durch den Namen des Buckets, der das Eingabebild enthält, das Sie auf Amazon S3 hochgeladen haben. Außerdem müssen Sie den Wert von file_name durch den Namen der Eingabedatei ersetzen, die Sie in Ihren Amazon-S3-Bucket hochgeladen haben, und den Wert von key_name durch den Schlüssel, den Sie zuvor zur Identifizierung der Eingabedatei verwendet haben. Ersetzen Sie zum Schluss den Wert von region durch den Namen der Region, die Ihrem Konto zugeordnet ist. Diese Werte sollten mit den in Schritt 1 angegebenen Werten übereinstimmen.

AddDBEntryIn werden die Werte FaceId ImageId, und Confidence gespeichert, die einem Gesicht in einer Sammlung zugewiesen wurden. Geben Sie für die unten stehende Funktion die Werte ein, die Sie in Schritt 2 des nächsten IndexFaces-Abschnitts gespeichert haben.


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)

Speichern Sie das nachfolgende Codebeispiel und führen Sie es aus, um die zurückgegebenen Gesichts-ID-Daten in einer Tabelle zu speichern.

Anmeldung bestehender Benutzer

Nachdem ein Benutzer in einer Sammlung registriert wurde, kann er bei seiner Rückkehr mithilfe der SearchFacesByImage-Operation authentifiziert werden. Sie müssen ein Eingabebild abrufen und dann die Qualität des Eingabebilds mithilfe von DetectFaces überprüfen. Dadurch wird festgestellt, ob vor dem Ausführen der SearchFacesbyImage Operation ein geeignetes Bild verwendet wurde.

Rufen Sie die DetectFaces Operation auf

Mit dieser DetectFaces-Operation überprüfen Sie die Qualität des Gesichtsbildes und stellen fest, ob ein mit der Kamera aufgenommenes Bild für die Verarbeitung durch die SearchFacesByImage-Operation geeignet ist. Das Eingabebild sollte nur ein Gesicht enthalten. Im folgenden Codebeispiel wird ein Eingabebild verwendet und für die DetectFaces-Operation bereitgestellt.

Ersetzen Sie im folgenden Codebeispiel den Wert von photo durch den Namen des lokalen Zielbilds und ersetzen Sie den Wert von region durch den Namen der Region, die Ihrem Konto zugeordnet ist.


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

Speichern Sie den Code und führen Sie ihn aus.

Ruf die SearchFacesByImage Operation an

Schreiben Sie den Code, um das erkannte Gesicht mit den Gesichtern in der Sammlung mit dem SearchFacesByImage zu vergleichen. Sie verwenden den Code, der im Abschnitt „Registrierung neuer Benutzer“ angezeigt wird, und stellen das Eingabebild für die SearchFacesByImage-Operation bereit.

Ändern Sie im folgenden Codebeispiel den Wert von collectionId in die Sammlung, nach der Sie suchen möchten. Außerdem ändern Sie den Wert von bucket in den Namen eines Amazon-S3-Buckets und den Wert von fileName in eine Bilddatei in diesem Bucket. Ersetzen Sie den Wert von region durch den Namen der Region, die Ihrem Konto zugeordnet ist. Sie sollten auch einen Ähnlichkeitsschwellenwert angeben, indem Sie den Wert von threshold durch ein ausgewähltes Perzentil ersetzen.
```
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)
```
Speichern Sie den Code und führen Sie ihn aus.

Suchen Sie nach der zurückgegebenen Gesichts-ID und dem Zuverlässigkeitsniveau

Sie können nun nach Informationen zu den übereinstimmenden Objekten suchen FaceId, FaceId indem Sie Antwortelemente wie die Attribute Ähnlichkeit und Konfidenz ausdrucken.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erstellen einer Lambda-Funktion für Amazon Rekognition

Verwendung von Amazon Rekognition (REK) zur Erkennung von Etiketten für Marketinganwendungen