Udostępnij za pośrednictwem

Samouczek: wykrywanie liveness na twarzach

  • Artykuł

Wykrywanie na żywo twarzy służy do określania, czy twarz w wejściowym strumieniu wideo jest prawdziwa (na żywo) lub fałszywa (fałszowana). Jest to ważny blok konstrukcyjny w systemie uwierzytelniania biometrycznego, aby uniemożliwić imposterom uzyskanie dostępu do systemu przy użyciu fotografii, 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. Systemy te są coraz ważniejsze dzięki wzrostowi finansów cyfrowych, kontroli dostępu zdalnego i procesów weryfikacji tożsamości online.

Rozwiązanie do wykrywania liveness rozpoznawania twarzy usługi Azure AI 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. Ciągłe ulepszenia są wdrażane na kliencie i składnikach 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.

Wprowadzenie

Integracja rozwiązania liveness obejmuje dwa odrębne składniki: aplikację mobilną/internetową frontonu i serwer aplikacji/orkiestrator.

Diagram przepływu pracy liveness w usłudze Azure AI Face.

  • Aplikacja frontonu: aplikacja frontonu odbiera autoryzację z serwera aplikacji w celu zainicjowania wykrywania aktualności. Jego głównym celem jest aktywacja aparatu i dokładnego kierowania użytkownikami końcowymi przez proces wykrywania aktualności.
  • Serwer aplikacji: serwer aplikacji służy jako serwer zaplecza do tworzenia sesji wykrywania żywości i uzyskiwania tokenu autoryzacji z usługi rozpoznawania twarzy dla określonej sesji. Ten token autoryzuje aplikację frontonu do wykrywania aktualności. Celem serwera aplikacji jest zarządzanie sesjami, udzielanie autoryzacji dla aplikacji frontonu oraz wyświetlanie wyników procesu wykrywania aktualności.

Ponadto łączymy weryfikację twarzy z wykrywaniem aktualności, aby sprawdzić, czy dana osoba jest określoną osobą, którą wyznaczono. W poniższej tabeli opisano szczegóły funkcji wykrywania aktualności:

Funkcja opis
Wykrywanie aktualności Określenie danych wejściowych jest prawdziwe lub fałszywe, a tylko serwer aplikacji ma uprawnienia do rozpoczęcia sprawdzania aktualności i wykonywania zapytań względem wyniku.
Wykrywanie aktualności za pomocą weryfikacji twarzy Określenie danych wejściowych jest prawdziwe lub fałszywe i zweryfikowanie tożsamości osoby na podstawie podanego obrazu referencyjnego. Serwer aplikacji lub aplikacja frontonu może dostarczyć obraz referencyjny. Tylko serwer aplikacji ma uprawnienia do zainicjowania sprawdzania aktualności i wykonywania zapytań względem wyniku.

W tym samouczku pokazano, jak obsługiwać aplikację frontonu i serwer aplikacji w celu przeprowadzania wykrywania na żywo i wykrywania żywości przy użyciu weryfikacji twarzy w różnych zestawach SDK języka.

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.
    • 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) i internetu. 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.

Konfigurowanie aplikacji frontonu i serwerów aplikacji w celu wykrywania aktualności

Udostępniamy zestawy SDK w różnych językach dla aplikacji frontonu i serwerów aplikacji. Zapoznaj się z poniższymi instrukcjami, aby skonfigurować aplikacje frontonu i serwery aplikacji.

Pobieranie zestawu SDK dla aplikacji frontonu

Gdy masz dostęp do zestawu SDK, postępuj zgodnie z instrukcjami w repozytorium azure-ai-vision-sdk GitHub, 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, kierując użytkownika końcowego w dostosowywaniu pozycji, komponowaniu ładunku na żywo i wywoływaniu usługi Azure AI Face w chmurze w celu przetworzenia ładunku aktualności.

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 aktualności, a następnie może wykonać zapytanie dotyczące wyniku i usunąć sesję po zakończeniu sprawdzania dostępności. Oferujemy bibliotekę w różnych językach do łatwego implementowania serwera aplikacji. Wykonaj następujące kroki, aby zainstalować odpowiedni pakiet:

Tworzenie zmiennych środowiskowych

W tym przykładzie zapisz swoje poświadczenia w zmiennych środowiskowych na komputerze lokalnym, na których jest uruchamiana aplikacja.

Przejdź do portalu Azure Portal. Jeśli zasób utworzony w sekcji Wymagania wstępne został wdrożony pomyślnie, wybierz pozycję Przejdź do zasobu w obszarze Następne kroki. Klucz i punkt końcowy można znaleźć w obszarze Zarządzanie zasobami na stronie Klucze i punkt końcowy . Klucz zasobu nie jest taki sam jak identyfikator subskrypcji platformy Azure.

Aby ustawić zmienną środowiskową dla klucza i punktu końcowego, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

  • Aby ustawić zmienną FACE_APIKEY środowiskową, zastąp <your_key> element jednym z kluczy zasobu.
  • Aby ustawić zmienną FACE_ENDPOINT środowiskową, zastąp <your_endpoint> element punktem końcowym zasobu.

Ważne

Jeśli używasz klucza interfejsu API, zapisz go bezpiecznie w innym miejscu, na przykład w usłudze Azure Key Vault. Nie dołączaj klucza interfejsu API bezpośrednio do kodu i nigdy nie publikuj go publicznie.

Aby uzyskać więcej informacji na temat zabezpieczeń usług sztucznej inteligencji, zobacz Uwierzytelnianie żądań w usługach Azure AI.

setx FACE_APIKEY <your_key>

setx FACE_ENDPOINT <your_endpoint>

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które będą odczytywać zmienne środowiskowe, w tym okno konsoli.

Wykrywanie żywości

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

Diagram przepływu pracy liveness w usłudze Azure AI Face.

  1. Aplikacja frontonu uruchamia sprawdzanie aktualności i powiadamia serwer aplikacji.

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

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

var sessionClient = new FaceSessionClient(endpoint, credential);

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

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

    Przykład treści odpowiedzi:

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

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

  4. Aplikacja frontonu udostępnia token autoryzacji sesji podczas inicjowania zestawu AZURE AI Vision SDK.

    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. Następnie zestaw SDK uruchamia kamerę, kieruje użytkownika do poprawnego położenia, a następnie przygotowuje ładunek w celu wywołania punktu końcowego usługi wykrywania żywości.

  6. 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ę frontonu o zakończeniu sprawdzania dostępności.

  7. Aplikacja frontonu przekazuje uzupełnianie sprawdzania dostępności do serwera aplikacji.

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

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

    Przykład treści odpowiedzi:

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

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

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ą:

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

Diagram przepływu pracy liveness-with-face-verification twarzy platformy Azure.

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

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:

  1. Podanie obrazu odwołania weryfikacji przy użyciu jednej z następujących dwóch 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 temacie Liveness With Verify Create Session Operation (Weryfikacja operacji tworzenia sesji).

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

var sessionClient = new FaceSessionClient(endpoint, credential);

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

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

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

      Przykład treści odpowiedzi:

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

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

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

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

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

    Przykład treści odpowiedzi:

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

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

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.

Powiązana zawartość

Aby dowiedzieć się więcej o innych opcjach w interfejsach API funkcji liveness, zobacz dokumentację zestawu AZURE AI Vision SDK.

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