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

2025-04-22

Dans ce tutoriel, vous allez apprendre à détecter la vivacité des visages, à l’aide d’une combinaison de code côté serveur et d’une application mobile côté client.

Conseil / Astuce

Pour obtenir des informations générales sur la détection de la vivacité des visages, consultez le guide conceptuel.

Ce tutoriel montre comment utiliser une application en front-end et un serveur d’applications pour effectuer la détection d'activité, y compris l’étape facultative de vérification faciale, sur différentes plateformes et langues.

Important

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

Conseil / Astuce

Une fois les prérequis terminés, vous pouvez essayer l’expérience liveness iOS de TestFlight et l’expérience web-liveness de Vision Studio. En outre, vous pouvez également générer et exécuter un exemple frontal complet (sur iOS, Android ou Web) à partir de la section Exemples .

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 Détection de visages 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ès au Kit de développement logiciel (SDK) azure AI Vision Face Client pour Mobile (IOS et Android) et au 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.
Connaissance de la fonctionnalité de détection de vivacité du visage. Consultez le guide conceptuel.

Préparer des kits SDK

Nous fournissons des kits SDK dans différents langages pour simplifier le développement sur les applications frontales et les serveurs d’applications :

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

Suivez les instructions fournies dans le référentiel GitHub azure-ai-vision-sdk pour intégrer l’interface utilisateur et le code à 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.

Vous pouvez surveiller la section Releases du dépôt du KIT DE développement logiciel (SDK) pour connaître les nouvelles mises à jour de version du SDK.

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 README dotnet
Pour Java, suivez les instructions du README Java
Pour Python, suivez les instructions du fichier Lisez-moi Python
Pour JavaScript, suivez les instructions du fichier Lisez-moi JavaScript

Important

Pour créer des variables d’environnement pour votre clé et point de terminaison de service Azure Visage, consultez le guide de démarrage rapide

Effectuer la détection de la vivacité

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",
    EnableSessionImage = true,
};

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")
    .setEnableSessionImage(true);

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",
        enable_session_image=True,
    )
)
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-sessions').post({
    body: {
        livenessOperationMode: 'Passive',
        deviceCorrelationId: '723d6d03-ef33-40a8-9682-23a1feb7bccd',
        enableSessionImage: true,
    },
});

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.2/detectLiveness-sessions" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%" ^
--header "Content-Type: application/json" ^
--data ^
"{ ^
    ""livenessOperationMode"": ""passive"", ^
    ""deviceCorrelationId"": ""723d6d03-ef33-40a8-9682-23a1feb7bccd"", ^
    ""enableSessionImage"": ""true"" ^
}"

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

Un exemple du corps de réponse :

{
    "sessionId": "a6e7193e-b638-42e9-903f-eaf60d2b40a5",
    "authToken": "<session-authorization-token>",
    "status": "NotStarted",
    "modelVersion": "2024-11-15",
    "results": {
        "attempts": []
    }
}

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

L’application front-end utilise le jeton d’autorisation de la session pour démarrer le détecteur d’authenticité du visage, qui lance le flux d’authenticité.

    FaceLivenessDetector(
        sessionAuthorizationToken = FaceSessionToken.sessionToken,
        verifyImageFileContent = FaceSessionToken.sessionSetInClientVerifyImage,
        deviceCorrelationId = "null",
        onSuccess = viewModel::onSuccess,
        onError = viewModel::onError
    )

struct HostView: View {
   @State var livenessDetectionResult: LivenessDetectionResult? = nil
   var token: String
   var body: some View {
       if livenessDetectionResult == nil {
           FaceLivenessDetectorView(result: $livenessDetectionResult,
                                    sessionAuthorizationToken: token)
       } else if let result = livenessDetectionResult {
           VStack {
               switch result { 
                   case .success(let success):
                   /// <#show success#>
                   case .failure(let error):
                   /// <#show failure#>
               }
           }
       }
   }
}

faceLivenessDetector = document.createElement("azure-ai-vision-face-ui");
document.getElementById("container").appendChild(faceLivenessDetector);
faceLivenessDetector.start(session.authToken)

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 de la vivacité. Une fois que le service répond, le kit de développement logiciel (SDK) informe l’application front-end que la vérification de la vivacité a été effectuée.
L’application front-end relaye la complétion de la vérification de la vivacité au serveur d’applications.

Le serveur d’applications peut désormais rechercher le résultat de la détection de vivacité 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 decision: {sessionResult.Result?.Response.Body.LivenessDecision}");

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 decision: " + sessionResult.getResult().getResponse().getBody().getLivenessDecision());

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 decision: {liveness_result.result.response.body.liveness_decision}")

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.2/detectLiveness-sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

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

Un exemple du corps de réponse :

{
    "sessionId": "0acf6dbf-ce43-42a7-937e-705938881d62",
    "authToken": "",
    "status": "Succeeded",
    "modelVersion": "2024-11-15",
    "results": {
        "attempts": [
        {
            "attemptId": 1,
            "attemptStatus": "Succeeded",
            "result": {
            "livenessDecision": "realface",
            "targets": {
                "color": {
                "faceRectangle": {
                    "top": 763,
                    "left": 320,
                    "width": 739,
                    "height": 938
                }
                }
            },
            "digest": "517A0E700859E42107FA47E957DD12F54211C1A021A969CD391AC38BB88295A2",
            "sessionImageId": "Ab9tzwpDzqdCk35wWTiIHWJzzPr9fBCNSqBcXnJmDjbI"
            }
        }
        ]
    }
}

Une fois les résultats de la session interrogés, le serveur de l’application peut supprimer la session.

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.2/detectLiveness-sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

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

Effectuer une détection de vitalité avec vérification faciale

La combinaison de la vérification des visages avec la détection de la vivacité 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 y a deux éléments pour l'intégration de la caractéristique de vivacité avec la vérification :

Étape 1 - Sélectionner une image de référence

Suivez les conseils répertoriés dans les exigences de composition des scénarios de vérification d’ID pour vous assurer que vos images d’entrée donnent les résultats de reconnaissance les plus précis.

Étape 2 : configurez l’orchestration de la vivacité avec vérification.

Les étapes de haut niveau impliquées dans l'orchestration de la vivacité 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",
    EnableSessionImage = true,
};
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")
    .setEnableSessionImage(true);

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",
        enable_session_image=True,
    ),
    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-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',
                enableSessionImage: true,
            },
        },
    ],
});

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.2/detectLivenesswithVerify-sessions" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%" ^
--form "Parameters=""{\\\""livenessOperationMode\\\"": \\\""passive\\\"", \\\""deviceCorrelationId\\\"": \\\""723d6d03-ef33-40a8-9682-23a1feb7bccd\\\"", ""enableSessionImage"": ""true""}""" ^
--form "VerifyImage=@""test.png"""

curl --request POST --location "${FACE_ENDPOINT}/face/v1.2/detectLivenesswithVerify-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 :

{
    "sessionId": "3847ffd3-4657-4e6c-870c-8e20de52f567",
    "authToken": "<session-authorization-token>",
    "status": "NotStarted",
    "modelVersion": "2024-11-15",
    "results": {
        "attempts": [],
        "verifyReferences": [
        {
            "referenceType": "image",
            "faceRectangle": {
            "top": 98,
            "left": 131,
            "width": 233,
            "height": 300
            },
            "qualityForRecognition": "high"
        }
        ]
    }
}

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.

    FaceLivenessDetector(
        sessionAuthorizationToken = FaceSessionToken.sessionToken,
        verifyImageFileContent = FaceSessionToken.sessionSetInClientVerifyImage,
        deviceCorrelationId = "null",
        onSuccess = viewModel::onSuccess,
        onError = viewModel::onError
    )

struct HostView: View {
    @State var livenessDetectionResult: LivenessDetectionResult? = nil
    var token: String
    var body: some View {
        if livenessDetectionResult == nil {
            FaceLivenessDetectorView(result: $livenessDetectionResult,
                                        sessionAuthorizationToken: token)
        } else if let result = livenessDetectionResult {
            VStack {
                switch result { 
                    case .success(let success):
                    /// <#show success#>
                    case .failure(let error):
                    /// <#show failure#>
                }
            }
        }
    }
}

Not supported.

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

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

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

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

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

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

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

Un exemple du corps de réponse :

{
    "sessionId": "93fd6f13-4161-41df-8a22-80a38ef53836",
    "authToken": "",
    "status": "Succeeded",
    "modelVersion": "2024-11-15",
    "results": {
        "attempts": [
            {
                "attemptId": 1,
                "attemptStatus": "Succeeded",
                "result": {
                "livenessDecision": "realface",
                "targets": {
                    "color": {
                        "faceRectangle": {
                            "top": 669,
                            "left": 203,
                            "width": 646,
                            "height": 724
                        }
                    }
                },
                "digest": "EE664438FDF0535C6344A468181E4DDD4A34AC89582D4FD6E9E8954B843C7AA7",
                "verifyResult": {
                        "matchConfidence": 0.08172279,
                        "isIdentical": false
                    }
                }
            }
        ],
        "verifyReferences": [
        {
            "faceRectangle": {
                "top": 98,
                "left": 131,
                "width": 233,
                "height": 300
                },
            "qualityForRecognition": "high"
        }
        ]
    }
}

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.2/detectLivenesswithVerify-sessions/<session-id>" ^
--header "Ocp-Apim-Subscription-Key: %FACE_APIKEY%"

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

Effectuer d’autres opérations de visage après la détection de la vivacité

Si vous le souhaitez, vous pouvez effectuer d'autres opérations de visage après la vérification de la vivacité, telles que l'analyse du visage (pour obtenir des attributs de visage, par exemple) et/ou des opérations sur l'identité du visage.

Pour l’activer, vous devez définir le paramètre « enableSessionImage » sur « true » pendant l’étape deSession-Creation.
Une fois la session terminée, vous pouvez extraire le « sessionImageId » à partir de l’étape session-Get-Result.
Vous pouvez maintenant soit télécharger l’image de session (référencée dans l'API Liveness Get Session Image Operation), soit fournir le « sessionImageId » dans l’opération Detect from Session Image ID API pour continuer à effectuer d’autres analyses de visage ou opérations d’identité faciale. Pour plus d’informations sur ces opérations, consultez les concepts de détection des visages et les concepts de reconnaissance faciale.

Options de support

En plus d’utiliser les principales options de prise en charge des services Azure AI, vous pouvez également publier vos questions dans la section problèmes du dépôt du KIT de développement logiciel (SDK).

Pour savoir comment intégrer la solution liveness à votre application existante, 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 de vivacité

Partager via

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

Prérequis

Préparer des kits SDK

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

Effectuer la détection de la vivacité

Effectuer une détection de vitalité avec vérification faciale

Étape 1 - Sélectionner une image de référence

Étape 2 : configurez l’orchestration de la vivacité avec vérification.

Effectuer d’autres opérations de visage après la détection de la vivacité

Options de support

Contenu connexe

Commentaires

Ressources supplémentaires