Tutorial: detectar atividade em rostos

Artigo
09/03/2024

A detecção de atividade facial pode ser usada para determinar se um rosto em uma entrada de transmissão de vídeo é real (ao vivo) ou falso (falsificação). É um bloco de construção importante em um sistema de autenticação biométrica para evitar impostores tentando obter acesso ao sistema ao usar uma fotografia, vídeo, máscara ou outros meios para usurpar a identidade de outra pessoa.

O objetivo da detecção de atividade é garantir que o sistema está interagindo com uma pessoa fisicamente presente ao vivo no momento da autenticação. Esses sistemas estão se tornando cada vez mais importantes com o aumento das finanças digitais, do controle de acesso remoto e dos processos de verificação de identidade online.

A solução de detecção de atividade de Detecção Facial da IA do Azure promove com êxito a defesa contra uma variedade de tipos de falsificação, desde impressões em papel, máscaras 2D/3D até apresentações falsificadas em telefones e laptops. A detecção de atividade é uma área ativa de pesquisa, obtendo melhorias contínuas para combater ataques de falsificação que ficam cada vez mais sofisticados com o tempo. Melhorias contínuas serão distribuídas para o cliente e os componentes de serviço com o tempo, à medida que a solução geral fica mais robusta para novos tipos de ataques.

Importante

Os SDKs do cliente da Detecção Facial para atividade são um recurso fechado. Solicite acesso ao recurso de atividade preenchendo o formulário de admissão de Reconhecimento Facial. Quando sua assinatura do Azure receber acesso, baixe o SDK de atividade da Detecção Facial.

Introdução

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

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

Além disso, combinamos a verificação facial com a detecção de atividade para confirmar se aquela pessoa é a pessoa específica que você designou. A tabela a seguir ajuda a descrever os detalhes dos recursos de detecção de atividade:

Recurso	Descrição
Detecção de atividade	Determina se uma entrada é real ou falsa, e apenas o servidor de aplicativos tem autoridade para iniciar a verificação de atividade e consultar o resultado.
Detecção de atividade com verificação facial	Determina se uma entrada é real ou falsa e verifica a identidade da pessoa com base em uma imagem de referência que você forneceu. O servidor de aplicativos ou o aplicativo front-end podem fornecer uma imagem de referência. Somente o servidor de aplicativos tem autoridade para inicializar a verificação de atividade e consultar o resultado.

Este tutorial demonstra como operar um aplicativo front-end e um servidor de aplicativos para executar a detecção de atividade e a detecção de atividade com verificação facial em vários SDKs de linguagem.

Pré-requisitos

Assinatura do Azure – Criar uma gratuitamente
Sua conta do Azure deve ter a função Colaborador dos Serviços Cognitivos atribuída para que você concorde com os termos e condições da IA responsável e crie um recurso. Para que essa função seja atribuída à sua conta, siga as etapas descritas na documentação Atribuir funções ou entre em contato com o administrador.
Depois de obter sua assinatura do Azure, crie um recurso da Detecção Facial no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, selecione Ir para recurso.
- Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Detecção Facial.
- Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.
Acessar o SDK do Detecção Facial da Pesquisa Visual de IA do Azure para dispositivos móveis (IOS e Android) e na Web. Para começar, você precisa solicitar os recursos de acesso limitado por reconhecimento facial para obter acesso ao SDK. Para obter mais informações, consulte a página Acesso limitado por Detecção Facial.

Configurar aplicativos front-end e servidores de aplicativos para executar a detecção de atividade

Fornecemos SDKs em diferentes linguagens para aplicativos front-end e servidores de aplicativos. Confira as instruções a seguir para configurar seus aplicativos front-end e servidores de aplicativos.

Baixar o SDK para aplicativo de front-end

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 ao seu aplicativo móvel nativo. O SDK de atividade dá suporte a aplicativos móveis Java/Kotlin para Android, Swift para aplicativos móveis iOS e JavaScript para aplicativos Web:

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

Depois de adicionar o código ao seu aplicativo, o SDK tratará a inicialização da câmera, orientando o usuário final a ajustar a própria posição, compondo o conteúdo de atividade e chamando o serviço de nuvem da Detecção Facial da IA do Azure para processar o conteúdo de atividade.

Baixar a biblioteca de clientes da Detecção Facial da IA do Azure para um servidor de aplicativos

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

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

Criar variáveis de ambiente

Nesse exemplo, grave as credenciais em variáveis de ambiente no computador local que executa o aplicativo.

Acesse o portal do Azure. Se o recurso que você criou na seção Pré-requisitos tiver sido implantado com sucesso, selecione Ir para o Recurso em Próximas Etapas. Encontre a chave e o ponto de extremidade em Gerenciamento de Recursos na página Chaves e ponto de extremidade. Sua chave de recurso não é igual à sua ID de assinatura do Azure.

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

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

Importante

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

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

Windows
Linux

setx FACE_APIKEY <your_key>

setx FACE_ENDPOINT <your_endpoint>

Depois de adicionar as variáveis de ambiente, é aconselhável reiniciar todos os programas em execução que precisarem lê-las, incluindo a janela do console.

export FACE_APIKEY=<your_key>

export FACE_ENDPOINT=<your_endpoint>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc na janela do console para que as alterações entrem em vigor.

Executar a detecção de atividade

As etapas de alto nível envolvidas na orquestração de atividade são ilustradas abaixo:

O aplicativo front-end inicia a verificação de atividade e notifica o servidor de aplicativos.

O servidor de aplicativos cria uma nova sessão de atividade no serviço de Detecção Facial da IA do Azure. O serviço cria uma sessão de atividade 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 atividade são referenciadas na Operação da Sessão de Criação de Atividade.

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

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")
    .setSendResultsToClient(false);

CreateLivenessSessionResult creationResult = sessionClient.createLivenessSession(parameters);
System.out.println("Session created.");
System.out.println("Session id: " + creationResult.getSessionId());
System.out.println("Auth token: " + creationResult.getAuthToken());

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

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

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

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

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

Aqui está um exemplo de corpo da resposta:

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

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

O aplicativo front-end fornece o token de autorização de sessão durante a inicialização do SDK da Visão de IA do Azure.

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

azureAIVisionFaceAnalyzer.token = "<INSERT_TOKEN_HERE>"

Em seguida, o SDK inicia a câmera, orienta o usuário a se posicionar corretamente e, em seguida, prepara o conteúdo para chamar o ponto de extremidade do serviço de detecção de atividade.
O SDK chama o serviço de Detecção Facial da Visão de IA do Azure para executar a detecção de atividade. Depois que o serviço responder, o SDK notificará o aplicativo front-end de que a verificação de atividade foi concluída.
O aplicativo front-end retransmite a conclusão da verificação de atividade para o servidor de aplicativos.

O servidor de aplicativos agora pode consultar o resultado da detecção de atividade do serviço de Detecção Facial da Visão de IA do Azure.

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

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 request id: " + sessionResult.getResult().getRequestId());
System.out.println("Liveness detection received datetime: " + sessionResult.getResult().getReceivedDateTime());
System.out.println("Liveness detection decision: " + sessionResult.getResult().getResponse().getBody().getLivenessDecision());
System.out.println("Session created datetime: " + sessionResult.getCreatedDateTime());
System.out.println("Auth token TTL (seconds): " + sessionResult.getAuthTokenTimeToLiveInSeconds());
System.out.println("Session expired: " + sessionResult.isSessionExpired());
System.out.println("Device correlation id: " + sessionResult.getDeviceCorrelationId());

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 request id: {liveness_result.result.request_id}")
print(f"Liveness detection received datetime: {liveness_result.result.received_date_time}")
print(f"Liveness detection decision: {liveness_result.result.response.body.liveness_decision}")
print(f"Session created datetime: {liveness_result.created_date_time}")
print(f"Auth token TTL (seconds): {liveness_result.auth_token_time_to_live_in_seconds}")
print(f"Session expired: {liveness_result.session_expired}")
print(f"Device correlation id: {liveness_result.device_correlation_id}")

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

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

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

Aqui está um exemplo de 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
}

O servidor de aplicativos poderá excluir a sessão se você não consultar mais o resultado.

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

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

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

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

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

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

Executar a detecção de atividade com verificação facial

A combinação da verificação facial com a detecção de atividade permite a verificação biométrica de uma determinada pessoa suspeita com uma garantia adicional de que ela está fisicamente presente no sistema. A integração da atividade com a verificação é feita em duas partes:

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

Selecionar uma boa imagem de referência

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

Requisitos técnicos

Os formatos de imagem de entrada com suporte incluem JPEG, PNG, GIF (o primeiro quadro), BMP.
O tamanho do arquivo de imagem não deve ser maior do que 6 MB.

Você pode utilizar o atributo qualityForRecognition na operação de detecção facial ao usar modelos de detecção aplicáveis como uma diretriz geral sobre a probabilidade de a imagem ter qualidade suficiente para tentar o reconhecimento facial. Apenas imagens com qualidade "high" são recomendadas para registro de pessoas e as com qualidade igual ou superior a "medium" são recomendadas para cenários de identificação.

Requisitos de composição

A foto está é clara e nítida, sem desfoque, pixelizada, distorcida ou danificada.
A foto não está alterada para remover manchas faciais ou a aparência do rosto.
A foto deve estar em um formato de cor RGB com suporte (JPEG, PNG, WEBP, BMP). O tamanho recomendado de Detecção Facial é de 200x200 pixels. Tamanhos de Detecção Facial maiores que 200x200 pixels não resultarão em qualidade de IA melhor e não devem ter mais de 6 MB.
O usuário não está usando óculos, máscaras, chapéus, fones de ouvido, tocas na cabeça ou coberturas faciais. O rosto deve estar livre de obstruções.
Joias faciais são permitidas desde que não ocultem seu rosto.
Apenas um rosto deve estar visível na foto.
O rosto deve estar em pose neutra voltada para a frente com os dois olhos abertos, com a boca fechada, sem expressões faciais extremas ou inclinação de cabeça.
O rosto deve estar sem sombras ou olhos vermelhos. Se alguma dessas coisas ocorrerem, tire a foto novamente.
O plano de fundo deve ser uniforme e simples, sem nenhuma sombra.
O rosto deve estar centralizado dentro da imagem e preencher pelo menos 50% da imagem.

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

As etapas de alto nível envolvidas na atividade com a orquestração de verificação são ilustradas abaixo:

Forneça a imagem de referência da verificação através de um dos dois métodos a seguir:

O servidor de aplicativos fornece a imagem de referência ao criar a sessão de atividade. Mais informações sobre cada parâmetro de solicitação envolvido na criação de uma sessão de atividade com verificação são referenciadas na Operação da Sessão de Criação de Atividade com Verificação.

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

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")
    .setSendResultsToClient(false);

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

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(
    CreateLivenessSessionContent(
        liveness_operation_mode=LivenessOperationMode.PASSIVE,
        device_correlation_id="723d6d03-ef33-40a8-9682-23a1feb7bccd",
    ),
    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}")

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/singleModal/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',
            },
        },
    ],
});

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

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

curl --request POST --location "${FACE_ENDPOINT}/face/v1.1-preview.1/detectlivenesswithverify/singlemodal/sessions" \
--header "Ocp-Apim-Subscription-Key: ${FACE_APIKEY}" \
--form 'Parameters="{
    \"livenessOperationMode\": \"passive\",
    \"deviceCorrelationId\": \"723d6d03-ef33-40a8-9682-23a1feb7bccd\"
}"' \
--form 'VerifyImage=@"test.png"'

Aqui está um exemplo de 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 front-end fornece a imagem de referência ao inicializar o SDK. Não há suporte para esse cenário na solução web.

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

Not supported.

Agora, o servidor de aplicativos pode consultar o resultado da verificação, além do resultado da atividade.

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

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 request id: " + sessionResult.getResult().getRequestId());
System.out.println("Liveness detection received datetime: " + sessionResult.getResult().getReceivedDateTime());
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());
System.out.println("Session created datetime: " + sessionResult.getCreatedDateTime());
System.out.println("Auth token TTL (seconds): " + sessionResult.getAuthTokenTimeToLiveInSeconds());
System.out.println("Session expired: " + sessionResult.isSessionExpired());
System.out.println("Device correlation id: " + sessionResult.getDeviceCorrelationId());

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 request id: {liveness_result.result.request_id}")
print(f"Liveness detection received datetime: {liveness_result.result.received_date_time}")
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}")
print(f"Session created datetime: {liveness_result.created_date_time}")
print(f"Auth token TTL (seconds): {liveness_result.auth_token_time_to_live_in_seconds}")
print(f"Session expired: {liveness_result.session_expired}")
print(f"Device correlation id: {liveness_result.device_correlation_id}")

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

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

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

Aqui está um exemplo de 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
}

O servidor de aplicativos poderá excluir a sessão se você não consultar mais o resultado.

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

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

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

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

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

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

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços de IA do Azure, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Para saber mais sobre outras opções nas APIs de atividade, consulte a referência do SDK da Visão de IA do Azure.

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

Operações da Sessão Dinâmica

Compartilhar via

Tutorial: detectar atividade em rostos

Introdução

Pré-requisitos

Configurar aplicativos front-end e servidores de aplicativos para executar a detecção de atividade

Baixar o SDK para aplicativo de front-end

Baixar a biblioteca de clientes da Detecção Facial da IA do Azure para um servidor de aplicativos

Criar variáveis de ambiente

Executar a detecção de atividade

Executar a detecção de atividade com verificação facial

Selecionar uma boa imagem de referência

Requisitos técnicos

Requisitos de composição

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

Limpar os recursos

Próximas etapas

Comentários

Recursos adicionais