Tutorial: Erkennen von Face Liveness

In diesem Lernprogramm erfahren Sie, wie Sie Liveität in Gesichtern erkennen, indem Sie eine Kombination aus serverseitigem Code und einer clientseitigen mobilen Anwendung verwenden.

Tipp

Allgemeine Informationen zur Gesichtslebenserkennung finden Sie in der konzeptionellen Anleitung.

In diesem Lernprogramm wird veranschaulicht, wie Sie eine Frontend-Anwendung und einen App-Server verwenden, um die Livenesserkennung durchzuführen, einschließlich des optionalen Schritts der Gesichtsüberprüfung auf verschiedenen Plattformen und Sprachen.

Wichtig

Die Face-Client-SDKs für die 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.

Tipp

Nachdem Sie die Voraussetzungen erfüllt haben, können Sie die iOS-Liveness-Erfahrung von TestFlight und der Web-Liveness-Erfahrung von Vision Studio ausprobieren. Darüber hinaus können Sie ein vollständiges Frontend-Beispiel (entweder unter iOS, Android oder Web) aus dem Abschnitt "Beispiele " erstellen und ausfü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.
• Sobald Sie über Ihr Azure-Abonnement verfügen, sollten Sie im Azure-Portal eine Gesichtserkennungsressource erstellen, um Ihren Schlüssel und Endpunkt zu erhalten. 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 AI Vision Face Client SDK für Mobile (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.
• Vertrautheit mit der Liveness-Gesichtserkennungsfunktion. Sehen Sie sich den konzeptionellen Leitfaden an.

Vorbereiten von SDKs

Wir stellen SDKs in verschiedenen Sprachen bereit, um die Entwicklung auf Frontend-Anwendungen und App-Servern zu vereinfachen:

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

Folgen Sie den Anweisungen im GitHub-Repository des Azure-ai-vision-sdk , 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.

Sie können den Abschnitt "Releases" des SDK-Repositorys für neue SDK-Versionsupdates überwachen.

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

Wichtig

Informationen zum Erstellen von Umgebungsvariablen für Ihren Azure Face Service Key und Endpunkt finden Sie in der Schnellstartanleitung

Durchführen der Liveness-Erkennung

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

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.

   C#

   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",
       EnableSessionImage = true,
   };
   
   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}");
   

   Java

   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")
       .setEnableSessionImage(true);
   
   CreateLivenessSessionResult creationResult = sessionClient.createLivenessSession(parameters);
   System.out.println("Session created.");
   System.out.println("Session id: " + creationResult.getSessionId());
   System.out.println("Auth token: " + creationResult.getAuthToken());
   

   Python

   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",
           enable_session_image=True,
       )
   )
   print("Session created.")
   print(f"Session id: {created_session.session_id}")
   print(f"Auth token: {created_session.auth_token}")
   

   JavaScript

   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-sessions').post({
       body: {
           livenessOperationMode: 'Passive',
           deviceCorrelationId: '723d6d03-ef33-40a8-9682-23a1feb7bccd',
           enableSessionImage: true,
       },
   });
   
   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}`);
   

   REST-API (Windows)

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

   REST-API (Linux)

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

   Ein Beispiel für den Antworttext:

   {
       "sessionId": "a6e7193e-b638-42e9-903f-eaf60d2b40a5",
       "authToken": "<session-authorization-token>",
       "status": "NotStarted",
       "modelVersion": "2024-11-15",
       "results": {
           "attempts": []
       }
   }
   

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

4. Die Front-End-Anwendung verwendet das Sitzungsautorisierungstoken, um die Gesichts-Livetesterkennung zu starten, die den Livetestflow startet.

   Android

       FaceLivenessDetector(
           sessionAuthorizationToken = FaceSessionToken.sessionToken,
           verifyImageFileContent = FaceSessionToken.sessionSetInClientVerifyImage,
           deviceCorrelationId = "null",
           onSuccess = viewModel::onSuccess,
           onError = viewModel::onError
       )
   

   Ios

   struct HostView: View {
      @State var livenessDetectionResult: LivenessDetectionResult? = nil
      var token: String
      var body: some View {
          if livenessDetectionResult == nil {
              FaceLivenessDetectorView(result: $livenessDetectionResult,
                                       sessionAuthorizationToken: token)
          } else if let result = livenessDetectionResult {
              VStack {
                  switch result { 
                      case .success(let success):
                      /// <#show success#>
                      case .failure(let error):
                      /// <#show failure#>
                  }
              }
          }
      }
   }
   

   Web

   faceLivenessDetector = document.createElement("azure-ai-vision-face-ui");
   document.getElementById("container").appendChild(faceLivenessDetector);
   faceLivenessDetector.start(session.authToken)
   

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

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.

   C#

   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 decision: {sessionResult.Result?.Response.Body.LivenessDecision}");
   

   Java

   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 decision: " + sessionResult.getResult().getResponse().getBody().getLivenessDecision());
   

   Python

   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 decision: {liveness_result.result.response.body.liveness_decision}")
   

   JavaScript

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

   REST-API (Windows)

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

   REST-API (Linux)

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

   Ein Beispiel für den Antworttext:

   {
       "sessionId": "0acf6dbf-ce43-42a7-937e-705938881d62",
       "authToken": "",
       "status": "Succeeded",
       "modelVersion": "2024-11-15",
       "results": {
           "attempts": [
           {
               "attemptId": 1,
               "attemptStatus": "Succeeded",
               "result": {
               "livenessDecision": "realface",
               "targets": {
                   "color": {
                   "faceRectangle": {
                       "top": 763,
                       "left": 320,
                       "width": 739,
                       "height": 938
                   }
                   }
               },
               "digest": "517A0E700859E42107FA47E957DD12F54211C1A021A969CD391AC38BB88295A2",
               "sessionImageId": "Ab9tzwpDzqdCk35wWTiIHWJzzPr9fBCNSqBcXnJmDjbI"
               }
           }
           ]
       }
   }
   

9. Der App-Server kann die Sitzung löschen, sobald alle Sitzungsergebnisse abgefragt wurden.

   C#

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

   Java

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

   Python

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

   JavaScript

   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.`);
   

   REST-API (Windows)

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

   REST-API (Linux)

   curl --request DELETE --location "${FACE_ENDPOINT}/face/v1.2/detectLiveness-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:

Schritt 1 : Auswählen eines Referenzbilds

Befolgen Sie die Tipps, die in den Kompositionsanforderungen für ID-Überprüfungsszenarien aufgeführt sind, um sicherzustellen, dass Ihre Eingabebilder die genauesten Erkennungsergebnisse liefern.

Schritt 2: 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.

     C#

     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",
         EnableSessionImage = true,
     };
     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}");
     

     Java

     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")
         .setEnableSessionImage(true);
     
     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());        
     

     Python

     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",
             enable_session_image=True,
         ),
         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}")
     

     JavaScript

     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-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',
                     enableSessionImage: true,
                 },
             },
         ],
     });
     
     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}`)
     

     REST-API (Windows)

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

     REST-API (Linux)

     curl --request POST --location "${FACE_ENDPOINT}/face/v1.2/detectLivenesswithVerify-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:

     {
         "sessionId": "3847ffd3-4657-4e6c-870c-8e20de52f567",
         "authToken": "<session-authorization-token>",
         "status": "NotStarted",
         "modelVersion": "2024-11-15",
         "results": {
             "attempts": [],
             "verifyReferences": [
             {
                 "referenceType": "image",
                 "faceRectangle": {
                 "top": 98,
                 "left": 131,
                 "width": 233,
                 "height": 300
                 },
                 "qualityForRecognition": "high"
             }
             ]
         }
     }
     

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

     Android

         FaceLivenessDetector(
             sessionAuthorizationToken = FaceSessionToken.sessionToken,
             verifyImageFileContent = FaceSessionToken.sessionSetInClientVerifyImage,
             deviceCorrelationId = "null",
             onSuccess = viewModel::onSuccess,
             onError = viewModel::onError
         )
     

     Ios

     struct HostView: View {
         @State var livenessDetectionResult: LivenessDetectionResult? = nil
         var token: String
         var body: some View {
             if livenessDetectionResult == nil {
                 FaceLivenessDetectorView(result: $livenessDetectionResult,
                                             sessionAuthorizationToken: token)
             } else if let result = livenessDetectionResult {
                 VStack {
                     switch result { 
                         case .success(let success):
                         /// <#show success#>
                         case .failure(let error):
                         /// <#show failure#>
                     }
                 }
             }
         }
     }
     

     Web

     Not supported.
     

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

   C#

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

   Java

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

   Python

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

   JavaScript

   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(`Verification result: ${getLivenessSessionResultResponse.body.result?.response.body.verifyResult.isIdentical}`);
   console.log(`Verification confidence: ${getLivenessSessionResultResponse.body.result?.response.body.verifyResult.matchConfidence}`);
   

   REST-API (Windows)

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

   REST-API (Linux)

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

   Ein Beispiel für den Antworttext:

   {
       "sessionId": "93fd6f13-4161-41df-8a22-80a38ef53836",
       "authToken": "",
       "status": "Succeeded",
       "modelVersion": "2024-11-15",
       "results": {
           "attempts": [
               {
                   "attemptId": 1,
                   "attemptStatus": "Succeeded",
                   "result": {
                   "livenessDecision": "realface",
                   "targets": {
                       "color": {
                           "faceRectangle": {
                               "top": 669,
                               "left": 203,
                               "width": 646,
                               "height": 724
                           }
                       }
                   },
                   "digest": "EE664438FDF0535C6344A468181E4DDD4A34AC89582D4FD6E9E8954B843C7AA7",
                   "verifyResult": {
                           "matchConfidence": 0.08172279,
                           "isIdentical": false
                       }
                   }
               }
           ],
           "verifyReferences": [
           {
               "faceRectangle": {
                   "top": 98,
                   "left": 131,
                   "width": 233,
                   "height": 300
                   },
               "qualityForRecognition": "high"
           }
           ]
       }
   }
   

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

   C#

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

   Java

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

   Python

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

   JavaScript

   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.`);
   

   REST-API (Windows)

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

   REST-API (Linux)

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

Ausführen anderer Gesichtsvorgänge nach der Liveness-Erkennung

Optional können Sie nach der Livenessüberprüfung weitere Gesichtsoperationen ausführen, wie zum Beispiel eine Gesichtsanalyse (zum Abrufen von Gesichtsattributen) und/oder Gesichtsidentitätsoperationen.

1. Um dies zu aktivieren, müssen Sie den Parameter "enableSessionImage" während des Session-Creation Schritts auf "true" festlegen.
2. Nach Abschluss der Sitzung können Sie die "sessionImageId" aus dem Sitzungs-Get-Result Schritt extrahieren.
3. Sie können nun entweder das Sitzungsbild herunterladen (auf das in der Api "Liveness Get Session Image Operation" verwiesen wird), oder die "sessionImageId" im Vorgang " Erkennen von Sitzungsbild-ID-API " bereitstellen, um weiterhin andere Gesichtsanalyse- oder Gesichtsidentitätsvorgänge auszuführen. Weitere Informationen zu diesen Vorgängen finden Sie unter Gesichtserkennungskonzepte und Gesichtserkennungskonzepte.

Supportoptionen

Zusätzlich zur Verwendung der wichtigsten Supportoptionen für Azure AI-Dienste können Sie Ihre Fragen auch im Abschnitt "Probleme " des SDK-Repositorys posten.

Verwandte Inhalte

Informationen zum Integrieren der Liveness-Lösung in Ihre vorhandene Anwendung finden Sie in der Azure AI Vision SDK-Referenz.

• Kotlin (Android)
• Swift (iOS)
• JavaScript (Web)

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