Självstudie: Identifiera livskraft i ansikten

Artikel
09/26/2024

Identifiering av ansiktsuppspelning används för att avgöra om ett ansikte i en indatavideoström är verklig (live) eller falsk (förfalskning). Det är en viktig byggsten i ett biometriskt autentiseringssystem för att förhindra att bedragare får åtkomst till systemet med hjälp av ett fotografi, en video, en mask eller något annat sätt att personifiera en annan person.

Målet med livenessidentifiering är att säkerställa att systemet interagerar med en fysiskt närvarande, levande person vid tidpunkten för autentiseringen. Dessa system blir allt viktigare med den ökade digitala ekonomin, fjärråtkomstkontroll och identitetsverifieringsprocesser online.

Lösningen för identifiering av ansiktsigenkänning i Azure AI skyddar mot olika typer av förfalskningar, allt från pappersutskrifter, 2D/3D-masker och falska presentationer på telefoner och bärbara datorer. Liveness detection är ett aktivt område för forskning, med kontinuerliga förbättringar som görs för att motverka alltmer sofistikerade förfalskningsattacker. Kontinuerliga förbättringar distribueras till klienten och tjänstkomponenterna över tid när den övergripande lösningen blir mer robust för nya typer av attacker.

Viktigt!

Ansiktsklient-SDK:er för liveness är en gated-funktion. Du måste begära åtkomst till liveness-funktionen genom att fylla i intagsformuläret för ansiktsigenkänning. När din Azure-prenumeration beviljas åtkomst kan du ladda ned Face liveness SDK.

Introduktion

Integreringen av liveness-lösningen omfattar två distinkta komponenter: en klientdelsmobil/webbapp och en appserver/orchestrator.

Klientdelsprogram: Klientdelsprogrammet får auktorisering från appservern för att initiera livenessidentifiering. Dess främsta mål är att aktivera kameran och vägleda slutanvändare korrekt genom processen för livenessidentifiering.
Appserver: Appservern fungerar som en serverdelsserver för att skapa sessioner för livenessidentifiering och hämta en auktoriseringstoken från ansiktstjänsten för en viss session. Den här token ger klientdelsprogrammet behörighet att utföra livenessidentifiering. Appserverns mål är att hantera sessionerna, att bevilja auktorisering för klientdelsprogrammet och att visa resultatet av processen för livenessidentifiering.

Dessutom kombinerar vi ansiktsverifiering med livenessidentifiering för att verifiera om personen är den specifika person som du har utsett. I följande tabell beskrivs information om funktionerna för livenessidentifiering:

Funktion	beskrivning
Identifiering av liveness	Fastställ att indata är verkliga eller falska, och endast appservern har behörighet att starta liveness-kontrollen och köra frågor mot resultatet.
Identifiering av livskraft med ansiktsverifiering	Fastställ att en indata är verklig eller falsk och verifiera identiteten för personen baserat på en referensbild som du angav. Antingen kan appservern eller klientdelsprogrammet tillhandahålla en referensbild. Endast appservern har behörighet att initiera liveness-kontrollen och köra frågor mot resultatet.

Den här självstudien visar hur du använder ett klientdelsprogram och en appserver för att utföra identifiering av liveness och liveness med ansiktsverifiering på olika språk-SDK:er.

Förutsättningar

Azure-prenumeration – Skapa en kostnadsfritt
Ditt Azure-konto måste ha tilldelats rollen Cognitive Services-deltagare för att du ska kunna godkänna de ansvarsfulla AI-villkoren och skapa en resurs. Om du vill tilldela den här rollen till ditt konto följer du stegen i dokumentationen Tilldela roller eller kontaktar administratören.
När du har din Azure-prenumeration skapar du en Ansiktsresurs i Azure Portal för att hämta din nyckel och slutpunkt. När den har distribuerats väljer du Gå till resurs.
- Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till ansiktstjänsten.
- Du kan använda den kostnadsfria prisnivån (F0) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.
Åtkomst till Azure AI Vision Face Client SDK för mobil (IOS och Android) och webben. För att komma igång måste du ansöka om funktionerna för begränsad åtkomst för ansiktsigenkänning för att få åtkomst till SDK:t. Mer information finns på sidan Ansiktsbegränsade åtkomst .

Konfigurera klientdelsprogram och appservrar för att utföra livenessidentifiering

Vi tillhandahåller SDK:er på olika språk för klientdelsprogram och appservrar. Se följande instruktioner för att konfigurera klientdelsprogram och appservrar.

Ladda ned SDK för klientdelsprogram

När du har åtkomst till SDK följer du anvisningarna på GitHub-lagringsplatsen azure-ai-vision-sdk för att integrera användargränssnittet och koden i ditt interna mobilprogram. Liveness SDK stöder Java/Kotlin för Mobila Android-program, Swift för iOS-mobilappar och JavaScript för webbprogram:

För Swift iOS följer du anvisningarna i iOS-exemplet
För Kotlin/Java Android följer du anvisningarna i Android-exemplet
För JavaScript Web följer du anvisningarna i webbexemplet

När du har lagt till koden i ditt program hanterar SDK:n start av kameran, vägleder slutanvändaren när de justerar sin position, skriver nyttolasten för liveness och anropar Azure AI Face-molntjänsten för att bearbeta nyttolasten för liveness.

Ladda ned Azure AI Face-klientbiblioteket för appservern

Appservern/orkestratorn ansvarar för att kontrollera livscykeln för en liveness-session. Appservern måste skapa en session innan du utför livenessidentifiering, och sedan kan den köra frågor mot resultatet och ta bort sessionen när liveness-kontrollen är klar. Vi erbjuder ett bibliotek på olika språk för att enkelt implementera din appserver. Följ de här stegen för att installera det paket du vill ha:

För C#följer du anvisningarna i dotnet readme
För Java följer du anvisningarna i Java readme
För Python följer du anvisningarna i Python-läsningen
För JavaScript följer du anvisningarna i JavaScript-readme

Skapa miljövariabler

I det här exemplet skriver du dina autentiseringsuppgifter till miljövariabler på den lokala dator som kör programmet.

Gå till Azure-portalen. Om resursen som du skapade i avsnittet Förutsättningar har distribuerats väljer du Gå till resurs under Nästa steg. Du hittar din nyckel och slutpunkt under Resurshantering på sidan Nycklar och slutpunkt . Resursnyckeln är inte samma som ditt Azure-prenumerations-ID.

Om du vill ange miljövariabeln för din nyckel och slutpunkt öppnar du ett konsolfönster och följer anvisningarna för operativsystemet och utvecklingsmiljön.

Om du vill ange FACE_APIKEY miljövariabeln ersätter du <your_key> med en av nycklarna för resursen.
Om du vill ange FACE_ENDPOINT miljövariabeln ersätter du <your_endpoint> med slutpunkten för resursen.

Viktigt!

Om du använder en API-nyckel lagrar du den på ett säkert sätt någon annanstans, till exempel i Azure Key Vault. Inkludera inte API-nyckeln direkt i koden och publicera den aldrig offentligt.

Mer information om säkerhet för AI-tjänster finns i Autentisera begäranden till Azure AI-tjänster.

Windows
Linux

setx FACE_APIKEY <your_key>

setx FACE_ENDPOINT <your_endpoint>

När du har lagt till miljövariablerna kan du behöva starta om alla program som körs som läser miljövariablerna, inklusive konsolfönstret.

export FACE_APIKEY=<your_key>

export FACE_ENDPOINT=<your_endpoint>

När du har lagt till miljövariablerna kör source ~/.bashrc du från konsolfönstret för att göra ändringarna effektiva.

Utföra livenessidentifiering

De övergripande stegen som ingår i orkestrering av liveness illustreras nedan:

Klientdelsprogrammet startar live-kontrollen och meddelar appservern.

Appservern skapar en ny liveness-session med Azure AI Face Service. Tjänsten skapar en liveness-session och svarar tillbaka med en sessionsauktoriseringstoken. Mer information om varje parameter för begäran som ingår i skapandet av en liveness-session finns i Liveness Create Session Operation (Skapa sessionsåtgärd för 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"
}'

Ett exempel på svarstexten:

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

Appservern tillhandahåller sessionsauktoriseringstoken tillbaka till klientdelsprogrammet.

Klientdelsprogrammet tillhandahåller sessionsauktoriseringstoken under Azure AI Vision SDK:s initiering.

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

SDK startar sedan kameran, vägleder användaren att placera korrekt och förbereder sedan nyttolasten för att anropa tjänstslutpunkten för livenessidentifiering.
SDK:n anropar Tjänsten Azure AI Vision Face för att utföra livenessidentifieringen. När tjänsten svarar meddelar SDK klientdelsappen att live-kontrollen har slutförts.
Klientdelsprogrammet vidarebefordrar live-kontrollens slutförande till appservern.

Appservern kan nu fråga efter livenessidentifieringsresultatet från Azure AI Vision Face Service.

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

Ett exempel på svarstexten:

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

Appservern kan ta bort sessionen om du inte kör frågor mot resultatet längre.

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

Utföra livenessidentifiering med ansiktsverifiering

Att kombinera ansiktsverifiering med livenessidentifiering möjliggör biometrisk verifiering av en viss person av intresse med en extra garanti för att personen är fysiskt närvarande i systemet. Det finns två delar för att integrera livskraft med verifiering:

Välj en bra referensbild.
Konfigurera orkestrering av liveness med verifiering.

Välj en referensbild

Använd följande tips för att se till att dina indatabilder ger de mest exakta igenkänningsresultaten.

Tekniska krav

De indatabildformat som stöds är JPEG, PNG, GIF (den första ramen), BMP.
Bildfilens storlek får inte vara större än 6 MB.

Du kan använda qualityForRecognition attributet i ansiktsidentifieringsåtgärden när du använder tillämpliga identifieringsmodeller som en allmän riktlinje för om bilden sannolikt har tillräcklig kvalitet för att försöka identifiera ansiktet. Endast "high" kvalitetsbilder rekommenderas för personregistrering och kvalitet på eller högre "medium" rekommenderas för identifieringsscenarier.

Krav på sammansättning

Fotot är tydligt och skarpt, inte suddigt, pixeliserat, förvrängt eller skadat.
Foto ändras inte för att ta bort ansiktsfläckar eller ansiktsutseende.
Fotot måste vara i ett RGB-format som stöds (JPEG, PNG, WEBP, BMP). Rekommenderad ansiktsstorlek är 200 bildpunkter x 200 bildpunkter. Ansiktsstorlekar som är större än 200 bildpunkter x 200 bildpunkter resulterar inte i bättre AI-kvalitet och inte större än 6 MB i storlek.
Användaren har inte glasögon, masker, hattar, hörlurar, huvudbeklädnader eller ansiktsbeklädnader. Ansiktet ska vara fritt från eventuella hinder.
Ansiktssmycken tillåts förutsatt att de inte döljer ditt ansikte.
Endast ett ansikte ska vara synligt på bilden.
Ansiktet ska vara i neutral framåtriktad pose med båda ögonen öppna, munnen stängd, utan extrema ansiktsuttryck eller huvudlutning.
Ansiktet ska vara fritt från skuggor eller röda ögon. Omtagningsfoto om något av dessa inträffar.
Bakgrunden ska vara enhetlig och oformaterad, utan skuggor.
Ansiktet ska centreras i bilden och fylla minst 50 % av bilden.

Konfigurera orkestrering av liveness med verifiering.

De övergripande stegen som ingår i livskraften med verifieringsorkestrering illustreras nedan:

Tillhandahålla verifieringsreferensbilden med någon av följande två metoder:

Appservern tillhandahåller referensbilden när du skapar liveness-sessionen. Mer information om varje parameter för begäran som ingår i skapandet av en liveness-session med verifiering finns i Liveness with Verify Create Session Operation (Liveness with Verify Create Session Operation).

var endpoint = new Uri(System.Environment.GetEnvironmentVariable("FACE_ENDPOINT"));
var credential = new AzureKeyCredential(System.Environment.GetEnvironmentVariable("FACE_APIKEY"));

var sessionClient = new FaceSessionClient(endpoint, credential);

var createContent = new CreateLivenessWithVerifySessionContent(LivenessOperationMode.Passive)
{
    DeviceCorrelationId = "723d6d03-ef33-40a8-9682-23a1feb7bccd"
};
using var fileStream = new FileStream("test.png", FileMode.Open, FileAccess.Read);

var createResponse = await sessionClient.CreateLivenessWithVerifySessionAsync(createContent, fileStream);

var sessionId = createResponse.Value.SessionId;
Console.WriteLine("Session created.");
Console.WriteLine($"Session id: {sessionId}");
Console.WriteLine($"Auth token: {createResponse.Value.AuthToken}");
Console.WriteLine("The reference image:");
Console.WriteLine($"  Face rectangle: {createResponse.Value.VerifyImage.FaceRectangle.Top}, {createResponse.Value.VerifyImage.FaceRectangle.Left}, {createResponse.Value.VerifyImage.FaceRectangle.Width}, {createResponse.Value.VerifyImage.FaceRectangle.Height}");
Console.WriteLine($"  The quality for recognition: {createResponse.Value.VerifyImage.QualityForRecognition}");

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

Ett exempel på svarstexten:

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

Klientdelsprogrammet tillhandahåller referensbilden när SDK initieras. Det här scenariot stöds inte i webblösningen.

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.

Appservern kan nu fråga efter verifieringsresultatet utöver liveness-resultatet.

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

Ett exempel på svarstexten:

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

Appservern kan ta bort sessionen om du inte kör frågor mot resultatet längre.

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

Rensa resurser

Om du vill rensa och ta bort en Azure AI-tjänstprenumeration kan du ta bort resursen eller resursgruppen. Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

Mer information om andra alternativ i API:erna för liveness finns i Azure AI Vision SDK-referensen.

Mer information om de funktioner som är tillgängliga för att orkestrera liveness-lösningen finns i referensen för SESSIONS-REST API.

Sessionsåtgärder för liveness

Dela via

Självstudie: Identifiera livskraft i ansikten

Introduktion

Förutsättningar

Konfigurera klientdelsprogram och appservrar för att utföra livenessidentifiering

Ladda ned SDK för klientdelsprogram

Ladda ned Azure AI Face-klientbiblioteket för appservern

Skapa miljövariabler

Utföra livenessidentifiering

Utföra livenessidentifiering med ansiktsverifiering

Välj en referensbild

Tekniska krav

Krav på sammansättning

Konfigurera orkestrering av liveness med verifiering.

Rensa resurser

Feedback

Ytterligare resurser

Dela via

Självstudie: Identifiera livskraft i ansikten

Introduktion

Förutsättningar

Konfigurera klientdelsprogram och appservrar för att utföra livenessidentifiering

Ladda ned SDK för klientdelsprogram

Ladda ned Azure AI Face-klientbiblioteket för appservern

Skapa miljövariabler

Utföra livenessidentifiering

Utföra livenessidentifiering med ansiktsverifiering

Välj en referensbild

Tekniska krav

Krav på sammansättning

Konfigurera orkestrering av liveness med verifiering.

Rensa resurser

Relaterat innehåll

Feedback

Ytterligare resurser