Samouczek: wykrywanie liveness na twarzach

Artykuł
02/06/2024

Wykrywanie na żywo twarzy może służyć do określenia, czy twarz w wejściowym strumieniu wideo jest prawdziwa (na żywo) lub fałszywa (fałsz). Jest to kluczowy blok konstrukcyjny w systemie uwierzytelniania biometrycznego, aby zapobiec fałszowaniu ataków przed oszustami próbującym uzyskać dostęp do systemu przy użyciu zdjęcia, wideo, maski lub innych środków personifikacji innej osoby.

Celem wykrywania aktywności jest zapewnienie, że system wchodzi w interakcję z fizycznie obecną osobą na żywo w momencie uwierzytelniania. Takie systemy stają się coraz ważniejsze wraz ze wzrostem finansów cyfrowych, zdalnej kontroli dostępu i procesów weryfikacji tożsamości online.

Rozwiązanie do wykrywania aktualności skutecznie broni przed różnymi typami fałszowania, od wydruków papierowych, masek 2d/3d i fałszowania prezentacji na telefonach i laptopach. Wykrywanie aktywności jest aktywnym obszarem badań, z ciągłymi ulepszeniami w celu przeciwdziałania coraz bardziej zaawansowanym atakom fałszowania w czasie. Ciągłe ulepszenia zostaną wprowadzone do klienta i składników usługi w miarę upływu czasu, ponieważ ogólne rozwiązanie staje się bardziej niezawodne dla nowych typów ataków.

Ważne

Zestawy SDK klienta rozpoznawania twarzy dla utrzymania są funkcją bramkową. 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.

Wymagania wstępne

Subskrypcja platformy Azure — utwórz bezpłatnie

Twoje konto platformy Azure musi mieć przypisaną rolę Współautor usług Cognitive Services, aby wyrazić zgodę na warunki odpowiedzialnego używania 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.
Po utworzeniu subskrypcji platformy Azure utwórz zasób rozpoznawania twarzy w witrynie Azure Portal, 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. W dalszej części przewodnika Szybki start wklejesz klucz i punkt końcowy do kodu.
- 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 Vision dla urządzeń przenośnych (iOS i Android). Aby rozpocząć, musisz zastosować funkcje dostępu ograniczonego do rozpoznawania twarzy, aby uzyskać dostęp do zestawu SDK. Aby uzyskać więcej informacji, zobacz stronę Dostęp ograniczony do twarzy.

Wykrywanie żywości

Integracja rozwiązania liveness obejmuje dwa różne składniki: aplikację mobilną i serwer aplikacji/orkiestrator.

Integrowanie aktualności z aplikacją mobilną

Po uzyskaniu dostępu do zestawu SDK 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 zarówno język Java/Kotlin dla systemu Android, jak i język Swift dla aplikacji mobilnych systemu iOS:

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

Po dodaniu kodu do aplikacji zestaw SDK obsługuje uruchamianie aparatu, kierując użytkownika końcowego, aby dostosować swoją pozycję, skomponować ładunek na żywo i wywołać usługę Azure AI Face w chmurze w celu przetworzenia ładunku aktualności.

Organizowanie rozwiązania liveness

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

Aplikacja mobilna uruchamia sprawdzanie aktualności i powiadamia serwer aplikacji.

Serwer aplikacji tworzy nową sesję liveness za pomocą usługi Azure AI Face Service. Usługa tworzy sesję liveness-session i odpowiada z powrotem za pomocą tokenu autoryzacji sesji.

Request:
curl --location '<insert-api-endpoint>/face/v1.1-preview.1/detectliveness/singlemodal/sessions' \
--header 'Ocp-Apim-Subscription-Key:<insert-api-key>
--header 'Content-Type: application/json' \
--data '{
  "livenessOperationMode": "passive",
  "deviceCorrelationId": "723d6d03-ef33-40a8-9682-23a1feb7bccd",
  "sendResultsToClient": "false"
}'
 
Response:
{
    "sessionId": "a6e7193e-b638-42e9-903f-eaf60d2b40a5",
    "authToken": <session-authorization-token>
}

Serwer aplikacji udostępnia token autoryzacji sesji z powrotem do aplikacji mobilnej.

Aplikacja mobilna udostępnia token autoryzacji sesji podczas inicjowania zestawu SDK usługi Azure AI Vision.

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

Następnie zestaw SDK uruchamia kamerę, kieruje użytkownika do poprawnego pozycjonowania, a następnie przygotowuje ładunek w celu wywołania punktu końcowego usługi wykrywania żywości.
Zestaw SDK wywołuje usługę rozpoznawania twarzy usługi Azure AI Vision w celu przeprowadzenia wykrywania aktualności. Gdy usługa odpowie, zestaw SDK powiadomi aplikację mobilną o zakończeniu sprawdzania dostępności.
Aplikacja mobilna przekazuje ukończenie sprawdzania aktualności na serwerze aplikacji.

Serwer aplikacji może teraz wysyłać zapytania dotyczące wyniku wykrywania aktualności z usługi rozpoznawania twarzy usługi Azure AI Vision.

Request:
curl --location '<insert-api-endpoint>/face/v1.1-preview.1/detectliveness/singlemodal/sessions/a3dc62a3-49d5-45a1-886c-36e7df97499a' \
--header 'Ocp-Apim-Subscription-Key: <insert-api-key>

Response:
{
    "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": "video.webp",
                    "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
}

Przeprowadzanie wykrywania aktualności przy użyciu 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ą dwie części integracji liveness z weryfikacją:

Wybierz dobry obraz referencyjny.
Skonfiguruj aranżację liveness przy użyciu weryfikacji.

Wybieranie dobrego obrazu referencyjnego

Skorzystaj z poniższych wskazówek, aby upewnić się, że obrazy wejściowe dają najdokładniejsze wyniki rozpoznawania.

Wymagania techniczne:

Obsługiwane formaty obrazów wejściowych to JPEG, PNG, GIF (pierwsza ramka), BMP.
Rozmiar pliku obrazu nie powinien być większy niż 6 MB.

Można użyć atrybutu qualityForRecognitionw operacji wykrywania twarzy w przypadku używania odpowiednich modeli wykrywania jako ogólnych wskazówek dotyczących tego, czy obraz prawdopodobnie ma wystarczającą jakość do próby rozpoznawania twarzy. W scenariuszach identyfikacji zalecane są tylko "high" obrazy jakości i rejestracji osób i jakości w lub powyżej "medium" .

Wymagania dotyczące kompozycji:

Zdjęcie jest jasne i ostre, nie rozmyte, pikselowane, zniekształcone lub uszkodzone.
Zdjęcie nie jest zmieniane, aby usunąć plamy twarzy lub wygląd twarzy.
Zdjęcie musi mieć obsługiwany format RGB (JPEG, PNG, WEBP, BMP). Zalecany rozmiar twarzy to 200 pikseli x 200 pikseli. Rozmiary twarzy większe niż 200 pikseli x 200 pikseli nie spowodują uzyskania lepszej jakości sztucznej inteligencji i rozmiaru nie większego niż 6 MB.
Użytkownik nie ma na sobie okularów, masek, kapeluszy, słuchawek, zakryć głowy ani zakryć twarzy. Twarz powinna być wolna od wszelkich przeszkód.
Biżuteria twarzy jest dozwolona, pod warunkiem, że nie ukrywają twarzy.
Tylko jedna twarz powinna być widoczna na zdjęciu.
Twarz powinna być neutralna przednie pozy z oboma oczami otwartymi, zamkniętymi ustami, bez ekstremalnych wyrazów twarzy ani nachylenia głowy.
Twarz powinna być wolna od cieni lub czerwonych oczu. Wykonaj ponownie zdjęcie, jeśli jeden z tych wystąpi.
Tło powinno być jednolite i proste, wolne od cieni.
Twarz powinna być wyśrodkowana na obrazie i wypełnić co najmniej 50% obrazu.

Skonfiguruj aranżację liveness przy użyciu weryfikacji.

Poniżej przedstawiono ogólne kroki związane z aranżacją weryfikacji:

Podaj obraz referencyjny weryfikacji przy użyciu jednej z następujących dwóch metod:

Serwer aplikacji udostępnia obraz referencyjny podczas tworzenia sesji liveness.

Request:
curl --location '<insert-api-endpoint>/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions' \
--header 'Ocp-Apim-Subscription-Key: <api_key>' \
--form 'Parameters="{
  \"livenessOperationMode\": \"passive\",
  \"deviceCorrelationId\": \"723d6d03-ef33-40a8-9682-23a1feb7bccd\"
}"' \
--form 'VerifyImage=@"test.png"'

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

Aplikacja mobilna udostępnia obraz referencyjny podczas inicjowania zestawu SDK.

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

Serwer aplikacji może teraz wysyłać zapytania dotyczące wyniku weryfikacji oprócz wyniku aktualności.

Request:
curl --location '<insert-api-endpoint>/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions/3847ffd3-4657-4e6c-870c-8e20de52f567' \
--header 'Content-Type: multipart/form-data' \
--header 'apim-recognition-model-preview-1904: true' \
--header 'Authorization: Bearer.<session-authorization-token> \
--form 'Content=@"video.webp"' \
--form 'Metadata="<insert-metadata>"

Response:
{
    "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": "video.webp",
                    "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
}

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Azure AI, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów.

Następne kroki

Zapoznaj się z dokumentacją zestawu AZURE AI Vision SDK, aby dowiedzieć się więcej o innych opcjach w interfejsach API liveness.

Zapoznaj się z dokumentacją interfejsu API REST sesji, aby dowiedzieć się więcej o funkcjach dostępnych do organizowania rozwiązania liveness.