Samouczek: wykrywanie żywotności na podstawie twarzy

Z tego samouczka dowiesz się, jak wykrywać żywość twarzy przy użyciu kombinacji kodu po stronie serwera i aplikacji mobilnej po stronie klienta.

Wskazówka

Aby uzyskać ogólne informacje na temat wykrywania na żywo twarzy, zobacz przewodnik koncepcyjny.

W tym samouczku pokazano, jak obsługiwać aplikację frontendową i serwer aplikacji w celu wykrywania obecności życia, w tym opcjonalny krok weryfikacji twarzy, na różnych platformach i w różnych językach.

Ważne

Zestawy SDK klienta Face dla sprawdzania żywotności są funkcjonalnością wymagającą autoryzacji. Musisz zażądać dostępu do funkcji liveness, wypełniając formularz do wprowadzania rozpoznawania twarzy. Po udzieleniu dostępu subskrypcji platformy Azure możesz pobrać zestaw SDK rozpoznawania twarzy na żywo.

Wskazówka

Po spełnieniu wymagań wstępnych możesz wypróbować środowisko liveness systemu iOS z poziomu środowiska TestFlight i aplikacji Web-liveness z poziomu programu Vision Studio. Ponadto możesz również skompilować i uruchomić kompletny przykład frontonu (w systemach iOS, Android lub Web) w sekcji Przykłady .

Wymagania wstępne

• Subskrypcja platformy Azure — utwórz bezpłatnie
• Twoje konto platformy Azure musi mieć przypisaną rolę Współpracownik usług Cognitive Services, aby wyrazić zgodę na warunki odpowiedzialnego stosowania sztucznej inteligencji i utworzyć zasób. Aby uzyskać przypisaną tę rolę do konta, wykonaj kroki opisane w dokumentacji Przypisywanie ról lub skontaktuj się z administratorem.
• Masz swoją subskrypcję Azure, utwórz zasób rozpoznawania twarzy w portalu Azure, aby uzyskać klucz i punkt końcowy. Po wdrożeniu wybierz pozycję Przejdź do zasobu.
  • Potrzebny jest klucz i punkt końcowy z utworzonego zasobu, aby połączyć aplikację z usługą rozpoznawania twarzy.
  • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.
• Dostęp do zestawu SDK klienta rozpoznawania twarzy usługi Azure AI dla urządzeń przenośnych (iOS i Android) i sieci Web. Aby rozpocząć, musisz ubiegać się o dostęp do funkcji Ograniczonego dostępu do rozpoznawania twarzy, aby uzyskać dostęp do zestawu SDK. Aby uzyskać więcej informacji, zobacz stronę Ograniczony Dostęp do Twarzy.
• Znajomość funkcji wykrywania na żywo twarzy. Zapoznaj się z przewodnikiem koncepcyjnym.

Przygotowywanie zestawów SDK

Udostępniamy zestawy SDK w różnych językach, aby uprościć tworzenie aplikacji frontonu i serwerów aplikacji:

Pobieranie zestawu SDK dla aplikacji frontonu

Postępuj zgodnie z instrukcjami w repozytorium gitHub azure-ai-vision-sdk , aby zintegrować interfejs użytkownika i kod z natywną aplikacją mobilną. Zestaw LIVENESS SDK obsługuje język Java/Kotlin dla aplikacji mobilnych systemu Android, język Swift dla aplikacji mobilnych dla systemu iOS i język JavaScript dla aplikacji internetowych:

• W przypadku aplikacji Swift dla systemu iOS postępuj zgodnie z instrukcjami w przykładzie systemu iOS
• W przypadku języka Kotlin/Java Android postępuj zgodnie z instrukcjami w przykładzie systemu Android
• W przypadku aplikacji JavaScript Web postępuj zgodnie z instrukcjami w przykładzie internetowym

Po dodaniu kodu do aplikacji zestaw SDK obsługuje uruchamianie aparatu, pomaga użytkownikowi końcowemu w dostosowywaniu pozycji, komponowaniu danych liveness i wywoływaniu usługi w chmurze Azure AI Face do przetwarzania tych danych liveness.

Sekcję Wydania repozytorium SDK można monitorować pod kątem nowych aktualizacji wersji zestawu SDK.

Pobieranie biblioteki klienta rozpoznawania twarzy usługi Azure AI dla serwera aplikacji

Serwer aplikacji/orkiestrator jest odpowiedzialny za kontrolowanie cyklu życia sesji liveness. Serwer aplikacji musi utworzyć sesję przed przeprowadzeniem wykrywania aktywności, a następnie może sprawdzić wynik i usunąć sesję po zakończeniu sprawdzania aktywności. Oferujemy bibliotekę w różnych językach do łatwego implementowania serwera aplikacji. Wykonaj następujące kroki, aby zainstalować odpowiedni pakiet:

• W przypadku języka C# postępuj zgodnie z instrukcjami w pliku dotnet readme
• W przypadku języka Java postępuj zgodnie z instrukcjami w pliku readme języka Java
• W przypadku języka Python postępuj zgodnie z instrukcjami w pliku readme języka Python
• W przypadku języka JavaScript postępuj zgodnie z instrukcjami w pliku readme języka JavaScript

Ważne

Aby utworzyć zmienne środowiskowe dla klucza i punktu końcowego usługi Azure Face, zobacz przewodnik szybkiego startu

Detekcja żywotności

Poniżej przedstawiono ogólne kroki związane z orkiestracją liveness:

1. Aplikacja frontendowa uruchamia kontrolę żywotności i powiadamia serwer aplikacji.

2. Serwer aplikacji tworzy nową sesję liveness za pomocą usługi Azure AI Face Service. Usługa tworzy sesję weryfikacji obecności i odpowiada, wysyłając token autoryzacji sesji. Więcej informacji na temat każdego parametru żądania związanego z tworzeniem sesji liveness można znaleźć w temacie Liveness Create Session Operation (Operacja tworzenia sesji w trybie liveness).

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

   Jawa

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

   Pyton

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

   Interfejs API REST (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"" ^
   }"
   

   Interfejs API REST (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"
   }'
   

   Przykład treści odpowiedzi:

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

3. Serwer aplikacji udostępnia token autoryzacji sesji aplikacji frontendowej.

4. Aplikacja interfejsu użytkownika używa tokenu autoryzacji sesji, aby uruchomić detektor żywotności twarzy, który rozpocznie proces sprawdzania żywotności.

   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#>
                  }
              }
          }
      }
   }
   

   Sieć Web

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

5. Następnie zestaw SDK uruchamia kamerę, prowadzi użytkownika do poprawnego ustawienia, a następnie przygotowuje dane w celu wywołania punktu końcowego usługi detekcji witalności.

6. Zestaw SDK wywołuje usługę Face w Azure AI Vision w celu przeprowadzenia detekcji żywotności. Gdy usługa odpowie, SDK powiadomi front-endową aplikację o zakończeniu kontroli żywotności.

7. Aplikacja frontendowa przekazuje zakończenie sprawdzania dostępności do serwera aplikacji.

8. Serwer aplikacji może teraz wysyłać zapytania dotyczące wyniku wykrywania żywotności z usługi Azure AI Vision rozpoznającej twarze.

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

   Jawa

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

   Pyton

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

   Interfejs API REST (Windows)

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

   Interfejs API REST (Linux)

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

   Przykład treści odpowiedzi:

   {
       "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. Serwer aplikacji może usunąć sesję po zapytaniu o wszystkie wyniki sesji.

   C#

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

   Jawa

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

   Pyton

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

   Interfejs API REST (Windows)

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

   Interfejs API REST (Linux)

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

Przeprowadź wykrywanie żywotności za pomocą weryfikacji twarzy

Połączenie weryfikacji twarzy z wykrywaniem aktywności umożliwia biometryczną weryfikację określonej osoby interesującej się dodatkową gwarancją, że osoba jest fizycznie obecna w systemie.

Istnieją dwa aspekty związania wskaźnika aktywności z weryfikacją:

Krok 1. Wybieranie obrazu referencyjnego

Postępuj zgodnie z poradami wymienionymi w wymaganiach dotyczących kompozycji dla scenariuszy weryfikacji identyfikatorów , aby upewnić się, że obrazy wejściowe dają najdokładniejsze wyniki rozpoznawania.

Krok 2. Skonfiguruj koordynację aktywności z weryfikacją.

Poniżej przedstawiono ogólne kroki związane z orkiestracją weryfikacji w kontekście liveness:

1. Podanie obrazu referencyjnego do weryfikacji przy użyciu jednej z dwóch następujących metod:

   • Serwer aplikacji udostępnia obraz referencyjny podczas tworzenia sesji liveness. Więcej informacji dotyczących każdego parametru żądania związanego z tworzeniem sesji liveness z weryfikacją można znaleźć w Liveness With Verify Create Session Operation.

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

     Jawa

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

     Pyton

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

     Interfejs API REST (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"""
     

     Interfejs API REST (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"'
     

     Przykład treści odpowiedzi:

     {
         "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"
             }
             ]
         }
     }
     

   • Aplikacja frontonu udostępnia obraz referencyjny podczas inicjowania zestawu SDK. Ten scenariusz nie jest obsługiwany w rozwiązaniu internetowym.

     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#>
                     }
                 }
             }
         }
     }
     

     Sieć Web

     Not supported.
     

2. Serwer aplikacji może teraz wysyłać zapytania dotyczące wyniku weryfikacji, a także wyniku żywotności.

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

   Jawa

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

   Pyton

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

   Interfejs API REST (Windows)

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

   Interfejs API REST (Linux)

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

   Przykład treści odpowiedzi:

   {
       "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. Serwer aplikacji może usunąć sesję, jeśli nie wykonasz zapytania o jego wynik.

   C#

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

   Jawa

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

   Pyton

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

   Interfejs API REST (Windows)

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

   Interfejs API REST (Linux)

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

Wykonaj inne operacje dotyczące twarzy po wykryciu żywotności

Opcjonalnie można wykonywać dalsze operacje na twarzach po sprawdzeniu żywotności, takie jak analiza twarzy (na przykład w celu pobrania atrybutów twarzy) i/lub operacje dotyczące tożsamości twarzy.

1. Aby to włączyć, należy ustawić parametr "enableSessionImage" na wartość "true" podczas krokuSession-Creation.
2. Po zakończeniu sesji można wyodrębnić element "sessionImageId" z kroku Session-Get-Result.
3. Teraz możesz pobrać obraz sesji (opisany w operacji API pobierania obrazu sesji Liveness) lub podać "sessionImageId" w operacji API wykrywania przy użyciu identyfikatora obrazu sesji, aby kontynuować inne analizy twarzy lub operacje związane z identyfikacją twarzy. Aby uzyskać więcej informacji na temat tych operacji, zobacz Pojęcia dotyczące wykrywania twarzy i pojęcia dotyczące rozpoznawania twarzy.

Opcje pomocy technicznej

Oprócz korzystania z głównych opcji pomocy technicznej usług Azure AI możesz również opublikować swoje pytania w sekcji problemów w repozytorium SDK.

Powiązana zawartość

Aby dowiedzieć się, jak zintegrować rozwiązanie liveness z istniejącą aplikacją, zobacz dokumentację zestawu AZURE AI Vision SDK.

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

Aby dowiedzieć się więcej o funkcjach dostępnych do koordynowania rozwiązania liveness, zobacz referencję interfejsu API REST sesji.

• Operacje sesji na żywo