Partilhar via

Tutorial: Detetar vivacidade em rostos

  • Artigo

A deteção de vivacidade facial é usada para determinar se um rosto em um fluxo de vídeo de entrada é real (ao vivo) ou falso (falsificado). É um bloco de construção importante em um sistema de autenticação biométrica para evitar que impostores tenham acesso ao sistema usando uma fotografia, vídeo, máscara ou outros meios para se passar por outra pessoa.

O objetivo da deteção de vivacidade é garantir que o sistema esteja interagindo com uma pessoa fisicamente presente e viva no momento da autenticação. Esses sistemas são cada vez mais importantes com o aumento das finanças digitais, controle de acesso remoto e processos de verificação de identidade on-line.

A solução de deteção de vivacidade facial do Azure AI defende com êxito contra vários tipos de falsificação, desde impressões em papel, máscaras 2D/3D e apresentações falsas em telefones e laptops. A deteção de vivacidade é uma área ativa de pesquisa, com melhorias contínuas sendo feitas para neutralizar ataques de falsificação cada vez mais sofisticados. Melhorias contínuas são implementadas para o cliente e os componentes de serviço ao longo do tempo, à medida que a solução geral fica mais robusta para novos tipos de ataques.

Importante

Os SDKs do cliente Face para vivacidade são um recurso fechado. Você deve solicitar acesso ao recurso de vivacidade preenchendo o formulário de admissão de Reconhecimento Facial. Quando sua assinatura do Azure tiver acesso concedido, você poderá baixar o SDK de vivacidade do Face.

Introdução

A integração da solução liveness envolve dois componentes distintos: um aplicativo móvel/web frontend e um servidor/orquestrador de aplicativos.

Diagrama do fluxo de trabalho de vivacidade no Azure AI Face.

  • Aplicativo frontend: o aplicativo frontend recebe autorização do servidor de aplicativos para iniciar a deteção de vivacidade. Seu principal objetivo é ativar a câmera e orientar os usuários finais com precisão através do processo de deteção de vivacidade.
  • Servidor de aplicativos: o servidor de aplicativos serve como um servidor de back-end para criar sessões de deteção de vivacidade e obter um token de autorização do serviço Face para uma sessão específica. Esse token autoriza o aplicativo frontend a executar a deteção de vivacidade. Os objetivos do servidor de aplicativos são gerenciar as sessões, conceder autorização para o aplicativo frontend e exibir os resultados do processo de deteção de vivacidade.

Além disso, combinamos a verificação facial com a deteção de vivacidade para verificar se a pessoa é a pessoa específica que você designou. A tabela a seguir descreve detalhes dos recursos de deteção de vivacidade:

Funcionalidade Description
Deteção de vivacidade Determine se uma entrada é real ou falsa, e apenas o servidor do aplicativo tem autoridade para iniciar a verificação de vivacidade e consultar o resultado.
Deteção de vivacidade com verificação facial Determine se uma entrada é real ou falsa e verifique a identidade da pessoa com base em uma imagem de referência que você forneceu. O servidor de aplicativos ou o aplicativo frontend pode fornecer uma imagem de referência. Somente o servidor do aplicativo tem autoridade para iniciar a verificação de vivacidade e consultar o resultado.

Este tutorial demonstra como operar um aplicativo frontend e um servidor de aplicativos para executar a deteção de vivacidade e a deteção de vivacidade com verificação facial em vários SDKs de idioma.

Pré-requisitos

  • Subscrição do Azure - Criar uma gratuitamente
  • Sua conta do Azure deve ter uma função de Colaborador de Serviços Cognitivos atribuída para que você concorde com os termos de IA responsável e crie um recurso. Para atribuir essa função à sua conta, siga as etapas na documentação Atribuir funções ou entre em contato com o administrador.
  • Depois de ter sua assinatura do Azure, crie um recurso Face no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
    • Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço Face.
    • Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.
  • Acesso ao SDK do Azure AI Vision Face Client para dispositivos móveis (IOS e Android) e Web. Para começar, você precisa solicitar os recursos de Acesso Limitado de Reconhecimento Facial para ter acesso ao SDK. Para obter mais informações, consulte a página Acesso limitado ao rosto.

Configurar aplicativos frontend e servidores de aplicativos para executar a deteção de vivacidade

Fornecemos SDKs em diferentes idiomas para aplicativos frontend e servidores de aplicativos. Consulte as instruções a seguir para configurar seus aplicativos frontend e servidores de aplicativos.

Baixar SDK para aplicativo frontend

Depois de ter acesso ao SDK, siga as instruções no repositório GitHub azure-ai-vision-sdk para integrar a interface do usuário e o código em seu aplicativo móvel nativo. O Liveness SDK suporta Java/Kotlin para aplicações móveis Android, Swift para aplicações móveis iOS e JavaScript para aplicações Web:

  • Para o Swift iOS, siga as instruções no exemplo iOS
  • Para Kotlin/Java Android, siga as instruções no exemplo Android
  • Para JavaScript Web, siga as instruções no exemplo Web

Depois de adicionar o código ao seu aplicativo, o SDK lida com a inicialização da câmera, orientando o usuário final no ajuste de sua posição, compondo a carga útil de vivacidade e chamando o serviço de nuvem Azure AI Face para processar a carga útil de vivacidade.

Baixar a biblioteca de cliente do Azure AI Face para o servidor de aplicativos

O servidor/orquestrador do aplicativo é responsável por controlar o ciclo de vida de uma sessão de liveness. O servidor de aplicativos precisa criar uma sessão antes de executar a deteção de vivacidade e, em seguida, pode consultar o resultado e excluir a sessão quando a verificação de vivacidade for concluída. Oferecemos uma biblioteca em vários idiomas para implementar facilmente seu servidor de aplicativos. Siga estas etapas para instalar o pacote desejado:

  • Para C#, siga as instruções no leiame dotnet
  • Para Java, siga as instruções no Leiame Java
  • Para Python, siga as instruções no Leiame Python
  • Para JavaScript, siga as instruções no Leiame JavaScript

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se o recurso criado na seção Pré-requisitos for implantado com êxito, selecione Ir para o recurso em Próximas etapas. Você pode encontrar sua chave e ponto de extremidade em Gerenciamento de Recursos na página Chaves e Ponto de Extremidade . Sua chave de recurso não é a mesma que sua ID de assinatura do Azure.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

  • Para definir a FACE_APIKEY variável de ambiente, substitua <your_key> por uma das chaves do seu recurso.
  • Para definir a variável de FACE_ENDPOINT ambiente, substitua <your_endpoint> pelo ponto de extremidade do seu recurso.

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Cofre de Chaves do Azure. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

Para obter mais informações sobre segurança de serviços de IA, consulte Autenticar solicitações para serviços de IA do Azure.

setx FACE_APIKEY <your_key>

setx FACE_ENDPOINT <your_endpoint>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

Execute a deteção de vivacidade

Os passos de alto nível envolvidos na orquestração da liveness são ilustrados abaixo:

Diagrama do fluxo de trabalho de vivacidade no Azure AI Face.

  1. O aplicativo frontend inicia a verificação de vivacidade e notifica o servidor do aplicativo.

  2. O servidor de aplicativos cria uma nova sessão de animação com o Azure AI Face Service. O serviço cria uma sessão de animação e responde com um token de autorização de sessão. Mais informações sobre cada parâmetro de solicitação envolvido na criação de uma sessão de liveness são referenciadas em Liveness Create Session Operation.

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

    Um exemplo do corpo da resposta:

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

  3. O servidor de aplicativos fornece o token de autorização de sessão de volta para o aplicativo front-end.

  4. O aplicativo frontend fornece o token de autorização de sessão durante a inicialização do SDK do 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))
})

  5. Em seguida, o SDK inicia a câmera, orienta o usuário a posicionar-se corretamente e, em seguida, prepara a carga útil para chamar o ponto de extremidade do serviço de deteção de vivacidade.

  6. O SDK chama o serviço Azure AI Vision Face para executar a deteção de vivacidade. Quando o serviço responde, o SDK notifica o aplicativo frontend de que a verificação de vivacidade foi concluída.

  7. O aplicativo frontend retransmite a conclusão da verificação de vivacidade para o servidor do aplicativo.

  8. O servidor de aplicativos agora pode consultar o resultado da deteção de vivacidade do serviço Azure AI Vision Face.

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

    Um exemplo do corpo da resposta:

    {
    "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. O servidor de aplicativos pode excluir a sessão se você não consultar mais o resultado.

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

Execute a deteção de vivacidade com verificação facial

A combinação da verificação facial com a deteção de vivacidade permite a verificação biométrica de uma determinada pessoa de interesse com uma garantia adicional de que a pessoa está fisicamente presente no sistema. Há duas partes para integrar a vivacidade com a verificação:

  1. Selecione uma boa imagem de referência.
  2. Configure a orquestração da vivacidade com verificação.

Diagrama do fluxo de trabalho de verificação de vivacidade com rosto do Azure AI Face.

Selecione uma imagem de referência

Use as dicas a seguir para garantir que suas imagens de entrada forneçam os resultados de reconhecimento mais precisos.

Requisitos técnicos

  • Os formatos de imagem de entrada suportados são JPEG, PNG, GIF (o primeiro quadro), BMP.
  • O tamanho do arquivo de imagem não deve ser maior que 6 MB.
  • Você pode utilizar o qualityForRecognition atributo na operação de deteção de rosto ao usar modelos de deteção aplicáveis como uma diretriz geral de se a imagem provavelmente tem qualidade suficiente para tentar o reconhecimento facial. Apenas "high" imagens de qualidade são recomendadas para inscrição de pessoas e qualidade igual ou superior "medium" é recomendada para cenários de identificação.

Requisitos em matéria de composição

  • A foto é clara e nítida, não desfocada, pixelada, distorcida ou danificada.
  • A foto não é alterada para remover manchas no rosto ou aparência do rosto.
  • A foto deve estar em um formato de cor RGB suportado (JPEG, PNG, WEBP, BMP). O tamanho recomendado do rosto é de 200 pixels x 200 pixels. Tamanhos de rosto maiores que 200 pixels x 200 pixels não resultarão em melhor qualidade de IA e não maiores que 6 MB de tamanho.
  • O usuário não está usando óculos, máscaras, chapéus, fones de ouvido, coberturas de cabeça ou coberturas faciais. O rosto deve estar livre de quaisquer obstruções.
  • Joias faciais são permitidas desde que não escondam seu rosto.
  • Apenas um rosto deve ser visível na foto.
  • O rosto deve estar em pose frontal neutra com os dois olhos abertos, boca fechada, sem expressões faciais extremas ou inclinação da cabeça.
  • O rosto deve estar livre de sombras ou olhos vermelhos. Retire uma foto se alguma dessas situações ocorrer.
  • O fundo deve ser uniforme e simples, livre de quaisquer sombras.
  • O rosto deve estar centralizado dentro da imagem e preencher pelo menos 50% da imagem.

Configure a orquestração da vivacidade com verificação.

Os passos de alto nível envolvidos na vivacidade com orquestração de verificação são ilustrados abaixo:

  1. Fornecer a imagem de referência de verificação por um dos dois métodos a seguir:

    • O servidor do aplicativo fornece a imagem de referência ao criar a sessão de liveness. Mais informações sobre cada parâmetro de solicitação envolvido na criação de uma sessão de animação com verificação são referenciadas em Liveness With Verify Create Session Operation.

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

      Um exemplo do corpo da resposta:

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

    • O aplicativo frontend fornece a imagem de referência ao inicializar o SDK. Este cenário não é suportado na solução Web.

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

  2. O servidor do aplicativo agora pode consultar o resultado da verificação, além do resultado de liveness.

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

    Um exemplo do corpo da resposta:

    {
    "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. O servidor de aplicativos pode excluir a sessão se você não consultar mais o resultado.

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

Clean up resources (Limpar recursos)

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados a ele.

Conteúdos relacionados

Para saber mais sobre outras opções nas APIs de liveness, consulte a referência do SDK do Azure AI Vision.

Para saber mais sobre os recursos disponíveis para orquestrar a solução de liveness, consulte a referência da API REST de sessão.