Tutoriel : Détecter la spontanéité dans les visages

Article
09/25/2024

La détection dynamique du visage est utilisée pour déterminer si un visage dans un flux vidéo d’entrée est réel (en direct) ou faux (usurpé). Il s’agit d’un bloc de construction important dans un système d’authentification biométrique pour empêcher les imposteurs d’accéder au système à l’aide d’une photographie, d’une vidéo, d’un masque ou d’un autre moyen d’usurper l’identité d’une autre personne.

L’objectif de la détection dynamique est de s’assurer que le système interagit en direct avec une personne physiquement présente au moment de l’authentification. Avec l’essor de la finance numérique, du contrôle d’accès à distance et des processus de vérification de l’identité en ligne, ces systèmes deviennent de plus en plus importants.

La solution Azure AI de détection dynamique des visages (Azure AI Face liveness detection) permet de se protéger efficacement contre différents types d’usurpation d’identité tels que les impressions sur papier, les masques 2D/3D et les présentations frauduleuses sur les téléphones et les ordinateurs portables. La détection dynamique est un domaine de recherche actif, qui ne cesse d’être amélioré pour contrer les attaques par usurpation d’identité, qui deviennent de plus en plus sophistiquées. Au fil du temps, nous apportons des améliorations continues au client et aux composants du service, afin que la solution globale soit plus résistante face aux nouveaux types d’attaques.

Important

Les kits SDK clients Face pour liveness sont une fonctionnalité contrôlée. Vous devez demander l’accès à la fonctionnalité liveness en remplissant le formulaire d’admission Face Recognition. Lorsque votre abonnement Azure est autorisé à y accéder, vous pouvez télécharger le Kit de développement logiciel (SDK) Face liveness.

Introduction

L’intégration de la solution liveness implique deux composants distincts : une application web/mobile front-end et un serveur/orchestrateur d’applications.

Application front-end : l’application front-end reçoit l’autorisation du serveur d’applications pour lancer la détection liveness. Son objectif principal est d’activer la caméra et de guider les utilisateurs finaux avec précision dans le processus de détection liveness.
Serveur d’applications : le serveur d’applications sert de serveur principal pour créer des sessions de détection liveness et obtenir un jeton d’autorisation auprès du service Visage pour une session particulière. Ce jeton autorise l’application front-end à effectuer la détection liveness. Les objectifs du serveur d’applications sont de gérer les sessions, d’accorder l’autorisation à l’application front-end et d’afficher les résultats du processus de détection liveness.

En outre, nous allons combiner la vérification des visages avec la détection liveness pour vérifier si la personne est la personne spécifique que vous avez désignée. Le tableau suivant décrit en détail les fonctionnalités de détection dynamique :

Fonctionnalité	Description
Détection de liveness	Détermine si une entrée est réelle ou fausse, et seul le serveur d’applications a l’autorité de démarrer la vérification liveness et d’interroger le résultat.
Détection liveness avec vérification des visages	Détermine si une entrée est réelle ou fausse et vérifiez l’identité de la personne en fonction d’une image de référence que vous avez fournie. Le serveur d’applications ou l’application front-end peut fournir une image de référence. Seul le serveur d’applications dispose de l’autorité permettant d’initialiser la vérification liveness et d’interroger le résultat.

Ce tutoriel montre comment utiliser une application front-end et un serveur d’applications pour effectuer une détection liveness et une détection liveness avec la vérification des visages sur différents kits de développement logiciel (SDK) linguistiques.

Prérequis

Abonnement Azure - En créer un gratuitement
Votre compte Azure doit disposer d’un rôle Contributeur Cognitive Services attribué pour vous permettre d’accepter les termes de l’IA responsable et de créer une ressource. Pour que ce rôle soit attribué à votre compte, suivez les étapes de la documentation Attribuer des rôles ou contactez votre administrateur.
Une fois que vous avez votre abonnement Azure, créez une ressource Visage dans le Portail Azure pour obtenir votre clé et votre point de terminaison. À la fin du déploiement, sélectionnez Accéder à la ressource.
- Vous avez besoin de la clé et du point de terminaison à partir de la ressource que vous créez pour connecter votre application au service Face.
- Vous pouvez utiliser le niveau tarifaire Gratuit (F0) pour tester le service, puis passer par la suite à un niveau payant pour la production.
Accéder au SDK Azure AI Vision Face Client pour mobile (IOS et Android) et web. Pour commencer, vous devez appliquer les fonctionnalités d’accès limité à la reconnaissance faciale pour accéder au Kit de développement logiciel (SDK). Pour plus d’informations, consultez la page accès limité à la reconnaissance faciale.

Configurer des applications front-end et des serveurs d’applications pour qu’ils effectuent la détection dynamique

Nous fournissons des kits SDK dans différentes langues pour les applications front-end et les serveurs d’applications. Consultez les instructions suivantes pour configurer vos applications front-end et vos serveurs d’applications.

Télécharger le SDK pour l’application front-end

Une fois que vous avez accès au SDK, suivez les instructions du dépôt GitHub azure-ai-vision-sdk pour intégrer l’interface utilisateur et le code dans votre application mobile native. Le SDK liveness prend en charge Java/Kotlin pour les applications mobiles Android, Swift pour les applications mobiles iOS et JavaScript pour les applications web :

Pour Swift iOS, suivez les instructions de l’exemple iOS
Pour Kotlin/Java Android, suivez les instructions de l’exemple Android
Pour JavaScript Web, suivez les instructions de l’exemple Web

Une fois le code ajouté à votre application, le SDK démarre l’appareil photo, guide l’utilisateur final pour ajuster sa position, compose la charge utile dynamique et appelle le service cloud Azure AI Visage pour traiter la charge utile dynamique.

Télécharger la bibliothèque de client Azure AI Visage pour un serveur d’applications

Le serveur d’applications/orchestrateur est responsable du contrôle du cycle de vie d’une session liveness. Le serveur d’applications doit créer une session avant d’effectuer la détection liveness, puis il peut interroger le résultat et supprimer la session lorsque la vérification liveness est terminée. Nous proposons une bibliothèque dans différentes langues pour implémenter facilement votre serveur d’applications. Suivez les étapes suivantes pour installer le package que vous souhaitez :

Pour C#, suivez les instructions du fichier Lisez-moi dotnet
Pour Java, suivez les instructions du fichier Lisez-moi Java
Pour Python, suivez les instructions du fichier Lisez-moi Python
Pour JavaScript, suivez les instructions du fichier Lisez-moi JavaScript

Créer des variables d’environnement

Dans cet exemple, écrivez vos informations d’identification dans des variables d’environnement sur l’ordinateur local exécutant l’application.

Accédez au portail Azure. Si la ressource que vous avez créée dans la section Prérequis a été correctement déployée, sélectionnez Accéder à la ressource sous Étapes suivantes. Vous trouverez votre clé et votre point de terminaison sous Gestion des ressources dans la page Clés et point de terminaison. Votre clé de ressource n’est pas la même que votre ID d’abonnement Azure.

Pour définir la variable d’environnement de votre clé et point de terminaison, ouvrez une fenêtre de console et suivez les instructions relatives à votre système d’exploitation et à votre environnement de développement.

Pour définir la variable d’environnement FACE_APIKEY, remplacez <your_key> par l’une des clés de votre ressource.
Pour définir la FACE_ENDPOINTvariable d’environnement, remplacez <your_endpoint> par le point de terminaison de votre ressource.

Important

Si vous utilisez une clé API, stockez-la en toute sécurité dans un autre emplacement, par exemple dans Azure Key Vault. N'incluez pas la clé API directement dans votre code et ne la diffusez jamais publiquement.

Pour plus d’informations sur la sécurité des services IA, consultez Authentifier les demandes auprès d’Azure AI services.

Windows
Linux

setx FACE_APIKEY <your_key>

setx FACE_ENDPOINT <your_endpoint>

Après avoir ajouté les variables d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui les liront, y compris la fenêtre de console.

export FACE_APIKEY=<your_key>

export FACE_ENDPOINT=<your_endpoint>

Après avoir ajouté les variables d’environnement, exécutez source ~/.bashrc à partir de la fenêtre de console pour appliquer les changements.

Effectuer la détection liveness

Les étapes générales impliquées dans l’orchestration liveness sont illustrées ci-dessous :

L’application front-end démarre la vérification de liveness et notifie le serveur d’applications.

Le serveur d’applications crée une session liveness avec Azure AI Face Service. Le service crée une session liveness et répond avec un jeton d’autorisation de session. Vous trouverez plus d’informations sur chaque paramètre de requête impliqué dans la création d’une session liveness en référence dans Opération de création de session 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}");

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

Un exemple du corps de réponse :

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

Le serveur d’applications fournit le jeton d’autorisation de session à l’application front-end.

L’application front-end fournit le jeton d’autorisation de session pendant l’initialisation du SDK 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>"

azureAIVisionFaceAnalyzer.token = "<INSERT_TOKEN_HERE>"

Le SDK démarre ensuite la caméra, guide l’utilisateur pour qu’il se positionne correctement, puis prépare la charge utile pour appeler le point de terminaison du service de détection dynamique.
Le Kit de développement logiciel (SDK) appelle le service Azure AI Vision Face pour effectuer la détection liveness. Une fois que le service répond, le kit de développement logiciel (SDK) informe l’application front-end que la vérification de l’activité a été effectuée.
L’application front-end relaye la complétion de la vérification de liveness au serveur d’applications.

Le serveur d’applications peut désormais rechercher le résultat de la détection liveness à partir du service 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}");

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

Un exemple du corps de réponse :

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

Le serveur d’applications peut supprimer la session si vous n’interrogez plus son résultat.

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

Effectuer une détection liveness avec la vérification des visages

La combinaison de la vérification des visages avec liveness permet la vérification biométrique d’une personne d’intérêt particulière avec une garantie supplémentaire que la personne est physiquement présente dans le système. Il existe deux parties pour intégrer liveness à la vérification :

Sélectionnez une bonne image de référence.
Configurez l’orchestration de la durée de vie avec vérification.

Sélectionnez une image de référence

Utilisez les conseils suivants pour vous assurer que vos images d’entrée fournissent les résultats de reconnaissance les plus précis.

Exigences techniques

Les formats d’image d’entrée pris en charge sont JPEG, PNG, GIF (la première image) et BMP.
La taille du fichier image ne doit pas dépasser 6 Mo.

Vous pouvez utiliser l’attribut qualityForRecognition dans l’opération de détection de visages lors de l’utilisation de modèles de détection applicables en tant que directive générale indiquant si l’image est susceptible d’avoir une qualité suffisante pour tenter la reconnaissance faciale. Seules des images de qualité "high" sont recommandées pour l’inscription de personnes, et une qualité supérieure à "medium" est recommandée pour les scénarios d’identification.

Exigences de composition

La photo est claire et nette, pas floue, pixelisée, déformée ou endommagée.
La photo n’est pas modifiée pour supprimer les taches de visage ou l’apparence du visage.
La photo doit être au format RVB pris en charge (JPEG, PNG, WEBP, BMP). La taille recommandée du visage est de 200 pixels x 200 pixels. Les tailles de visage supérieures à 200 pixels x 200 pixels n’entraînent pas une meilleure qualité de l’IA, mais également pas de taille supérieure à 6 Mo.
L’utilisateur ne porte pas de lunettes, masques, chapeaux, casques, couvertures de tête ou couvertures faciales. Le visage doit être libre de toute obstruction.
Les bijoux sur le visage sont autorisés à condition qu’ils ne masquent pas votre visage.
Un seul visage doit être visible dans la photo.
Le visage doit être neutre et tourné vers l'avant, les deux yeux ouverts, la bouche fermée, sans expression faciale extrême ni inclinaison de la tête.
Le visage ne doit pas présenter d'ombres ou des yeux rouges. Reprenez la photo si l’une ou l’autre survient.
L'arrière-plan doit être uniforme et uni, sans aucune ombre.
Le visage doit être centré dans l'image et occuper au moins 50 % de l'image.

Configurez l’orchestration de la durée de vie avec vérification.

Les étapes de haut niveau impliquées dans l'orchestration de la sécurité et de la vérification sont illustrées ci-dessous :

Fournir l’image de référence de vérification par l’une des deux méthodes suivantes :

Le serveur d’applications fournit l’image de référence lors de la création de la session liveness. Vous trouverez plus d’informations sur chaque paramètre de requête impliqué dans la création d’une session liveness avec vérification en référence dans Opération de création de session liveness avec Verify.

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

String endpoint = System.getenv("FACE_ENDPOINT");
String accountKey = System.getenv("FACE_APIKEY");

FaceSessionClient sessionClient = new FaceSessionClientBuilder()
    .endpoint(endpoint)
    .credential(new AzureKeyCredential(accountKey))
    .buildClient();

CreateLivenessWithVerifySessionContent parameters = new CreateLivenessWithVerifySessionContent(LivenessOperationMode.PASSIVE)
    .setDeviceCorrelationId("723d6d03-ef33-40a8-9682-23a1feb7bccd")
    .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(
    CreateLivenessWithVerifySessionContent(
        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"'

Un exemple du corps de réponse :

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

L’application front-end fournit l’image de référence lors de l’initialisation du kit de développement logiciel (SDK). Ce scénario n’est pas pris en charge dans la solution 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.

Le serveur d’applications peut désormais interroger le résultat de vérification en plus du résultat de la durée de vie.

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

Un exemple du corps de réponse :

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

Le serveur d’applications peut supprimer la session si vous n’interrogez plus son résultat.

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

Nettoyer les ressources

Si vous souhaitez nettoyer et supprimer un abonnement Azure AI services, vous pouvez supprimer la ressource ou le groupe de ressources. La suppression du groupe de ressources efface également les autres ressources qui y sont associées.

Pour en savoir plus sur d’autres options dans les API liveness, consultez la référence du kit de développement logiciel (SDK) Azure AI Vision.

Pour en savoir plus sur les fonctionnalités disponibles pour orchestrer la solution liveness, consultez la référence de l’API REST Session.

Opérations de session liveness

Partager via

Tutoriel : Détecter la spontanéité dans les visages

Introduction

Prérequis

Configurer des applications front-end et des serveurs d’applications pour qu’ils effectuent la détection dynamique

Télécharger le SDK pour l’application front-end

Télécharger la bibliothèque de client Azure AI Visage pour un serveur d’applications

Créer des variables d’environnement

Effectuer la détection liveness

Effectuer une détection liveness avec la vérification des visages

Sélectionnez une image de référence

Exigences techniques

Exigences de composition

Configurez l’orchestration de la durée de vie avec vérification.

Nettoyer les ressources

Commentaires

Ressources supplémentaires

Partager via

Tutoriel : Détecter la spontanéité dans les visages

Introduction

Prérequis

Configurer des applications front-end et des serveurs d’applications pour qu’ils effectuent la détection dynamique

Télécharger le SDK pour l’application front-end

Télécharger la bibliothèque de client Azure AI Visage pour un serveur d’applications

Créer des variables d’environnement

Effectuer la détection liveness

Effectuer une détection liveness avec la vérification des visages

Sélectionnez une image de référence

Exigences techniques

Exigences de composition

Configurez l’orchestration de la durée de vie avec vérification.

Nettoyer les ressources

Contenu connexe

Commentaires

Ressources supplémentaires