Tutorial: Erkennen von Face Liveness

Artikel
09/25/2024

Mithilfe der Erkennung von Face Liveness lässt sich bestimmen, ob ein Gesicht in einem Eingabevideostream echt (live) oder eine Fälschung (Spoof) ist. Dies ist ein wichtiger Baustein in einem biometrischen Authentifizierungssystem, um zu verhindern, dass Betrüger mithilfe eines Fotos, eines Videos, einer Maske oder einer anderen Imitationsmethode Zugriff auf das System zu erlangt.

Die Liveness-Erkennung soll sicherstellen, dass das System zum Zeitpunkt der Authentifizierung mit einer physisch anwesenden, echten Person interagiert. Solche Systeme werden aufgrund der zunehmenden Nutzung von digitalen Finanzen, Remotezugriffssteuerung und Onlineidentitätsüberprüfung immer wichtiger.

Die Face Liveness-Erkennungslösung von Azure KI schützt erfolgreich vor einer Vielzahl von Spooftypen – von Papierausdrucken über 2D/3D-Masken bis hin zu Spoofpräsentationen auf Smartphones und Laptops. Die Liveness-Erkennung ist ein aktiver Forschungsbereich, und es werden kontinuierlich Verbesserungen vorgenommen, um immer ausgefeilteren Spoofingangriffen entgegenzuwirken. Für den Client und die Dienstkomponenten werden im Laufe der Zeit immer wieder Verbesserungen bereitgestellt, da die gesamte Lösung immer besser darin wird, neue Arten von Angriffen abzuwehren.

Wichtig

Die Face-Client-SDKs für Liveness sind ein eingeschränktes Feature. Sie müssen den Zugriff auf das Liveness-Feature anfordern, indem Sie das Aufnahmeformular für die Gesichtserkennung ausfüllen. Wenn Ihrem Azure-Abonnement Zugriff gewährt wird, können Sie das Face Liveness-SDK herunterladen.

Einführung

Die Liveness-Lösungsintegration umfasst zwei spezifische Komponenten: eine mobile Front-End-/Web-Anwendung und einen App-Server/Orchestrator.

Front-End-Anwendung: Die Front-End-Anwendung erhält eine Autorisierung vom App-Server, um die Liveness-Erkennung zu initiieren. Das Hauptziel besteht darin, die Kamera zu aktivieren und Endbenutzer präzise durch den Liveness-Erkennungsprozess zu leiten.
App-Server: Der App-Server dient als Back-End-Server, um Liveness-Erkennungssitzungen zu erstellen und ein Autorisierungstoken vom Gesichtserkennungsdienst für eine bestimmte Sitzung abzurufen. Dieses Token autorisiert die Front-End-Anwendung zum Durchführen der Liveness-Erkennung. Die Ziele des App-Servers sind die Verwaltung der Sitzungen, die Erteilung der Autorisierung für die Front-End-Anwendung und das Anzeigen der Ergebnisse des Liveness-Erkennungsprozesses.

Darüber hinaus kombinieren wir die Gesichtsüberprüfung mit der Liveness-Erkennung, um zu überprüfen, ob die Person die von Ihnen festgelegte Person ist. In der folgenden Tabelle werden die Details zu den Funktionen der Liveness-Erkennung beschrieben:

Funktion	Beschreibung
Liveness-Erkennung	Bestimmt, ob eine Eingabe echt oder gefälscht ist. Nur der App-Server hat die Berechtigung, die Liveness-Überprüfung zu starten und das Ergebnis abzufragen.
Liveness-Erkennung mit Gesichtsüberprüfung	Bestimmt, ob eine Eingabe echt oder gefälscht ist, und überprüft die Identität der Person basierend auf einem von Ihnen bereitgestellten Referenzbild. Entweder der App-Server oder die Front-End-Anwendung können ein Referenzbild bereitstellen. Nur der App-Server hat die Berechtigung, die Liveness-Überprüfung einzuleiten und das Ergebnis abzufragen.

In diesem Tutorial wird veranschaulicht, wie Sie eine Front-End-Anwendung und einen App-Server ausführen, um die Liveness-Erkennung und die Liveness-Erkennung mit Gesichtsüberprüfung in verschiedenen Sprach-SDKs durchzuführen.

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Damit Sie den entsprechenden KI-Bedingungen zustimmen und eine Ressource erstellen können, muss Ihrem Azure-Konto die Rolle Cognitive Services-Mitwirkender zugewiesen sein. Um diese Rolle Ihrem Konto zuzuweisen, führen Sie die Schritte in der Dokumentation Zuweisen von Rollen aus, oder wenden Sie sich an Ihren Administrator.
Wenn Sie über Ihr Azure-Abonnement verfügen, sollten Sie im Azure-Portal eine Gesichtserkennungsressource erstellen, um Ihren Schlüssel und Endpunkt abzurufen. Wählen Sie nach Abschluss der Bereitstellung Zu Ressource wechseln aus.
- Sie benötigen den Schlüssel und den Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit dem Gesichtserkennungsdienst verbinden zu können.
- Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.
Zugriff auf das Azure KI Vision Client-SDK für Gesichtserkennung für Mobilgeräte (iOS und Android) und Web. Um Zugriff auf das SDK zu erhalten, müssen Sie zunächst die Features für eingeschränkten Zugriff auf die Gesichtserkennung beantragen. Weitere Informationen finden Sie auf der Seite zum eingeschränkten Zugriff auf die Gesichtserkennung.

Einrichten von Front-End-Anwendungen und App-Servern zur Durchführung der Liveness-Erkennung

Wir stellen SDKs in verschiedenen Sprachen für Front-End-Anwendungen und App-Server bereit. Lesen Sie die folgenden Anweisungen zum Einrichten Ihrer Front-End-Anwendungen und App-Server.

Herunterladen des SDK für die Front-End-Anwendung

Wenn Sie Zugriff auf das SDK haben, können Sie gemäß der Anleitung im GitHub-Repository azure-ai-vision-sdk vorgehen, um die Benutzeroberfläche und den Code in Ihre native mobile Anwendung zu integrieren. Das Liveness SDK unterstützt Java/Kotlin für mobile Android-Anwendungen, Swift für mobile iOS-Anwendungen und JavaScript für Webanwendungen:

Folgen Sie für Swift (iOS) der Anleitung im iOS-Beispiel.
Folgen Sie für Kotlin/Java (Android) der Anleitung im Android-Beispiel.
Folgen Sie für JavaScript Web den Anweisungen im Webbeispiel

Nachdem Sie den Code zu Ihrer Anwendung hinzugefügt haben, kümmert sich das SDK um den Start der Kamera, leitet Endbenutzer an, um sie richtig zu positionieren, erstellt die Liveness-Nutzdaten und ruft den Azure KI-Clouddienst für die Gesichtserkennung auf, um die Liveness-Nutzdaten zu verarbeiten.

Herunterladen der Clientbibliothek der Azure KI-Gesichtserkennung für einen App-Server

Der App-Server/Orchestrator ist für die Steuerung des Lebenszyklus einer Liveness-Sitzung verantwortlich. Der App-Server muss eine Sitzung erstellen, bevor die Liveness-Erkennung ausgeführt wird. Dann kann er das Ergebnis abfragen und die Sitzung löschen, wenn die Liveness-Überprüfung abgeschlossen ist. Wir bieten eine Bibliothek in verschiedenen Sprachen für die einfache Implementierung Ihres App-Servers an. Führen Sie diese Schritte aus, um das gewünschte Paket zu installieren:

Folgen Sie für C# den Anleitungen in der Dotnet-Infodatei
Folgen Sie für Java den Anleitungen in der Java-Infodatei
Folgen Sie für Python den Anleitungen in der Python-Infodatei
Folgen Sie für JavaScript den Anleitungen in der JavaScript-Infodatei

Erstellen von Umgebungsvariablen

In diesem Beispiel schreiben Sie Ihre Anmeldeinformationen in Umgebungsvariablen auf dem lokalen Computer, auf dem die Anwendung ausgeführt wird.

Öffnen Sie das Azure-Portal. Wenn die Ressource, die Sie im Abschnitt Voraussetzungen erstellt haben, erfolgreich bereitgestellt wurde, wählen Sie unter Nächste Schritte die Option Zu Ressource wechseln aus. Schlüssel und Endpunkt finden Sie unter Ressourcenverwaltung auf der Seite Schlüssel und Endpunkte. Ihr Ressourcenschlüssel ist nicht mit Ihrer Azure-Abonnement-ID identisch.

Um die Umgebungsvariable für Ihren Ressourcenschlüssel und Endpunkt festzulegen, öffnen Sie ein Konsolenfenster und befolgen Sie die Anweisungen für Ihr Betriebssystem und Ihre Entwicklungsumgebung.

Zum Festlegen der Umgebungsvariablen FACE_APIKEY ersetzen Sie <your_key> durch einen der Schlüssel für Ihre Ressource.
Zum Festlegen der Umgebungsvariablen FACE_ENDPOINT ersetzen Sie <your_endpoint> durch den Endpunkt für Ihre Ressource.

Wichtig

Wenn Sie einen API-Schlüssel verwenden, speichern Sie ihn an einer anderen Stelle sicher, z. B. in Azure Key Vault. Fügen Sie den API-Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich zugänglich.

Weitere Informationen zur Sicherheit von KI Services finden Sie unter Authentifizieren von Anforderungen an Azure KI Services.

Windows
Linux

setx FACE_APIKEY <your_key>

setx FACE_ENDPOINT <your_endpoint>

Nachdem Sie die Umgebungsvariable hinzugefügt haben, müssen Sie unter Umständen alle ausgeführten Programme neu starten, von denen die Umgebungsvariablen gelesen werden, einschließlich des Konsolenfensters.

export FACE_APIKEY=<your_key>

export FACE_ENDPOINT=<your_endpoint>

Führen Sie nach dem Hinzufügen der Umgebungsvariablen im Konsolenfenster source ~/.bashrc aus, damit die Änderungen wirksam werden.

Durchführen der Liveness-Erkennung

Die Liveness-Orchestrierung umfasst die im Folgenden dargestellten allgemeinen Schritte:

Die Front-End-Anwendung startet die Liveness-Überprüfung und benachrichtigt den App-Server.

Der App-Server erstellt eine neue Liveness-Sitzung mit dem Azure KI-Gesichtserkennungsdienst. Der Dienst erstellt eine Liveness-Sitzung und antwortet mit einem Sitzungsautorisierungstoken. Weitere Informationen zu jedem Anforderungsparameter, der an der Erstellung einer Liveness-Sitzung beteiligt ist, wird in Liveness Create Session Operation referenziert.

var endpoint = new Uri(System.Environment.GetEnvironmentVariable("FACE_ENDPOINT"));
var credential = new AzureKeyCredential(System.Environment.GetEnvironmentVariable("FACE_APIKEY"));

var sessionClient = new FaceSessionClient(endpoint, credential);

var createContent = new CreateLivenessSessionContent(LivenessOperationMode.Passive)
{
    DeviceCorrelationId = "723d6d03-ef33-40a8-9682-23a1feb7bccd",
    SendResultsToClient = false,
};

var createResponse = await sessionClient.CreateLivenessSessionAsync(createContent);
var sessionId = createResponse.Value.SessionId;
Console.WriteLine($"Session created.");
Console.WriteLine($"Session id: {sessionId}");
Console.WriteLine($"Auth token: {createResponse.Value.AuthToken}");

String endpoint = System.getenv("FACE_ENDPOINT");
String accountKey = System.getenv("FACE_APIKEY");

FaceSessionClient sessionClient = new FaceSessionClientBuilder()
    .endpoint(endpoint)
    .credential(new AzureKeyCredential(accountKey))
    .buildClient();

CreateLivenessSessionContent parameters = new CreateLivenessSessionContent(LivenessOperationMode.PASSIVE)
    .setDeviceCorrelationId("723d6d03-ef33-40a8-9682-23a1feb7bccd")
    .setSendResultsToClient(false);

CreateLivenessSessionResult creationResult = sessionClient.createLivenessSession(parameters);
System.out.println("Session created.");
System.out.println("Session id: " + creationResult.getSessionId());
System.out.println("Auth token: " + creationResult.getAuthToken());

endpoint = os.environ["FACE_ENDPOINT"]
key = os.environ["FACE_APIKEY"]

face_session_client = FaceSessionClient(endpoint=endpoint, credential=AzureKeyCredential(key))

created_session = await face_session_client.create_liveness_session(
    CreateLivenessSessionContent(
        liveness_operation_mode=LivenessOperationMode.PASSIVE,
        device_correlation_id="723d6d03-ef33-40a8-9682-23a1feb7bccd",
        send_results_to_client=False,
    )
)
print("Session created.")
print(f"Session id: {created_session.session_id}")
print(f"Auth token: {created_session.auth_token}")

const endpoint = process.env['FACE_ENDPOINT'];
const apikey = process.env['FACE_APIKEY'];

const credential = new AzureKeyCredential(apikey);
const client = createFaceClient(endpoint, credential);

const createLivenessSessionResponse = await client.path('/detectLiveness/singleModal/sessions').post({
    body: {
        livenessOperationMode: 'Passive',
        deviceCorrelationId: '723d6d03-ef33-40a8-9682-23a1feb7bccd',
        sendResultsToClient: false,
    },
});

if (isUnexpected(createLivenessSessionResponse)) {
    throw new Error(createLivenessSessionResponse.body.error.message);
}

console.log('Session created.');
console.log(`Session ID: ${createLivenessSessionResponse.body.sessionId}`);
console.log(`Auth token: ${createLivenessSessionResponse.body.authToken}`);

curl --request POST --location "%FACE_ENDPOINT%/face/v1.1-preview.1/detectliveness/singlemodal/sessions" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%" ^
--header "Content-Type: application/json" ^
--data ^
"{ ^
    ""livenessOperationMode"": ""passive"", ^
    ""deviceCorrelationId"": ""723d6d03-ef33-40a8-9682-23a1feb7bccd"", ^
    ""sendResultsToClient"": ""false"" ^
}"

curl --request POST --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectliveness/singlemodal/sessions" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}" \
--header "Content-Type: application/json" \
--data \
'{
    "livenessOperationMode": "passive",
    "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bccd",
    "sendResultsToClient": "false"
}'

Ein Beispiel für den Antworttext:

{
    "sessionId": "a6e7193e-b638-42e9-903f-eaf60d2b40a5",
    "authToken": "<session-authorization-token>"
}

Der App-Server gibt das Sitzungsautorisierungstoken an die Front-End-Anwendung zurück.

Die Front-End-Anwendung stellt das Sitzungsautorisierungstoken während der Initialisierung des Azure KI Vision SDK bereit.

mServiceOptions?.setTokenCredential(com.azure.android.core.credential.TokenCredential { _, callback ->
    callback.onSuccess(com.azure.android.core.credential.AccessToken("<INSERT_TOKEN_HERE>", org.threeten.bp.OffsetDateTime.MAX))
})

serviceOptions?.authorizationToken = "<INSERT_TOKEN_HERE>"

azureAIVisionFaceAnalyzer.token = "<INSERT_TOKEN_HERE>"

Das SDK startet daraufhin die Kamera, bringt den Benutzer in die richtige Position und bereitet anschließend die Nutzdaten vor, um den Endpunkt für die Liveness-Erkennung aufzurufen.
Das SDK ruft den Gesichtserkennungsdienst von Azure KI Vision auf, um die Liveness-Erkennung durchzuführen. Wenn der Dienst antwortet, benachrichtigt das SDK die Front-End-Anwendung, dass die Liveness-Überprüfung abgeschlossen ist.
Die Front-End-Anwendung informiert den App-Server über den Abschluss der Liveness-Überprüfung.

Der App-Server kann nun das Ergebnis der Liveness-Erkennung aus dem Gesichtserkennungsdienst von Azure KI Vision abfragen.

var getResultResponse = await sessionClient.GetLivenessSessionResultAsync(sessionId);

var sessionResult = getResultResponse.Value;
Console.WriteLine($"Session id: {sessionResult.Id}");
Console.WriteLine($"Session status: {sessionResult.Status}");
Console.WriteLine($"Liveness detection request id: {sessionResult.Result?.RequestId}");
Console.WriteLine($"Liveness detection received datetime: {sessionResult.Result?.ReceivedDateTime}");
Console.WriteLine($"Liveness detection decision: {sessionResult.Result?.Response.Body.LivenessDecision}");
Console.WriteLine($"Session created datetime: {sessionResult.CreatedDateTime}");
Console.WriteLine($"Auth token TTL (seconds): {sessionResult.AuthTokenTimeToLiveInSeconds}");
Console.WriteLine($"Session expired: {sessionResult.SessionExpired}");
Console.WriteLine($"Device correlation id: {sessionResult.DeviceCorrelationId}");

LivenessSession sessionResult = sessionClient.getLivenessSessionResult(creationResult.getSessionId());
System.out.println("Session id: " + sessionResult.getId());
System.out.println("Session status: " + sessionResult.getStatus());
System.out.println("Liveness detection request id: " + sessionResult.getResult().getRequestId());
System.out.println("Liveness detection received datetime: " + sessionResult.getResult().getReceivedDateTime());
System.out.println("Liveness detection decision: " + sessionResult.getResult().getResponse().getBody().getLivenessDecision());
System.out.println("Session created datetime: " + sessionResult.getCreatedDateTime());
System.out.println("Auth token TTL (seconds): " + sessionResult.getAuthTokenTimeToLiveInSeconds());
System.out.println("Session expired: " + sessionResult.isSessionExpired());
System.out.println("Device correlation id: " + sessionResult.getDeviceCorrelationId());

liveness_result = await face_session_client.get_liveness_session_result(
    created_session.session_id
)
print(f"Session id: {liveness_result.id}")
print(f"Session status: {liveness_result.status}")
print(f"Liveness detection request id: {liveness_result.result.request_id}")
print(f"Liveness detection received datetime: {liveness_result.result.received_date_time}")
print(f"Liveness detection decision: {liveness_result.result.response.body.liveness_decision}")
print(f"Session created datetime: {liveness_result.created_date_time}")
print(f"Auth token TTL (seconds): {liveness_result.auth_token_time_to_live_in_seconds}")
print(f"Session expired: {liveness_result.session_expired}")
print(f"Device correlation id: {liveness_result.device_correlation_id}")

const getLivenessSessionResultResponse = await client.path('/detectLiveness/singleModal/sessions/{sessionId}', createLivenessSessionResponse.body.sessionId).get();

if (isUnexpected(getLivenessSessionResultResponse)) {
    throw new Error(getLivenessSessionResultResponse.body.error.message);
}

console.log(`Session id: ${getLivenessSessionResultResponse.body.id}`);
console.log(`Session status: ${getLivenessSessionResultResponse.body.status}`);
console.log(`Liveness detection request id: ${getLivenessSessionResultResponse.body.result?.requestId}`);
console.log(`Liveness detection received datetime: ${getLivenessSessionResultResponse.body.result?.receivedDateTime}`);
console.log(`Liveness detection decision: ${getLivenessSessionResultResponse.body.result?.response.body.livenessDecision}`);
console.log(`Session created datetime: ${getLivenessSessionResultResponse.body.createdDateTime}`);
console.log(`Auth token TTL (seconds): ${getLivenessSessionResultResponse.body.authTokenTimeToLiveInSeconds}`);
console.log(`Session expired: ${getLivenessSessionResultResponse.body.sessionExpired}`);
console.log(`Device correlation id: ${getLivenessSessionResultResponse.body.deviceCorrelationId}`);

curl --request GET --location "%FACE_ENDPOINT%/face/v1.1-preview.1/detectliveness/singlemodal/sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

curl --request GET --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectliveness/singlemodal/sessions/<session-id>" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"

Ein Beispiel für den Antworttext:

{
    "status": "ResultAvailable",
    "result": {
        "id": 1,
        "sessionId": "a3dc62a3-49d5-45a1-886c-36e7df97499a",
        "requestId": "cb2b47dc-b2dd-49e8-bdf9-9b854c7ba843",
        "receivedDateTime": "2023-10-31T16:50:15.6311565+00:00",
        "request": {
            "url": "/face/v1.1-preview.1/detectliveness/singlemodal",
            "method": "POST",
            "contentLength": 352568,
            "contentType": "multipart/form-data; boundary=--------------------------482763481579020783621915",
            "userAgent": ""
        },
        "response": {
            "body": {
                "livenessDecision": "realface",
                "target": {
                    "faceRectangle": {
                        "top": 59,
                        "left": 121,
                        "width": 409,
                        "height": 395
                    },
                    "fileName": "content.bin",
                    "timeOffsetWithinFile": 0,
                    "imageType": "Color"
                },
                "modelVersionUsed": "2022-10-15-preview.04"
            },
            "statusCode": 200,
            "latencyInMilliseconds": 1098
        },
        "digest": "537F5CFCD8D0A7C7C909C1E0F0906BF27375C8E1B5B58A6914991C101E0B6BFC"
    },
    "id": "a3dc62a3-49d5-45a1-886c-36e7df97499a",
    "createdDateTime": "2023-10-31T16:49:33.6534925+00:00",
    "authTokenTimeToLiveInSeconds": 600,
    "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bccd",
    "sessionExpired": false
}

Der App-Server kann die Sitzung löschen, wenn Sie das Ergebnis nicht mehr abfragen.

await sessionClient.DeleteLivenessSessionAsync(sessionId);
Console.WriteLine($"The session {sessionId} is deleted.");

sessionClient.deleteLivenessSession(creationResult.getSessionId());
System.out.println("The session " + creationResult.getSessionId() + " is deleted.");

await face_session_client.delete_liveness_session(
    created_session.session_id
)
print(f"The session {created_session.session_id} is deleted.")
await face_session_client.close()

const deleteLivenessSessionResponse = await client.path('/detectLiveness/singleModal/sessions/{sessionId}', createLivenessSessionResponse.body.sessionId).delete();
if (isUnexpected(deleteLivenessSessionResponse)) {
    throw new Error(deleteLivenessSessionResponse.body.error.message);
}
console.log(`The session ${createLivenessSessionResponse.body.sessionId} is deleted.`);

curl --request DELETE --location "%FACE_ENDPOINT%/face/v1.1-preview.1/detectliveness/singlemodal/sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

curl --request DELETE --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectliveness/singlemodal/sessions/<session-id>" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"

Durchführen der Liveness-Erkennung mit Gesichtsüberprüfung

Die Kombination aus Gesichtsüberprüfung und Liveness-Erkennung ermöglicht die biometrische Überprüfung einer bestimmten Person von Interesse mit der zusätzlichen Garantie, dass die Person physisch im System vorhanden ist. Die Integration von Liveness in die Überprüfung umfasst zwei Aspekte:

Die Wahl eines guten Referenzbilds.
Die Einrichtung der Orchestrierung von Liveness mit Überprüfung.

Auswählen eines Referenzbilds

Anhand der folgenden Tipps können Sie sicherstellen, dass Ihre Eingabebilder möglichst genaue Erkennungsergebnisse liefern.

Technische Anforderungen

Als Eingabebildformate werden JPEG, PNG, GIF (der erste Frame), BMP unterstützt.
Die Bilddateien dürfen maximal 6 MB groß sein.

Sie können das Attribut qualityForRecognition im Gesichtserkennungsvorgang verwenden, wenn Sie geeignete Erkennungsmodelle als allgemeine Richtlinie verwenden, um zu prüfen, ob das Bild wahrscheinlich eine ausreichende Qualität aufweist, um die Gesichtserkennung zu versuchen. Für die Registrierung von Personen werden nur Bilder der Qualitätsstufe "high" empfohlen, und die Qualität "medium" oder höher wird bei Identifikationen empfohlen.

Bildanforderungen

Das Foto ist klar und scharf, nicht verschwommen, pixelig, verzerrt oder beschädigt.
Das Foto wurde nicht verändert, um Schönheitsfehler zu entfernen oder das Aussehen des Gesichts zu verändern.
Das Foto muss in einem Format mit RGB-Farbunterstützung (JPEG, PNG, WEBP, BMP) vorliegen. Das Gesicht sollte eine Größe von 200 × 200 Pixel haben. Gesichter mit einer Größe von mehr als 200 × 200 Pixel führen nicht zu einer besseren KI-Qualität. Außerdem darf das Bild maximal 6 MB groß sein.
Der Benutzer bzw. die Benutzerin trägt weder eine Brille noch eine Maske, einen Hut, Kopfhörer oder eine Kopf- oder Gesichtsbedeckung. Das Gesicht darf nicht durch etwas verdeckt sein.
Gesichtsschmuck ist erlaubt, solange das Gesicht dadurch nicht verborgen wird.
Auf dem Foto darf nur ein einzelnes Gesicht sichtbar sein.
Das Gesicht muss sich in einer neutralen, nach vorn gerichteten Pose ohne extremen Gesichtsausdruck oder extreme Kopfneigung befinden. Beide Augen müssen geöffnet und der Mund muss geschlossen sein.
Das Gesicht darf keine Schatten oder roten Augen aufweisen. Nehmen Sie das Foto erneut auf, wenn einer dieser Punkte zutrifft.
Der Hintergrund muss einheitlich, schlicht und frei von Schatten sein.
Das Gesicht muss sich in der Bildmitte befinden und mindestens 50 Prozent des Bilds ausfüllen.

Die Einrichtung der Orchestrierung von Liveness mit Überprüfung.

Die Orchestrierung von Liveness mit Überprüfung umfasst die im Folgenden dargestellten allgemeinen Schritte:

Bereitstellen des Referenzbildes für die Überprüfung mit einer der beiden folgenden Methoden:

Der App-Server stellt das Referenzbild beim Erstellen der Liveness-Sitzung bereit. Weitere Informationen zu jedem Anforderungsparameter, der an der Erstellung einer Liveness-Sitzung mit Überprüfung beteiligt ist, wird in Liveness With Verify Session Operation referenziert.

var endpoint = new Uri(System.Environment.GetEnvironmentVariable("FACE_ENDPOINT"));
var credential = new AzureKeyCredential(System.Environment.GetEnvironmentVariable("FACE_APIKEY"));

var sessionClient = new FaceSessionClient(endpoint, credential);

var createContent = new CreateLivenessWithVerifySessionContent(LivenessOperationMode.Passive)
{
    DeviceCorrelationId = "723d6d03-ef33-40a8-9682-23a1feb7bccd"
};
using var fileStream = new FileStream("test.png", FileMode.Open, FileAccess.Read);

var createResponse = await sessionClient.CreateLivenessWithVerifySessionAsync(createContent, fileStream);

var sessionId = createResponse.Value.SessionId;
Console.WriteLine("Session created.");
Console.WriteLine($"Session id: {sessionId}");
Console.WriteLine($"Auth token: {createResponse.Value.AuthToken}");
Console.WriteLine("The reference image:");
Console.WriteLine($"  Face rectangle: {createResponse.Value.VerifyImage.FaceRectangle.Top}, {createResponse.Value.VerifyImage.FaceRectangle.Left}, {createResponse.Value.VerifyImage.FaceRectangle.Width}, {createResponse.Value.VerifyImage.FaceRectangle.Height}");
Console.WriteLine($"  The quality for recognition: {createResponse.Value.VerifyImage.QualityForRecognition}");

String endpoint = System.getenv("FACE_ENDPOINT");
String accountKey = System.getenv("FACE_APIKEY");

FaceSessionClient sessionClient = new FaceSessionClientBuilder()
    .endpoint(endpoint)
    .credential(new AzureKeyCredential(accountKey))
    .buildClient();

CreateLivenessWithVerifySessionContent parameters = new CreateLivenessWithVerifySessionContent(LivenessOperationMode.PASSIVE)
    .setDeviceCorrelationId("723d6d03-ef33-40a8-9682-23a1feb7bccd")
    .setSendResultsToClient(false);

Path path = Paths.get("test.png");
BinaryData data = BinaryData.fromFile(path);
CreateLivenessWithVerifySessionResult creationResult = sessionClient.createLivenessWithVerifySession(parameters, data);

System.out.println("Session created.");
System.out.println("Session id: " + creationResult.getSessionId());
System.out.println("Auth token: " + creationResult.getAuthToken());
System.out.println("The reference image:");
System.out.println("  Face rectangle: " + creationResult.getVerifyImage().getFaceRectangle().getTop() + " " + creationResult.getVerifyImage().getFaceRectangle().getLeft() + " " + creationResult.getVerifyImage().getFaceRectangle().getWidth() + " " + creationResult.getVerifyImage().getFaceRectangle().getHeight());
System.out.println("  The quality for recognition: " + creationResult.getVerifyImage().getQualityForRecognition());

endpoint = os.environ["FACE_ENDPOINT"]
key = os.environ["FACE_APIKEY"]

face_session_client = FaceSessionClient(endpoint=endpoint, credential=AzureKeyCredential(key))

reference_image_path = "test.png"
with open(reference_image_path, "rb") as fd:
    reference_image_content = fd.read()

created_session = await face_session_client.create_liveness_with_verify_session(
    CreateLivenessWithVerifySessionContent(
        liveness_operation_mode=LivenessOperationMode.PASSIVE,
        device_correlation_id="723d6d03-ef33-40a8-9682-23a1feb7bccd",
    ),
    verify_image=reference_image_content,
)
print("Session created.")
print(f"Session id: {created_session.session_id}")
print(f"Auth token: {created_session.auth_token}")
print("The reference image:")
print(f"  Face rectangle: {created_session.verify_image.face_rectangle}")
print(f"  The quality for recognition: {created_session.verify_image.quality_for_recognition}")

const endpoint = process.env['FACE_ENDPOINT'];
const apikey = process.env['FACE_APIKEY'];

const credential = new AzureKeyCredential(apikey);
const client = createFaceClient(endpoint, credential);

const createLivenessSessionResponse = await client.path('/detectLivenessWithVerify/singleModal/sessions').post({
    contentType: 'multipart/form-data',
    body: [
        {
            name: 'VerifyImage',
            // Note that this utilizes Node.js API.
            // In browser environment, please use file input or drag and drop to read files.
            body: readFileSync('test.png'),
        },
        {
            name: 'Parameters',
            body: {
                livenessOperationMode: 'Passive',
                deviceCorrelationId: '723d6d03-ef33-40a8-9682-23a1feb7bccd',
            },
        },
    ],
});

if (isUnexpected(createLivenessSessionResponse)) {
    throw new Error(createLivenessSessionResponse.body.error.message);
}

console.log('Session created:');
console.log(`Session ID: ${createLivenessSessionResponse.body.sessionId}`);
console.log(`Auth token: ${createLivenessSessionResponse.body.authToken}`);
console.log('The reference image:');
console.log(`  Face rectangle: ${createLivenessSessionResponse.body.verifyImage.faceRectangle}`);
console.log(`  The quality for recognition: ${createLivenessSessionResponse.body.verifyImage.qualityForRecognition}`)

curl --request POST --location "%FACE_ENDPOINT%/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%" ^
--form "Parameters=""{\\\""livenessOperationMode\\\"": \\\""passive\\\"", \\\""deviceCorrelationId\\\"": \\\""723d6d03-ef33-40a8-9682-23a1feb7bccd\\\""}""" ^
--form "VerifyImage=@""test.png"""

curl --request POST --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}" \
--form 'Parameters="{
    \"livenessOperationMode\": \"passive\",
    \"deviceCorrelationId\": \"723d6d03-ef33-40a8-9682-23a1feb7bccd\"
}"' \
--form 'VerifyImage=@"test.png"'

Ein Beispiel für den Antworttext:

{
    "verifyImage": {
        "faceRectangle": {
            "top": 506,
            "left": 51,
            "width": 680,
            "height": 475
        },
        "qualityForRecognition": "high"
    },
    "sessionId": "3847ffd3-4657-4e6c-870c-8e20de52f567",
    "authToken": "<session-authorization-token>"
}

Die Front-End-Anwendung stellt das Referenzbild beim Initialisieren des SDK bereit. Dieses Szenario wird bei der Weblösung nicht unterstützt.

val singleFaceImageSource = VisionSource.fromFile("/path/to/image.jpg")
mFaceAnalysisOptions?.setRecognitionMode(RecognitionMode.valueOfVerifyingMatchToFaceInSingleFaceImage(singleFaceImageSource))

if let path = Bundle.main.path(forResource: "<IMAGE_RESOURCE_NAME>", ofType: "<IMAGE_RESOURCE_TYPE>"),
   let image = UIImage(contentsOfFile: path),
   let singleFaceImageSource = try? VisionSource(uiImage: image) {
   try methodOptions.setRecognitionMode(.verifyMatchToFaceIn(singleFaceImage: singleFaceImageSource))
}

Not supported.

Der App-Server kann nun neben dem Liveness-Ergebnis auch das Überprüfungsergebnis abfragen.

var getResultResponse = await sessionClient.GetLivenessWithVerifySessionResultAsync(sessionId);
var sessionResult = getResultResponse.Value;
Console.WriteLine($"Session id: {sessionResult.Id}");
Console.WriteLine($"Session status: {sessionResult.Status}");
Console.WriteLine($"Liveness detection request id: {sessionResult.Result?.RequestId}");
Console.WriteLine($"Liveness detection received datetime: {sessionResult.Result?.ReceivedDateTime}");
Console.WriteLine($"Liveness detection decision: {sessionResult.Result?.Response.Body.LivenessDecision}");
Console.WriteLine($"Verification result: {sessionResult.Result?.Response.Body.VerifyResult.IsIdentical}");
Console.WriteLine($"Verification confidence: {sessionResult.Result?.Response.Body.VerifyResult.MatchConfidence}");
Console.WriteLine($"Session created datetime: {sessionResult.CreatedDateTime}");
Console.WriteLine($"Auth token TTL (seconds): {sessionResult.AuthTokenTimeToLiveInSeconds}");
Console.WriteLine($"Session expired: {sessionResult.SessionExpired}");
Console.WriteLine($"Device correlation id: {sessionResult.DeviceCorrelationId}");

LivenessWithVerifySession sessionResult = sessionClient.getLivenessWithVerifySessionResult(creationResult.getSessionId());
System.out.println("Session id: " + sessionResult.getId());
System.out.println("Session status: " + sessionResult.getStatus());
System.out.println("Liveness detection request id: " + sessionResult.getResult().getRequestId());
System.out.println("Liveness detection received datetime: " + sessionResult.getResult().getReceivedDateTime());
System.out.println("Liveness detection decision: " + sessionResult.getResult().getResponse().getBody().getLivenessDecision());
System.out.println("Verification result: " + sessionResult.getResult().getResponse().getBody().getVerifyResult().isIdentical());
System.out.println("Verification confidence: " + sessionResult.getResult().getResponse().getBody().getVerifyResult().getMatchConfidence());
System.out.println("Session created datetime: " + sessionResult.getCreatedDateTime());
System.out.println("Auth token TTL (seconds): " + sessionResult.getAuthTokenTimeToLiveInSeconds());
System.out.println("Session expired: " + sessionResult.isSessionExpired());
System.out.println("Device correlation id: " + sessionResult.getDeviceCorrelationId());

liveness_result = await face_session_client.get_liveness_with_verify_session_result(
    created_session.session_id
)
print(f"Session id: {liveness_result.id}")
print(f"Session status: {liveness_result.status}")
print(f"Liveness detection request id: {liveness_result.result.request_id}")
print(f"Liveness detection received datetime: {liveness_result.result.received_date_time}")
print(f"Liveness detection decision: {liveness_result.result.response.body.liveness_decision}")
print(f"Verification result: {liveness_result.result.response.body.verify_result.is_identical}")
print(f"Verification confidence: {liveness_result.result.response.body.verify_result.match_confidence}")
print(f"Session created datetime: {liveness_result.created_date_time}")
print(f"Auth token TTL (seconds): {liveness_result.auth_token_time_to_live_in_seconds}")
print(f"Session expired: {liveness_result.session_expired}")
print(f"Device correlation id: {liveness_result.device_correlation_id}")

const getLivenessSessionResultResponse = await client.path('/detectLivenessWithVerify/singleModal/sessions/{sessionId}', createLivenessSessionResponse.body.sessionId).get();
if (isUnexpected(getLivenessSessionResultResponse)) {
    throw new Error(getLivenessSessionResultResponse.body.error.message);
}

console.log(`Session id: ${getLivenessSessionResultResponse.body.id}`);
console.log(`Session status: ${getLivenessSessionResultResponse.body.status}`);
console.log(`Liveness detection request id: ${getLivenessSessionResultResponse.body.result?.requestId}`);
console.log(`Liveness detection received datetime: ${getLivenessSessionResultResponse.body.result?.receivedDateTime}`);
console.log(`Liveness detection decision: ${getLivenessSessionResultResponse.body.result?.response.body.livenessDecision}`);
console.log(`Verification result: ${getLivenessSessionResultResponse.body.result?.response.body.verifyResult.isIdentical}`);
console.log(`Verification confidence: ${getLivenessSessionResultResponse.body.result?.response.body.verifyResult.matchConfidence}`);
console.log(`Session created datetime: ${getLivenessSessionResultResponse.body.createdDateTime}`);
console.log(`Auth token TTL (seconds): ${getLivenessSessionResultResponse.body.authTokenTimeToLiveInSeconds}`);
console.log(`Session expired: ${getLivenessSessionResultResponse.body.sessionExpired}`);
console.log(`Device correlation id: ${getLivenessSessionResultResponse.body.deviceCorrelationId}`);

curl --request GET --location "%FACE_ENDPOINT%/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

curl --request GET --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions/<session-id>" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"

Ein Beispiel für den Antworttext:

{
    "status": "ResultAvailable",
    "result": {
        "id": 1,
        "sessionId": "3847ffd3-4657-4e6c-870c-8e20de52f567",
        "requestId": "f71b855f-5bba-48f3-a441-5dbce35df291",
        "receivedDateTime": "2023-10-31T17:03:51.5859307+00:00",
        "request": {
            "url": "/face/v1.1-preview.1/detectlivenesswithverify/singlemodal",
            "method": "POST",
            "contentLength": 352568,
            "contentType": "multipart/form-data; boundary=--------------------------590588908656854647226496",
            "userAgent": ""
        },
        "response": {
            "body": {
                "livenessDecision": "realface",
                "target": {
                    "faceRectangle": {
                        "top": 59,
                        "left": 121,
                        "width": 409,
                        "height": 395
                    },
                    "fileName": "content.bin",
                    "timeOffsetWithinFile": 0,
                    "imageType": "Color"
                },
                "modelVersionUsed": "2022-10-15-preview.04",
                "verifyResult": {
                    "matchConfidence": 0.9304124,
                    "isIdentical": true
                }
            },
            "statusCode": 200,
            "latencyInMilliseconds": 1306
        },
        "digest": "2B39F2E0EFDFDBFB9B079908498A583545EBED38D8ACA800FF0B8E770799F3BF"
    },
    "id": "3847ffd3-4657-4e6c-870c-8e20de52f567",
    "createdDateTime": "2023-10-31T16:58:19.8942961+00:00",
    "authTokenTimeToLiveInSeconds": 600,
    "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bccd",
    "sessionExpired": true
}

Der App-Server kann die Sitzung löschen, wenn Sie das Ergebnis nicht mehr abfragen.

await sessionClient.DeleteLivenessWithVerifySessionAsync(sessionId);
Console.WriteLine($"The session {sessionId} is deleted.");

sessionClient.deleteLivenessWithVerifySession(creationResult.getSessionId());
System.out.println("The session " + creationResult.getSessionId() + " is deleted.");

await face_session_client.delete_liveness_with_verify_session(
    created_session.session_id
)
print(f"The session {created_session.session_id} is deleted.")
await face_session_client.close()

const deleteLivenessSessionResponse = await client.path('/detectLivenessWithVerify/singleModal/sessions/{sessionId}', createLivenessSessionResponse.body.sessionId).delete();
if (isUnexpected(deleteLivenessSessionResponse)) {
    throw new Error(deleteLivenessSessionResponse.body.error.message);
}
console.log(`The session ${createLivenessSessionResponse.body.sessionId} is deleted.`);

curl --request DELETE --location "%FACE_ENDPOINT%/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

curl --request DELETE --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions/<session-id>" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}"

Bereinigen von Ressourcen

Wenn Sie ein Azure KI Services-Abonnement bereinigen und entfernen möchten, können Sie die Ressource oder die Ressourcengruppe löschen. Wenn Sie die Ressourcengruppe löschen, werden auch alle anderen Ressourcen gelöscht, die ihr zugeordnet sind.

Informationen zu anderen Optionen in den Liveness-APIs finden Sie in der Referenz zum Azure KI Vision-SDK.

Weitere Informationen zu den verfügbaren Funktionen zur Orchestrierung der Liveness-Lösung finden Sie in der REST-API-Referenz für die Sitzung.

Liveness-Sitzungsvorgänge

Freigeben über

Tutorial: Erkennen von Face Liveness

Einführung

Voraussetzungen

Einrichten von Front-End-Anwendungen und App-Servern zur Durchführung der Liveness-Erkennung

Herunterladen des SDK für die Front-End-Anwendung

Herunterladen der Clientbibliothek der Azure KI-Gesichtserkennung für einen App-Server

Erstellen von Umgebungsvariablen

Durchführen der Liveness-Erkennung

Durchführen der Liveness-Erkennung mit Gesichtsüberprüfung

Auswählen eines Referenzbilds

Technische Anforderungen

Bildanforderungen

Die Einrichtung der Orchestrierung von Liveness mit Überprüfung.

Bereinigen von Ressourcen

Feedback

Zusätzliche Ressourcen

Freigeben über

Tutorial: Erkennen von Face Liveness

Einführung

Voraussetzungen

Einrichten von Front-End-Anwendungen und App-Servern zur Durchführung der Liveness-Erkennung

Herunterladen des SDK für die Front-End-Anwendung

Herunterladen der Clientbibliothek der Azure KI-Gesichtserkennung für einen App-Server

Erstellen von Umgebungsvariablen

Durchführen der Liveness-Erkennung

Durchführen der Liveness-Erkennung mit Gesichtsüberprüfung

Auswählen eines Referenzbilds

Technische Anforderungen

Bildanforderungen

Die Einrichtung der Orchestrierung von Liveness mit Überprüfung.

Bereinigen von Ressourcen

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen