Partager via

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

  • Article

La détection dynamique de visage peut être utilisée pour déterminer si un visage dans un flux vidéo d’entrée est réel (live) ou faux (falsifié). 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 de liveness est de s’assurer que le système interagit avec une personne physiquement présente au moment de l’authentification. De tels systèmes sont de plus en plus importants avec la montée en puissance de la finance numérique, du contrôle d’accès à distance et des processus de vérification d’identité en ligne.

La solution de détection dynamique d’Azure AI Visage protège avec succès contre une divers types d’usurpation allant des imprimés papier aux masques 2d/3d en passant par les présentations d’usurpation sur les téléphones et les ordinateurs portables. La détection de liveness est un domaine actif de la recherche, avec des améliorations continues apportées pour contrer les attaques de usurpation de plus en plus sophistiquées au fil du temps. Les améliorations continues seront déployées sur le client et les composants de service au fil du temps, car la solution globale sera plus robuste pour de 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.

Diagramme du workflow liveness dans Azure AI Visage.

  • 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 les détails des fonctionnalités de détection liveness :

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 :

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 :

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.

Conseil

N’incluez pas la clé directement dans votre code et ne la publiez jamais publiquement. Pour découvrir d’autres options d’authentification telles qu’Azure Key Vault, veuillez consulter l’article sur la sécurité d’Azure AI services.

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.

  1. Pour définir la variable d’environnement FACE_APIKEY, remplacez <your_key> par l’une des clés de votre ressource.
  2. Pour définir la FACE_ENDPOINTvariable d’environnement, remplacez <your_endpoint> par le point de terminaison de votre ressource.
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.

Effectuer la détection liveness

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

Diagramme du workflow liveness dans Azure AI Visage.

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

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

    Un exemple du corps de réponse :

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

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

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

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

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

  7. L’application front-end relaye la complétion de la vérification de liveness au serveur d’applications.

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

    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
}

  9. 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.");

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 :

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

Diagramme du workflow de vérification des visages avec liveness d’Azure AI Visage.

Sélectionner une bonne 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 :

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

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

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

    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
}

  3. 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.");

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.

Étapes suivantes

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.