SearchFacesByImage Operationsanforderung SearchFacesByImage Antwort auf die Operation

Suche nach einem Gesicht mit einem Bild

Sie können die SearchFacesByImageOperation verwenden, um in einer Sammlung nach Gesichtern zu suchen, die dem größten Gesicht in einem bereitgestellten Bild entsprechen.

Weitere Informationen finden Sie unter Suche nach Gesichtern und Benutzern in einer Sammlung.

Suchen nach einem Gesicht in einer Sammlung mithilfe eines Bildes (SDK)

Wenn Sie dies noch nicht getan haben:
1. Erstellen oder aktualisieren Sie einen Benutzer mit AmazonRekognitionFullAccess- und AmazonS3ReadOnlyAccess-Berechtigungen. Weitere Informationen finden Sie unter Schritt 1: Einrichten eines AWS-Kontos und Erstellen eines Benutzers.
2. Installieren und konfigurieren Sie die AWS CLI und die AWS SDKs. Weitere Informationen finden Sie unter Schritt 2: Richten Sie die AWS CLI und AWS SDKs ein.
Laden Sie ein Bild in Ihren S3-Bucket hoch, auf dem ein oder mehrere Gesichter abgebildet sind.

Weitere Anleitungen finden Sie unter Upload eines Objekts in Amazon S3 im Benutzerhandbuch für Amazon Simple Storage Service.

Verwenden Sie die folgenden Beispiele zum Aufrufen der SearchFacesByImage-Operation.

Java

Dieses Beispiel zeigt Informationen über Gesichter an, die mit dem größten Gesicht in einem Bild übereinstimmen. Der Beispielcode legt die beiden Parameter FaceMatchThreshold und MaxFaces fest, um die in der Antwort zurückgegebenen Ergebnisse einzugrenzen.

Im folgenden Beispiel ändern Sie Folgendes: Ändern Sie den Wert von collectionId in die Sammlung, die Sie durchsuchen möchten, ändern Sie den Wert von bucket in den Bucket mit dem Eingabebild und ändern Sie den Wert von photo in das Eingabebild.


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

package aws.example.rekognition.image;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.FaceMatch;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.SearchFacesByImageRequest;
import com.amazonaws.services.rekognition.model.SearchFacesByImageResult;
import java.util.List;
import com.fasterxml.jackson.databind.ObjectMapper;


public class SearchFaceMatchingImageCollection {
    public static final String collectionId = "MyCollection";
    public static final String bucket = "bucket";
    public static final String photo = "input.jpg";
      
    public static void main(String[] args) throws Exception {

       AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();
        
      ObjectMapper objectMapper = new ObjectMapper();
      
       // Get an image object from S3 bucket.
      Image image=new Image()
              .withS3Object(new S3Object()
                      .withBucket(bucket)
                      .withName(photo));
      
      // Search collection for faces similar to the largest face in the image.
      SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
              .withCollectionId(collectionId)
              .withImage(image)
              .withFaceMatchThreshold(70F)
              .withMaxFaces(2);
           
       SearchFacesByImageResult searchFacesByImageResult = 
               rekognitionClient.searchFacesByImage(searchFacesByImageRequest);

       System.out.println("Faces matching largest face in image from" + photo);
      List < FaceMatch > faceImageMatches = searchFacesByImageResult.getFaceMatches();
      for (FaceMatch face: faceImageMatches) {
          System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                  .writeValueAsString(face));
         System.out.println();
      }
   }
}

Java V2

Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie hier.


// snippet-start:[rekognition.java2.search_faces_collection.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.SearchFacesByImageRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.SearchFacesByImageResponse;
import software.amazon.awssdk.services.rekognition.model.FaceMatch;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
// snippet-end:[rekognition.java2.search_faces_collection.import]

/**
 * Before running this Java V2 code example, set up your development environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class SearchFaceMatchingImageCollection {

    public static void main(String[] args) {

        final String usage = "\n" +
            "Usage: " +
            "   <collectionId> <sourceImage>\n\n" +
            "Where:\n" +
            "   collectionId - The id of the collection.  \n" +
            "   sourceImage - The path to the image (for example, C:\\AWS\\pic1.png). \n\n";

        if (args.length != 2) {
            System.out.println(usage);
            System.exit(1);
        }

        String collectionId = args[0];
        String sourceImage = args[1];
        Region region = Region.US_EAST_1;
        RekognitionClient rekClient = RekognitionClient.builder()
            .region(region)
            .credentialsProvider(ProfileCredentialsProvider.create("profile-name"))
            .build();

        System.out.println("Searching for a face in a collections");
        searchFaceInCollection(rekClient, collectionId, sourceImage ) ;
        rekClient.close();
    }

    // snippet-start:[rekognition.java2.search_faces_collection.main]
    public static void searchFaceInCollection(RekognitionClient rekClient,String collectionId, String sourceImage) {

        try {
            InputStream sourceStream = new FileInputStream(new File(sourceImage));
            SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
            Image souImage = Image.builder()
                .bytes(sourceBytes)
                .build();

            SearchFacesByImageRequest facesByImageRequest = SearchFacesByImageRequest.builder()
                .image(souImage)
                .maxFaces(10)
                .faceMatchThreshold(70F)
                .collectionId(collectionId)
                .build();

            SearchFacesByImageResponse imageResponse = rekClient.searchFacesByImage(facesByImageRequest) ;
            System.out.println("Faces matching in the collection");
            List<FaceMatch> faceImageMatches = imageResponse.faceMatches();
            for (FaceMatch face: faceImageMatches) {
                System.out.println("The similarity level is  "+face.similarity());
                System.out.println();
            }

        } catch (RekognitionException | FileNotFoundException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }
    // snippet-end:[rekognition.java2.search_faces_collection.main]
}

AWS CLI

Dieser AWS CLI Befehl zeigt die JSON-Ausgabe für den search-faces-by-image CLI-Vorgang an. Ersetzen Sie den Wert von Bucket durch den S3-Bucket, den Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von Name durch den Namen der Bilddatei, die Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von collection-id durch den Namen der Sammlung, in der Sie suchen möchten. Ersetzen Sie den Wert von profile_name in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.



aws rekognition search-faces-by-image --image '{"S3Object":{"Bucket":"bucket-name","Name":"image-name"}}' \
--collection-id "collection-id" --profile profile-name

Wenn Sie auf einem Windows-Gerät auf die CLI zugreifen, verwenden Sie doppelte Anführungszeichen anstelle von einfachen Anführungszeichen und maskieren Sie die inneren doppelten Anführungszeichen durch einen Backslash (d. h. \), um eventuell auftretende Parserfehler zu beheben. Sehen Sie sich zum Beispiel Folgendes an:


aws rekognition search-faces-by-image --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" \
--collection-id "collection-id" --profile profile-name

Python

Nehmen Sie im folgenden Beispiel diese Änderungen vor: Ändern Sie den Wert von collectionId in die Sammlung, die Sie durchsuchen möchten, und ersetzen Sie die Werte von bucket und photo durch die Namen des Amazon-S3-Buckets und des Bilds, die Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von profile_name in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.


#Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

import boto3

if __name__ == "__main__":

    bucket='bucket'
    collectionId='MyCollection'
    fileName='input.jpg'
    threshold = 70
    maxFaces=2

    client=boto3.client('rekognition')

  
    response=client.search_faces_by_image(CollectionId=collectionId,
                                Image={'S3Object':{'Bucket':bucket,'Name':fileName}},
                                FaceMatchThreshold=threshold,
                                MaxFaces=maxFaces)

                                
    faceMatches=response['FaceMatches']
    print ('Matching faces')
    for match in faceMatches:
            print ('FaceId:' + match['Face']['FaceId'])
            print ('Similarity: ' + "{:.2f}".format(match['Similarity']) + "%")
            print

.NET


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

using System;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;

public class SearchFacesMatchingImage
{
    public static void Example()
    {
        String collectionId = "MyCollection";
        String bucket = "bucket";
        String photo = "input.jpg";

        AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

        // Get an image object from S3 bucket.
        Image image = new Image()
        {
            S3Object = new S3Object()
            {
                Bucket = bucket,
                Name = photo
            }
        };

        SearchFacesByImageRequest searchFacesByImageRequest = new SearchFacesByImageRequest()
        {
            CollectionId = collectionId,
            Image = image,
            FaceMatchThreshold = 70F,
            MaxFaces = 2
        };

        SearchFacesByImageResponse searchFacesByImageResponse = rekognitionClient.SearchFacesByImage(searchFacesByImageRequest);

        Console.WriteLine("Faces matching largest face in image from " + photo);
        foreach (FaceMatch face in searchFacesByImageResponse.FaceMatches)
            Console.WriteLine("FaceId: " + face.Face.FaceId + ", Similarity: " + face.Similarity);
    }
}

SearchFacesByImage Operationsanforderung

Die in SearchFacesImageByImage eingegebenen Parameter entsprechen der Sammlung, in der gesucht werden soll, und dem Speicherort des Quellbilds. In diesem Beispiel wird das in einem Amazon-S3-Bucket gespeicherte Quellenbild (S3Object) geladen. Außerdem sind die maximale Anzahl von Gesichtern (Maxfaces), die zurückgegeben wird, und die minimale Übereinstimmung angegeben, die eingehalten werden muss, damit ein Gesicht (FaceMatchThreshold) zurückgegeben wird.


{
    "CollectionId": "MyCollection",
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "input.jpg"
        }
    },
    "MaxFaces": 2,
    "FaceMatchThreshold": 99
}

SearchFacesByImage Antwort auf die Operation

Für ein bereitgestelltes Eingabebild (im JPEG- oder PNG-Format) erkennt die Operation zuerst das Gesicht auf dem Eingabebild. Anschließend durchsucht sie die festgelegte Gesichtersammlung nach ähnlichen Gesichtern.

Anmerkung

Wenn der Dienst mehrere Gesichter auf dem Eingabebild erkennt, wird nach dem größten erkannten Gesicht gesucht.

Die Operation gibt eine Reihe von gefundenen übereinstimmenden Gesichtern sowie Informationen zu den eingegebenen Gesichtern zurück. Dies umfasst Informationen wie den Begrenzungsrahmen sowie den Wahrscheinlichkeitswert, der die Wahrscheinlichkeit angibt, dass der Begrenzungsrahmen ein Gesicht enthält.

Standardmäßig gibt SearchFacesByImage Gesichter zurück, bei denen der Algorithmus mindestens 80% Ähnlichkeit erkennt. Die Ähnlichkeit gibt an, inwieweit das Gesicht mit dem Bild auf dem Eingabebild übereinstimmt. Optional können Sie die Funktion FaceMatchThreshold nutzen, um einen anderen Wert zu bestimmen. Für jede gefundene Gesichtsübereinstimmung enthält die Antwort Metadaten zur Ähnlichkeit und zum Gesicht wie in der folgenden Beispielantwort angezeigt:


{
    "FaceMatches": [
        {
            "Face": {
                "BoundingBox": {
                    "Height": 0.06333330273628235,
                    "Left": 0.1718519926071167,
                    "Top": 0.7366669774055481,
                    "Width": 0.11061699688434601
                },
                "Confidence": 100,
                "ExternalImageId": "input.jpg",
                "FaceId": "578e2e1b-d0b0-493c-aa39-ba476a421a34",
                "ImageId": "9ba38e68-35b6-5509-9d2e-fcffa75d1653"
            },
            "Similarity": 99.9764175415039
        }
    ],
    "FaceModelVersion": "3.0",
    "SearchedFaceBoundingBox": {
        "Height": 0.06333333253860474,
        "Left": 0.17185185849666595,
        "Top": 0.7366666793823242,
        "Width": 0.11061728745698929
    },
    "SearchedFaceConfidence": 99.99999237060547
}

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

Suchen nach einem Gesicht (Gesichts-ID)

Suche nach Benutzern (Gesichts-ID/Benutzer-ID)