Teilen über

Tutorial: Erkennen von Face Liveness

  • Artikel

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 Spoofingangriffe von Betrügern zu verhindern, die versuchen, mithilfe eines Fotos, eines Videos, einer Maske oder einer anderen Imitationsmethode Zugriff auf das System zu erlangen.

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 Liveness-Erkennungslösung 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.

Abbildung des Liveness-Workflows in Azure KI Gesichtserkennung.

  • 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.

Erste Schritte

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.

Integrieren von Liveness in 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:

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.

Tipp

Fügen Sie den Schlüssel nicht direkt in Ihren Code ein, und machen Sie ihn nicht öffentlich. Im Artikel zur Azure KI Services-Sicherheit finden Sie weitere Authentifizierungsoptionen, wie zum Beispiel Azure Key Vault.

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.

  1. Zum Festlegen der Umgebungsvariablen VISION_KEY ersetzen Sie your-key durch einen der Schlüssel für Ihre Ressource.
  2. Zum Festlegen der Umgebungsvariablen VISION_ENDPOINT ersetzen Sie your-endpoint durch den Endpunkt für Ihre Ressource.
setx VISION_KEY your-key

setx VISION_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.

Durchführen der Liveness-Erkennung

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

Abbildung des Liveness-Workflows in Azure KI Gesichtserkennung.

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

  2. 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("VISION_ENDPOINT"));
var credential = new AzureKeyCredential(System.Environment.GetEnvironmentVariable("VISION_KEY"));

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}");

    Ein Beispiel für den Antworttext:

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

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

  4. 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))
})

  5. Das SDK startet daraufhin die Kamera, bringt den Benutzer bzw. die Benutzerin in die richtige Position und bereitet anschließend die Nutzdaten vor, um den Endpunkt für die Liveness-Erkennung aufzurufen.

  6. 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.

  7. Die Front-End-Anwendung informiert den App-Server über den Abschluss der Liveness-Überprüfung.

  8. 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}");

    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
}

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

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:

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

Diagramm: Workflow für Liveness mit Gesichtsüberprüfung in der Azure KI-Gesichtserkennung.

Auswählen eines guten 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:

  1. 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("VISION_ENDPOINT"));
var credential = new AzureKeyCredential(System.Environment.GetEnvironmentVariable("VISION_KEY"));

var sessionClient = new FaceSessionClient(endpoint, credential);

var createContent = new CreateLivenessSessionContent(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}");

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

  2. 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}");

    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
}

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

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.

Nächste Schritte

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.