Snabbstart: Använda ansiktstjänsten

Viktigt!

Om du använder Microsofts produkter eller tjänster för att bearbeta biometriska data ansvarar du för att: (i) meddela registrerade, inklusive med avseende på kvarhållningsperioder och destruktion; ii) erhålla samtycke från registrerade. och iii) ta bort biometriska data, allt efter behov och krävs enligt tillämpliga dataskyddskrav. "Biometriska data" kommer att ha den betydelse som anges i artikel 4 i GDPR och, om tillämpligt, likvärdiga termer i andra dataskyddskrav. Relaterad information finns i Data och sekretess för Ansikte.

Varning

Åtkomsten till ansiktstjänsten är begränsad baserat på berättigande- och användningskriterier för att stödja våra principer för ansvarsfull AI. Ansiktstjänsten är endast tillgänglig för Microsofts hanterade kunder och partner. Använd formuläret ansiktsigenkänning för att ansöka om åtkomst. Mer information finns på sidan ansiktsbegränsade åtkomst .

Kom igång med ansiktsigenkänning med hjälp av ansiktsklientbiblioteket för .NET. Ansiktstjänsten ger dig åtkomst till avancerade algoritmer för att identifiera och identifiera mänskliga ansikten i bilder. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande ansiktsidentifiering med fjärrbilder.

Referensdokumentation NuGet-exempel (Library Source Code | Package) | |

Förutsättningar

  • Azure-prenumeration – Skapa en kostnadsfritt
  • Visual Studio IDE eller den aktuella versionen av .NET Core.
  • Ditt Azure-konto måste ha en Cognitive Services Contributor tilldelad roll 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-portalen 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 ansikts-API:et.
    • 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.

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 Resurshanteringsidan Nycklar och slutpunkt . Resursnyckeln är inte samma som ditt Azure-prenumerations-ID.

Dricks

Inkludera inte nyckeln direkt i koden och publicera den aldrig offentligt. Mer autentiseringsalternativ som Azure Key Vault finns i säkerhetsartikeln för Azure AI-tjänster.

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.

  1. Om du vill ange VISION_KEY miljövariabeln ersätter du your-key med en av nycklarna för resursen.
  2. Om du vill ange VISION_ENDPOINT miljövariabeln ersätter du your-endpoint med slutpunkten för resursen.
setx VISION_KEY your-key
setx VISION_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.

Identifiera och verifiera ansikten

  1. Skapa ett nytt C#-program

    Skapa ett nytt .NET Core-program med Hjälp av Visual Studio.

    Installera klientbiblioteket

    När du har skapat ett nytt projekt installerar du klientbiblioteket genom att högerklicka på projektlösningen i Solution Explorer och välja Hantera NuGet-paket. I pakethanteraren som öppnas väljer du Browse (Bläddra), markera Include prerelease (Inkludera förhandsversion) och söker efter Microsoft.Azure.CognitiveServices.Vision.Face. Välj den senaste versionen och sedan Installera.

  2. Lägg till följande kod i filen Program.cs .

    Kommentar

    Om du inte har fått åtkomst till ansiktstjänsten med hjälp av intagsformuläret fungerar inte vissa av dessa funktioner.

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Threading;
    using System.Threading.Tasks;
    
    using Microsoft.Azure.CognitiveServices.Vision.Face;
    using Microsoft.Azure.CognitiveServices.Vision.Face.Models;
    
    namespace FaceQuickstart
    {
        class Program
        {
            static string personGroupId = Guid.NewGuid().ToString();
    
            // URL path for the images.
            const string IMAGE_BASE_URL = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/";
    
            // From your Face subscription in the Azure portal, get your subscription key and endpoint.
            const string SUBSCRIPTION_KEY = Environment.GetEnvironmentVariable("VISION_KEY");
            const string ENDPOINT = Environment.GetEnvironmentVariable("VISION_ENDPOINT");
    
    
             static void Main(string[] args)
            {
                // Recognition model 4 was released in 2021 February.
                // It is recommended since its accuracy is improved
                // on faces wearing masks compared with model 3,
                // and its overall accuracy is improved compared
                // with models 1 and 2.
                const string RECOGNITION_MODEL4 = RecognitionModel.Recognition04;
    
                // Authenticate.
                IFaceClient client = Authenticate(ENDPOINT, SUBSCRIPTION_KEY);
    
                // Identify - recognize a face(s) in a person group (a person group is created in this example).
                IdentifyInPersonGroup(client, IMAGE_BASE_URL, RECOGNITION_MODEL4).Wait();
    
                Console.WriteLine("End of quickstart.");
            }
    
            /*
             *	AUTHENTICATE
             *	Uses subscription key and region to create a client.
             */
            public static IFaceClient Authenticate(string endpoint, string key)
            {
                return new FaceClient(new ApiKeyServiceClientCredentials(key)) { Endpoint = endpoint };
            }
    
            // Detect faces from image url for recognition purposes. This is a helper method for other functions in this quickstart.
            // Parameter `returnFaceId` of `DetectWithUrlAsync` must be set to `true` (by default) for recognition purposes.
            // Parameter `FaceAttributes` is set to include the QualityForRecognition attribute. 
            // Recognition model must be set to recognition_03 or recognition_04 as a result.
            // Result faces with insufficient quality for recognition are filtered out. 
            // The field `faceId` in returned `DetectedFace`s will be used in Face - Face - Verify and Face - Identify.
            // It will expire 24 hours after the detection call.
            private static async Task<List<DetectedFace>> DetectFaceRecognize(IFaceClient faceClient, string url, string recognition_model)
            {
                // Detect faces from image URL. Since only recognizing, use the recognition model 1.
                // We use detection model 3 because we are not retrieving attributes.
                IList<DetectedFace> detectedFaces = await faceClient.Face.DetectWithUrlAsync(url, recognitionModel: recognition_model, detectionModel: DetectionModel.Detection03, returnFaceAttributes: new List<FaceAttributeType> { FaceAttributeType.QualityForRecognition });
                List<DetectedFace> sufficientQualityFaces = new List<DetectedFace>();
                foreach (DetectedFace detectedFace in detectedFaces){
                    var faceQualityForRecognition = detectedFace.FaceAttributes.QualityForRecognition;
                    if (faceQualityForRecognition.HasValue && (faceQualityForRecognition.Value >= QualityForRecognition.Medium)){
                        sufficientQualityFaces.Add(detectedFace);
                    }
                }
                Console.WriteLine($"{detectedFaces.Count} face(s) with {sufficientQualityFaces.Count} having sufficient quality for recognition detected from image `{Path.GetFileName(url)}`");
    
                return sufficientQualityFaces.ToList();
            }
    
            /*
             * IDENTIFY FACES
             * To identify faces, you need to create and define a person group.
             * The Identify operation takes one or several face IDs from DetectedFace or PersistedFace and a PersonGroup and returns 
             * a list of Person objects that each face might belong to. Returned Person objects are wrapped as Candidate objects, 
             * which have a prediction confidence value.
             */
            public static async Task IdentifyInPersonGroup(IFaceClient client, string url, string recognitionModel)
            {
                Console.WriteLine("========IDENTIFY FACES========");
                Console.WriteLine();
    
                // Create a dictionary for all your images, grouping similar ones under the same key.
                Dictionary<string, string[]> personDictionary =
                    new Dictionary<string, string[]>
                        { { "Family1-Dad", new[] { "Family1-Dad1.jpg", "Family1-Dad2.jpg" } },
                          { "Family1-Mom", new[] { "Family1-Mom1.jpg", "Family1-Mom2.jpg" } },
                          { "Family1-Son", new[] { "Family1-Son1.jpg", "Family1-Son2.jpg" } },
                          { "Family1-Daughter", new[] { "Family1-Daughter1.jpg", "Family1-Daughter2.jpg" } },
                          { "Family2-Lady", new[] { "Family2-Lady1.jpg", "Family2-Lady2.jpg" } },
                          { "Family2-Man", new[] { "Family2-Man1.jpg", "Family2-Man2.jpg" } }
                        };
                // A group photo that includes some of the persons you seek to identify from your dictionary.
                string sourceImageFileName = "identification1.jpg";
    
                // Create a person group. 
                Console.WriteLine($"Create a person group ({personGroupId}).");
                await client.PersonGroup.CreateAsync(personGroupId, personGroupId, recognitionModel: recognitionModel);
                // The similar faces will be grouped into a single person group person.
                foreach (var groupedFace in personDictionary.Keys)
                {
                    // Limit TPS
                    await Task.Delay(250);
                    Person person = await client.PersonGroupPerson.CreateAsync(personGroupId: personGroupId, name: groupedFace);
                    Console.WriteLine($"Create a person group person '{groupedFace}'.");
    
                    // Add face to the person group person.
                    foreach (var similarImage in personDictionary[groupedFace])
                    {
                        Console.WriteLine($"Check whether image is of sufficient quality for recognition");
                        IList<DetectedFace> detectedFaces1 = await client.Face.DetectWithUrlAsync($"{url}{similarImage}", 
                            recognitionModel: recognitionModel, 
                            detectionModel: DetectionModel.Detection03,
                            returnFaceAttributes: new List<FaceAttributeType> { FaceAttributeType.QualityForRecognition });
                        bool sufficientQuality = true;
                        foreach (var face1 in detectedFaces1)
                        {
                            var faceQualityForRecognition = face1.FaceAttributes.QualityForRecognition;
                            //  Only "high" quality images are recommended for person enrollment
                            if (faceQualityForRecognition.HasValue && (faceQualityForRecognition.Value != QualityForRecognition.High)){
                                sufficientQuality = false;
                                break;
                            }
                        }
    
                        if (!sufficientQuality){
                            continue;
                        }
    
                        // add face to the person group
                        Console.WriteLine($"Add face to the person group person({groupedFace}) from image `{similarImage}`");
                        PersistedFace face = await client.PersonGroupPerson.AddFaceFromUrlAsync(personGroupId, person.PersonId,
                            $"{url}{similarImage}", similarImage);
                    }
                }
    
                // Start to train the person group.
                Console.WriteLine();
                Console.WriteLine($"Train person group {personGroupId}.");
                await client.PersonGroup.TrainAsync(personGroupId);
    
                // Wait until the training is completed.
                while (true)
                {
                    await Task.Delay(1000);
                    var trainingStatus = await client.PersonGroup.GetTrainingStatusAsync(personGroupId);
                    Console.WriteLine($"Training status: {trainingStatus.Status}.");
                    if (trainingStatus.Status == TrainingStatusType.Succeeded) { break; }
                }
                Console.WriteLine();
    
                List<Guid> sourceFaceIds = new List<Guid>();
                // Detect faces from source image url.
                List<DetectedFace> detectedFaces = await DetectFaceRecognize(client, $"{url}{sourceImageFileName}", recognitionModel);
    
                // Add detected faceId to sourceFaceIds.
                foreach (var detectedFace in detectedFaces) { sourceFaceIds.Add(detectedFace.FaceId.Value); }
                
                // Identify the faces in a person group. 
                var identifyResults = await client.Face.IdentifyAsync(sourceFaceIds, personGroupId);
    
                foreach (var identifyResult in identifyResults)
                {
                    if (identifyResult.Candidates.Count==0) {
                        Console.WriteLine($"No person is identified for the face in: {sourceImageFileName} - {identifyResult.FaceId},");
                        continue;
                    }
                    Person person = await client.PersonGroupPerson.GetAsync(personGroupId, identifyResult.Candidates[0].PersonId);
                    Console.WriteLine($"Person '{person.Name}' is identified for the face in: {sourceImageFileName} - {identifyResult.FaceId}," +
                        $" confidence: {identifyResult.Candidates[0].Confidence}.");
    
                    VerifyResult verifyResult = await client.Face.VerifyFaceToPersonAsync(identifyResult.FaceId, person.PersonId, personGroupId);
                    Console.WriteLine($"Verification result: is a match? {verifyResult.IsIdentical}. confidence: {verifyResult.Confidence}");
                }
                Console.WriteLine();
            }
        }
    }
    
  3. Kör appen

    Kör programmet genom att klicka på felsökningsknappen överst i IDE-fönstret.

Output

========IDENTIFY FACES========

Create a person group (3972c063-71b3-4328-8579-6d190ee76f99).
Create a person group person 'Family1-Dad'.
Add face to the person group person(Family1-Dad) from image `Family1-Dad1.jpg`
Add face to the person group person(Family1-Dad) from image `Family1-Dad2.jpg`
Create a person group person 'Family1-Mom'.
Add face to the person group person(Family1-Mom) from image `Family1-Mom1.jpg`
Add face to the person group person(Family1-Mom) from image `Family1-Mom2.jpg`
Create a person group person 'Family1-Son'.
Add face to the person group person(Family1-Son) from image `Family1-Son1.jpg`
Add face to the person group person(Family1-Son) from image `Family1-Son2.jpg`
Create a person group person 'Family1-Daughter'.
Create a person group person 'Family2-Lady'.
Add face to the person group person(Family2-Lady) from image `Family2-Lady1.jpg`
Add face to the person group person(Family2-Lady) from image `Family2-Lady2.jpg`
Create a person group person 'Family2-Man'.
Add face to the person group person(Family2-Man) from image `Family2-Man1.jpg`
Add face to the person group person(Family2-Man) from image `Family2-Man2.jpg`

Train person group 3972c063-71b3-4328-8579-6d190ee76f99.
Training status: Succeeded.

4 face(s) with 4 having sufficient quality for recognition detected from image `identification1.jpg`
Person 'Family1-Dad' is identified for face in: identification1.jpg - 994bfd7a-0d8f-4fae-a5a6-c524664cbee7, confidence: 0.96725.
Person 'Family1-Mom' is identified for face in: identification1.jpg - 0c9da7b9-a628-429d-97ff-cebe7c638fb5, confidence: 0.96921.
No person is identified for face in: identification1.jpg - a881259c-e811-4f7e-a35e-a453e95ca18f,
Person 'Family1-Son' is identified for face in: identification1.jpg - 53772235-8193-46eb-bdfc-1ebc25ea062e, confidence: 0.92886.

End of quickstart.

Dricks

Ansikts-API:et körs på en uppsättning fördefinierade modeller som är statiska av naturen (modellens prestanda kommer inte att regresseras eller förbättras när tjänsten körs). Resultatet som modellen genererar kan ändras om Microsoft uppdaterar modellens serverdel utan att migrera till en helt ny modellversion. Om du vill dra nytta av en nyare version av en modell kan du träna om din PersonGroup och ange den nyare modellen som en parameter med samma registreringsbilder.

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.

Om du vill ta bort den PersonGroup som du skapade i den här snabbstarten kör du följande kod i programmet:

// At end, delete person groups in both regions (since testing only)
Console.WriteLine("========DELETE PERSON GROUP========");
Console.WriteLine();
DeletePersonGroup(client, personGroupId).Wait();

Definiera borttagningsmetoden med följande kod:

/*
 * DELETE PERSON GROUP
 * After this entire example is executed, delete the person group in your Azure account,
 * otherwise you cannot recreate one with the same name (if running example repeatedly).
 */
public static async Task DeletePersonGroup(IFaceClient client, String personGroupId)
{
    await client.PersonGroup.DeleteAsync(personGroupId);
    Console.WriteLine($"Deleted the person group {personGroupId}.");
}

Nästa steg

I den här snabbstarten har du lärt dig hur du använder ansiktsklientbiblioteket för .NET för att utföra grundläggande ansiktsidentifiering. Lär dig sedan om de olika ansiktsidentifieringsmodellerna och hur du anger rätt modell för ditt användningsfall.

Kom igång med ansiktsigenkänning med hjälp av Ansiktsklientbiblioteket för JavaScript. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Ansiktstjänsten ger dig åtkomst till avancerade algoritmer för att identifiera och identifiera mänskliga ansikten i bilder. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande ansiktsidentifiering med fjärrbilder.

Referensdokumentation Bibliotek källkodspaket | (npm)Exempel | |

Förutsättningar

  • Azure-prenumeration – Skapa en kostnadsfritt
  • Den senaste versionen av Node.js
  • Ditt Azure-konto måste ha en Cognitive Services Contributor tilldelad roll 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-portalen 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 ansikts-API:et.
    • 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.

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 Resurshanteringsidan Nycklar och slutpunkt . Resursnyckeln är inte samma som ditt Azure-prenumerations-ID.

Dricks

Inkludera inte nyckeln direkt i koden och publicera den aldrig offentligt. Mer autentiseringsalternativ som Azure Key Vault finns i säkerhetsartikeln för Azure AI-tjänster.

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.

  1. Om du vill ange VISION_KEY miljövariabeln ersätter du your-key med en av nycklarna för resursen.
  2. Om du vill ange VISION_ENDPOINT miljövariabeln ersätter du your-endpoint med slutpunkten för resursen.
setx VISION_KEY your-key
setx VISION_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.

Identifiera och verifiera ansikten

  1. Skapa ett nytt Node.js-program

    Skapa en ny katalog för din app i ett konsolfönster (till exempel cmd, PowerShell eller bash) och navigera till den.

    mkdir myapp && cd myapp
    

    Kör kommandot npm init för att skapa ett nodprogram med en package.json-fil.

    npm init
    
  2. Installera och azure-cognitiveservices-face npm-paketenms-rest-azure:

    npm install @azure/cognitiveservices-face @azure/ms-rest-js uuid
    

    Appens package.json fil uppdateras med beroendena.

  3. Skapa en fil med namnet index.js, öppna den i en textredigerare och klistra in följande kod:

    Kommentar

    Om du inte har fått åtkomst till ansiktstjänsten med hjälp av intagsformuläret fungerar inte vissa av dessa funktioner.

    'use strict';
    
    const msRest = require("@azure/ms-rest-js");
    const Face = require("@azure/cognitiveservices-face");
    const { v4: uuid } = require('uuid');
    
    const key = process.env.VISION_KEY;
    const endpoint = process.env.VISION_ENDPOINT;
    
    const credentials = new msRest.ApiKeyCredentials({ inHeader: { 'Ocp-Apim-Subscription-Key': key } });
    const client = new Face.FaceClient(credentials, endpoint);
    
    
    const image_base_url = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/";
    const person_group_id = uuid();
    
    function sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
    
    async function DetectFaceRecognize(url) {
        // Detect faces from image URL. Since only recognizing, use the recognition model 4.
        // We use detection model 3 because we are only retrieving the qualityForRecognition attribute.
        // Result faces with quality for recognition lower than "medium" are filtered out.
        let detected_faces = await client.face.detectWithUrl(url,
            {
                detectionModel: "detection_03",
                recognitionModel: "recognition_04",
                returnFaceAttributes: ["QualityForRecognition"]
            });
        return detected_faces.filter(face => face.faceAttributes.qualityForRecognition == 'high' || face.faceAttributes.qualityForRecognition == 'medium');
    }
    
    async function AddFacesToPersonGroup(person_dictionary, person_group_id) {
        console.log ("Adding faces to person group...");
        // The similar faces will be grouped into a single person group person.
        
        await Promise.all (Object.keys(person_dictionary).map (async function (key) {
            const value = person_dictionary[key];
    
    
            let person = await client.personGroupPerson.create(person_group_id, { name : key });
            console.log("Create a persongroup person: " + key + ".");
    
            // Add faces to the person group person.
            await Promise.all (value.map (async function (similar_image) {
    
                // Wait briefly so we do not exceed rate limits.
                await sleep (1000);
    
    
                // Check if the image is of sufficent quality for recognition.
                let sufficientQuality = true;
                let detected_faces = await client.face.detectWithUrl(image_base_url + similar_image,
                    {
                        returnFaceAttributes: ["QualityForRecognition"],
                        detectionModel: "detection_03",
                        recognitionModel: "recognition_03"
                    });
                detected_faces.forEach(detected_face => {
                    if (detected_face.faceAttributes.qualityForRecognition != 'high'){
                        sufficientQuality = false;
                    }
                });
    
                // Wait briefly so we do not exceed rate limits.
                await sleep (1000);
    
                // Quality is sufficent, add to group.
                if (sufficientQuality){
                    console.log("Add face to the person group person: (" + key + ") from image: " + similar_image + ".");
                    await client.personGroupPerson.addFaceFromUrl(person_group_id, person.personId, image_base_url + similar_image);
                }
                // Wait briefly so we do not exceed rate limits.
                await sleep (1000);
            }));
        }));
    
        console.log ("Done adding faces to person group.");
    }
    
    async function WaitForPersonGroupTraining(person_group_id) {
        // Wait so we do not exceed rate limits.
        console.log ("Waiting 10 seconds...");
        await sleep (10000);
        let result = await client.personGroup.getTrainingStatus(person_group_id);
        console.log("Training status: " + result.status + ".");
        if (result.status !== "succeeded") {
            await WaitForPersonGroupTraining(person_group_id);
        }
    }
    
    /* NOTE This function might not work with the free tier of the Face service
    because it might exceed the rate limits. If that happens, try inserting calls
    to sleep() between calls to the Face service.
    */
    async function IdentifyInPersonGroup() {
        console.log("========IDENTIFY FACES========");
        console.log();
    
    // Create a dictionary for all your images, grouping similar ones under the same key.
        const person_dictionary = {
            "Family1-Dad" : ["Family1-Dad1.jpg", "Family1-Dad2.jpg"],
            "Family1-Mom" : ["Family1-Mom1.jpg", "Family1-Mom2.jpg"],
            "Family1-Son" : ["Family1-Son1.jpg", "Family1-Son2.jpg"],
            "Family1-Daughter" : ["Family1-Daughter1.jpg", "Family1-Daughter2.jpg"],
            "Family2-Lady" : ["Family2-Lady1.jpg", "Family2-Lady2.jpg"],
            "Family2-Man" : ["Family2-Man1.jpg", "Family2-Man2.jpg"]
        };
    
        // A group photo that includes some of the persons you seek to identify from your dictionary.
        let source_image_file_name = "identification1.jpg";
    
        
        // Create a person group. 
        console.log("Creating a person group with ID: " + person_group_id);
        await client.personGroup.create(person_group_id, person_group_id, {recognitionModel : "recognition_04" });
    
        await AddFacesToPersonGroup(person_dictionary, person_group_id);
    
        // Start to train the person group.
        console.log();
        console.log("Training person group: " + person_group_id + ".");
        await client.personGroup.train(person_group_id);
    
        await WaitForPersonGroupTraining(person_group_id);
        console.log();
    
        // Detect faces from source image url and only take those with sufficient quality for recognition.
        let face_ids = (await DetectFaceRecognize(image_base_url + source_image_file_name)).map (face => face.faceId);
        
        // Identify the faces in a person group.
        let results = await client.face.identify(face_ids, { personGroupId : person_group_id});
        await Promise.all (results.map (async function (result) {
            try{
                let person = await client.personGroupPerson.get(person_group_id, result.candidates[0].personId);
    
                console.log("Person: " + person.name + " is identified for face in: " + source_image_file_name + " with ID: " + result.faceId + ". Confidence: " + result.candidates[0].confidence + ".");
    
                // Verification:
                let verifyResult = await client.face.verifyFaceToPerson(result.faceId, person.personId, {personGroupId : person_group_id});
                console.log("Verification result between face "+ result.faceId +" and person "+ person.personId+ ": " +verifyResult.isIdentical + " with confidence: "+ verifyResult.confidence);
    
            } catch(error) {
                //console.log("no persons identified for face with ID " + result.faceId);
                console.log(error.toString());
            }
            
        }));
        console.log();
    }
    
    async function main() {
        await IdentifyInPersonGroup();
        console.log ("Done.");
    }
    main();
    
  4. Kör programmet med kommandot node på din snabbstartsfil.

    node index.js
    

Output

========IDENTIFY FACES========

Creating a person group with ID: c08484e0-044b-4610-8b7e-c957584e5d2d
Adding faces to person group...
Create a persongroup person: Family1-Dad.
Create a persongroup person: Family1-Mom.
Create a persongroup person: Family2-Lady.
Create a persongroup person: Family1-Son.
Create a persongroup person: Family1-Daughter.
Create a persongroup person: Family2-Man.
Add face to the person group person: (Family1-Son) from image: Family1-Son2.jpg.
Add face to the person group person: (Family1-Dad) from image: Family1-Dad2.jpg.
Add face to the person group person: (Family1-Mom) from image: Family1-Mom1.jpg.
Add face to the person group person: (Family2-Man) from image: Family2-Man1.jpg.
Add face to the person group person: (Family1-Son) from image: Family1-Son1.jpg.
Add face to the person group person: (Family2-Lady) from image: Family2-Lady2.jpg.
Add face to the person group person: (Family1-Mom) from image: Family1-Mom2.jpg.
Add face to the person group person: (Family1-Dad) from image: Family1-Dad1.jpg.
Add face to the person group person: (Family2-Man) from image: Family2-Man2.jpg.
Add face to the person group person: (Family2-Lady) from image: Family2-Lady1.jpg.
Done adding faces to person group.

Training person group: c08484e0-044b-4610-8b7e-c957584e5d2d.
Waiting 10 seconds...
Training status: succeeded.

Person: Family1-Mom is identified for face in: identification1.jpg with ID: b7f7f542-c338-4a40-ad52-e61772bc6e14. Confidence: 0.96921.
Person: Family1-Son is identified for face in: identification1.jpg with ID: 600dc1b4-b2c4-4516-87de-edbbdd8d7632. Confidence: 0.92886.
Person: Family1-Dad is identified for face in: identification1.jpg with ID: e83b494f-9ad2-473f-9d86-3de79c01e345. Confidence: 0.96725.

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.

Nästa steg

I den här snabbstarten har du lärt dig hur du använder Ansiktsklientbiblioteket för JavaScript för att utföra grundläggande ansiktsidentifiering. Lär dig sedan om de olika ansiktsidentifieringsmodellerna och hur du anger rätt modell för ditt användningsfall.

Kom igång med ansiktsigenkänning med hjälp av ansiktsklientbiblioteket för Python. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Ansiktstjänsten ger dig åtkomst till avancerade algoritmer för att identifiera och identifiera mänskliga ansikten i bilder. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande ansiktsidentifiering med fjärrbilder.

Exempel på källkodspaket (PiPy) | för referensdokumentation | |

Förutsättningar

  • Azure-prenumeration – Skapa en kostnadsfritt
  • Python 3.x
    • Python-installationen bör innehålla pip. Du kan kontrollera om du har pip installerat genom att köra pip --version på kommandoraden. Hämta pip genom att installera den senaste versionen av Python.
  • Ditt Azure-konto måste ha en Cognitive Services Contributor tilldelad roll 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-portalen 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 ansikts-API:et.
    • 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.

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 Resurshanteringsidan Nycklar och slutpunkt . Resursnyckeln är inte samma som ditt Azure-prenumerations-ID.

Dricks

Inkludera inte nyckeln direkt i koden och publicera den aldrig offentligt. Mer autentiseringsalternativ som Azure Key Vault finns i säkerhetsartikeln för Azure AI-tjänster.

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.

  1. Om du vill ange VISION_KEY miljövariabeln ersätter du your-key med en av nycklarna för resursen.
  2. Om du vill ange VISION_ENDPOINT miljövariabeln ersätter du your-endpoint med slutpunkten för resursen.
setx VISION_KEY your-key
setx VISION_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.

Identifiera och verifiera ansikten

  1. Installera klientbiblioteket

    När du har installerat Python kan du installera klientbiblioteket med:

    pip install --upgrade azure-cognitiveservices-vision-face
    
  2. Skapa ett nytt Python-program

    Skapa ett nytt Python-skript – quickstart-file.py till exempel. Öppna den sedan i önskad redigerare eller IDE och klistra in följande kod.

    Kommentar

    Om du inte har fått åtkomst till ansiktstjänsten med hjälp av intagsformuläret fungerar inte vissa av dessa funktioner.

    import asyncio
    import io
    import os
    import sys
    import time
    import uuid
    import requests
    from urllib.parse import urlparse
    from io import BytesIO
    # To install this module, run:
    # python -m pip install Pillow
    from PIL import Image, ImageDraw
    from azure.cognitiveservices.vision.face import FaceClient
    from msrest.authentication import CognitiveServicesCredentials
    from azure.cognitiveservices.vision.face.models import TrainingStatusType, Person, QualityForRecognition
    
    
    # This key will serve all examples in this document.
    KEY = os.environ["VISION_KEY"]
    
    # This endpoint will be used in all examples in this quickstart.
    ENDPOINT = os.environ["VISION_ENDPOINT"]
    
    # Base url for the Verify and Facelist/Large Facelist operations
    IMAGE_BASE_URL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/'
    
    # Used in the Person Group Operations and Delete Person Group examples.
    # You can call list_person_groups to print a list of preexisting PersonGroups.
    # SOURCE_PERSON_GROUP_ID should be all lowercase and alphanumeric. For example, 'mygroupname' (dashes are OK).
    PERSON_GROUP_ID = str(uuid.uuid4()) # assign a random ID (or name it anything)
    
    # Used for the Delete Person Group example.
    TARGET_PERSON_GROUP_ID = str(uuid.uuid4()) # assign a random ID (or name it anything)
    
    # Create an authenticated FaceClient.
    face_client = FaceClient(ENDPOINT, CognitiveServicesCredentials(KEY))
    
    '''
    Create the PersonGroup
    '''
    # Create empty Person Group. Person Group ID must be lower case, alphanumeric, and/or with '-', '_'.
    print('Person group:', PERSON_GROUP_ID)
    face_client.person_group.create(person_group_id=PERSON_GROUP_ID, name=PERSON_GROUP_ID, recognition_model='recognition_04')
    
    # Define woman friend
    woman = face_client.person_group_person.create(PERSON_GROUP_ID, name="Woman")
    # Define man friend
    man = face_client.person_group_person.create(PERSON_GROUP_ID, name="Man")
    # Define child friend
    child = face_client.person_group_person.create(PERSON_GROUP_ID, name="Child")
    
    '''
    Detect faces and register them to each person
    '''
    # Find all jpeg images of friends in working directory (TBD pull from web instead)
    woman_images = ["https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Mom1.jpg", "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Mom2.jpg"]
    man_images = ["https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Dad1.jpg", "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Dad2.jpg"]
    child_images = ["https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Son1.jpg", "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Son2.jpg"]
    
    # Add to woman person
    for image in woman_images:
        # Check if the image is of sufficent quality for recognition.
        sufficientQuality = True
        detected_faces = face_client.face.detect_with_url(url=image, detection_model='detection_03', recognition_model='recognition_04', return_face_attributes=['qualityForRecognition'])
        for face in detected_faces:
            if face.face_attributes.quality_for_recognition != QualityForRecognition.high:
                sufficientQuality = False
                break
            face_client.person_group_person.add_face_from_url(PERSON_GROUP_ID, woman.person_id, image)
            print("face {} added to person {}".format(face.face_id, woman.person_id))
    
        if not sufficientQuality: continue
    
    # Add to man person
    for image in man_images:
        # Check if the image is of sufficent quality for recognition.
        sufficientQuality = True
        detected_faces = face_client.face.detect_with_url(url=image, detection_model='detection_03', recognition_model='recognition_04', return_face_attributes=['qualityForRecognition'])
        for face in detected_faces:
            if face.face_attributes.quality_for_recognition != QualityForRecognition.high:
                sufficientQuality = False
                break
            face_client.person_group_person.add_face_from_url(PERSON_GROUP_ID, man.person_id, image)
            print("face {} added to person {}".format(face.face_id, man.person_id))
    
        if not sufficientQuality: continue
    
    # Add to child person
    for image in child_images:
        # Check if the image is of sufficent quality for recognition.
        sufficientQuality = True
        detected_faces = face_client.face.detect_with_url(url=image, detection_model='detection_03', recognition_model='recognition_04', return_face_attributes=['qualityForRecognition'])
        for face in detected_faces:
            if face.face_attributes.quality_for_recognition != QualityForRecognition.high:
                sufficientQuality = False
                print("{} has insufficient quality".format(face))
                break
            face_client.person_group_person.add_face_from_url(PERSON_GROUP_ID, child.person_id, image)
            print("face {} added to person {}".format(face.face_id, child.person_id))
        if not sufficientQuality: continue
    
    
    '''
    Train PersonGroup
    '''
    # Train the person group
    print("pg resource is {}".format(PERSON_GROUP_ID))
    rawresponse = face_client.person_group.train(PERSON_GROUP_ID, raw= True)
    print(rawresponse)
    
    while (True):
        training_status = face_client.person_group.get_training_status(PERSON_GROUP_ID)
        print("Training status: {}.".format(training_status.status))
        print()
        if (training_status.status is TrainingStatusType.succeeded):
            break
        elif (training_status.status is TrainingStatusType.failed):
            face_client.person_group.delete(person_group_id=PERSON_GROUP_ID)
            sys.exit('Training the person group has failed.')
        time.sleep(5)
    
    '''
    Identify a face against a defined PersonGroup
    '''
    # Group image for testing against
    test_image = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/identification1.jpg"
    
    print('Pausing for 10 seconds to avoid triggering rate limit on free account...')
    time.sleep (10)
    
    # Detect faces
    face_ids = []
    # We use detection model 3 to get better performance, recognition model 4 to support quality for recognition attribute.
    faces = face_client.face.detect_with_url(test_image, detection_model='detection_03', recognition_model='recognition_04', return_face_attributes=['qualityForRecognition'])
    for face in faces:
        # Only take the face if it is of sufficient quality.
        if face.face_attributes.quality_for_recognition == QualityForRecognition.high or face.face_attributes.quality_for_recognition == QualityForRecognition.medium:
            face_ids.append(face.face_id)
    
    # Identify faces
    results = face_client.face.identify(face_ids, PERSON_GROUP_ID)
    print('Identifying faces in image')
    if not results:
        print('No person identified in the person group')
    for identifiedFace in results:
        if len(identifiedFace.candidates) > 0:
            print('Person is identified for face ID {} in image, with a confidence of {}.'.format(identifiedFace.face_id, identifiedFace.candidates[0].confidence)) # Get topmost confidence score
    
            # Verify faces
            verify_result = face_client.face.verify_face_to_person(identifiedFace.face_id, identifiedFace.candidates[0].person_id, PERSON_GROUP_ID)
            print('verification result: {}. confidence: {}'.format(verify_result.is_identical, verify_result.confidence))
        else:
            print('No person identified for face ID {} in image.'.format(identifiedFace.face_id))
     
    
    print()
    print('End of quickstart.')
    
    
  3. Kör ansiktsigenkänningsappen från programkatalogen python med kommandot .

    python quickstart-file.py
    

    Dricks

    Ansikts-API:et körs på en uppsättning fördefinierade modeller som är statiska av naturen (modellens prestanda kommer inte att regresseras eller förbättras när tjänsten körs). Resultatet som modellen genererar kan ändras om Microsoft uppdaterar modellens serverdel utan att migrera till en helt ny modellversion. Om du vill dra nytta av en nyare version av en modell kan du träna om din PersonGroup och ange den nyare modellen som en parameter med samma registreringsbilder.

Output

Person group: c8e679eb-0b71-43b4-aa91-ab8200cae7df
face 861d769b-d014-40e8-8b4a-7fd3bc9b425b added to person f80c1cfa-b8cb-46f8-9f7f-e72fbe402bc3
face e3c356a4-1ac3-4c97-9219-14648997f195 added to person f80c1cfa-b8cb-46f8-9f7f-e72fbe402bc3
face f9119820-c374-4c4d-b795-96ae2fec5069 added to person be4084a7-0c7b-4cf9-9463-3756d2e28e17
face 67d626df-3f75-4801-9364-601b63c8296a added to person be4084a7-0c7b-4cf9-9463-3756d2e28e17
face 19e2e8cc-5029-4087-bca0-9f94588fb850 added to person 3ff07c65-6193-4d3e-bf18-d7c106393cd5
face dcc61e80-16b1-4241-ae3f-9721597bae4c added to person 3ff07c65-6193-4d3e-bf18-d7c106393cd5
pg resource is c8e679eb-0b71-43b4-aa91-ab8200cae7df
<msrest.pipeline.ClientRawResponse object at 0x00000240DAD47310>
Training status: running.

Training status: succeeded.

Pausing for 10 seconds to avoid triggering rate limit on free account...
Identifying faces in image
Person for face ID 40582995-d3a8-41c4-a9d1-d17ae6b46c5c is identified in image, with a confidence of 0.96725.
Person for face ID 7a0368a2-332c-4e7a-81c4-2db3d74c78c5 is identified in image, with a confidence of 0.96921.
No person identified for face ID c4a3dd28-ef2d-457e-81d1-a447344242c4 in image.
Person for face ID 360edf1a-1e8f-402d-aa96-1734d0c21c1c is identified in image, with a confidence of 0.92886.

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.

Om du vill ta bort den PersonGroup som du skapade i den här snabbstarten kör du följande kod i skriptet:

# Delete the main person group.
face_client.person_group.delete(person_group_id=PERSON_GROUP_ID)
print("Deleted the person group {} from the source location.".format(PERSON_GROUP_ID))
print()

Nästa steg

I den här snabbstarten har du lärt dig hur du använder ansiktsklientbiblioteket för Python för att utföra grundläggande ansiktsidentifiering. Lär dig sedan om de olika ansiktsidentifieringsmodellerna och hur du anger rätt modell för ditt användningsfall.

Kom igång med ansiktsigenkänning med hjälp av ANSIKTS-REST-API:et. Ansiktstjänsten ger dig åtkomst till avancerade algoritmer för att identifiera och identifiera mänskliga ansikten i bilder.

Kommentar

Den här snabbstarten använder cURL-kommandon för att anropa REST-API:et. Du kan också anropa REST-API:et med hjälp av ett programmeringsspråk. Komplexa scenarier som ansiktsidentifiering är enklare att implementera med hjälp av ett språk-SDK. Se GitHub-exempel för exempel i C#, Python, Java, JavaScript och Go.

Förutsättningar

  • Azure-prenumeration – Skapa en kostnadsfritt
  • Ditt Azure-konto måste ha en Cognitive Services Contributor tilldelad roll 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-portalen 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 ansikts-API:et. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
    • 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.
  • PowerShell version 6.0+ eller ett liknande kommandoradsprogram.

Identifiera och verifiera ansikten

Kommentar

Om du inte har fått åtkomst till ansiktstjänsten med hjälp av intagsformuläret fungerar inte vissa av dessa funktioner.

  1. Anropa först identifierings-API:et i källinsiktet. Det här är det ansikte som vi ska försöka identifiera från den större gruppen. Kopiera följande kommando till en textredigerare, infoga din egen nyckel och kopiera den sedan till ett gränssnittsfönster och kör den.

    curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/detect?returnFaceId=true&returnFaceLandmarks=false&recognitionModel=recognition_04&returnRecognitionModel=false&detectionModel=detection_03&faceIdTimeToLive=86400" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii '{\"url\":\"https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/identification1.jpg\"}'
    

    Spara den returnerade ansikts-ID-strängen på en tillfällig plats. Du använder den igen i slutet.

  2. Därefter måste du skapa en LargePersonGroup. Det här objektet lagrar aggregerade ansiktsdata för flera personer. Kör följande kommando och infoga din egen nyckel. Du kan också ändra gruppens namn och metadata i begärandetexten.

    curl -v -X PUT "https://westus.api.cognitive.microsoft.com/face/v1.0/largepersongroups/{largePersonGroupId}" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii "{
        \"name\": \"large-person-group-name\",
        \"userData\": \"User-provided data attached to the large person group.\",
        \"recognitionModel\": \"recognition_03\"
    }"
    

    Spara det returnerade ID:t för den skapade gruppen på en tillfällig plats.

  3. Därefter skapar du Person-objekt som tillhör gruppen. Kör följande kommando och infoga din egen nyckel och ID för LargePersonGroup från föregående steg. Det här kommandot skapar en person med namnet "Family1-Dad".

    curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/largepersongroups/{largePersonGroupId}/persons" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii "{
        \"name\": \"Family1-Dad\",
        \"userData\": \"User-provided data attached to the person.\"
    }"
    

    När du har kört det här kommandot kör du det igen med olika indata för att skapa fler personobjekt : "Family1-Mom", "Family1-Son", "Family1-Daughter", "Family2-Lady" och "Family2-Man".

    Spara ID:t för varje person som skapats. Det är viktigt att hålla reda på vilket personnamn som har vilket ID.

  4. Därefter måste du identifiera nya ansikten och associera dem med de personobjekt som finns. Följande kommando identifierar ett ansikte från bilden Family1-Dad1.jpg och lägger till det i motsvarande person. Du måste ange personId som det ID som returnerades när du skapade objektet "Family1-Dad" Person . Avbildningsnamnet motsvarar namnet på den skapade personen. Ange även LargePersonGroup-ID och din nyckel i lämpliga fält.

    curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/largepersongroups/{largePersonGroupId}/persons/{personId}/persistedfaces?detectionModel=detection_03" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii '{\"url\":\"https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/Family1-Dad1.jpg\"}'
    

    Kör sedan kommandot ovan igen med en annan källbild och målperson. De tillgängliga bilderna är: Family1-Dad1.jpg, Family1-Dad2.jpgFamily1-Mom1.jpg, Family1-Mom2.jpg, Family1-Son1.jpg, Family1-Son2.jpg, Family1-Daughter1.jpg, Family1-Daughter2.jpg, Family2-Lady1.jpg, Family2-Lady2.jpg, Family2-Man1.jpg och Family2-Man2.jpg. Se till att den person vars ID du anger i API-anropet matchar namnet på bildfilen i begärandetexten.

    I slutet av det här steget bör du ha flera personobjekt som var och en har ett eller flera motsvarande ansikten, som identifieras direkt från de angivna bilderna.

  5. Träna sedan LargePersonGroup med aktuella ansiktsdata. Träningsåtgärden lär modellen hur man associerar ansiktsfunktioner, ibland aggregerade från flera källbilder, till varje enskild person. Infoga LargePersonGroup-ID:t och nyckeln innan du kör kommandot.

    curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/largepersongroups/{largePersonGroupId}/train" -H "Ocp-Apim-Subscription-Key: {subscription key}"
    
  6. Nu är du redo att anropa API:et Identifiera med hjälp av källigenkännings-ID:t från det första steget och LargePersonGroup-ID :t. Infoga dessa värden i lämpliga fält i begärandetexten och infoga nyckeln.

    curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/identify" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii "{
        \"largePersonGroupId\": \"INSERT_PERSONGROUP_NAME\",
        \"faceIds\": [
            \"INSERT_SOURCE_FACE_ID\"
        ],  
        \"maxNumOfCandidatesReturned\": 1,
        \"confidenceThreshold\": 0.5
    }"
    

    Svaret bör ge dig ett person-ID som anger den person som identifieras med källsiktet. Det bör vara det ID som motsvarar "Family1-Dad"-personen, eftersom källansiktet är av den personen.

  7. För att utföra ansiktsverifiering använder du person-ID:t som returnerades i föregående steg, LargePersonGroup-ID:t och även ansikts-ID:t för källan. Infoga dessa värden i fälten i begärandetexten och infoga nyckeln.

    curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/verify"
    -H "Content-Type: application/json"
    -H "Ocp-Apim-Subscription-Key: {subscription key}"
    --data-ascii "{
        \"faceId\": \"\{INSERT_SOURCE_FACE_ID}\",
        \"personId\": \"{INSERT_PERSON_ID}\",
        \"largePersonGroupId\": \"INSERT_PERSONGROUP_ID\"
    }"
    

    Svaret bör ge dig ett booleskt verifieringsresultat tillsammans med ett konfidensvärde.

Rensa resurser

Om du vill ta bort LargePersonGroup som du skapade i den här övningen kör du anropet LargePersonGroup – Delete.

curl -v -X DELETE "https://westus.api.cognitive.microsoft.com/face/v1.0/largepersongroups/{largePersonGroupId}" -H "Ocp-Apim-Subscription-Key: {subscription key}"

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.

Nästa steg

I den här snabbstarten har du lärt dig hur du använder ANSIKTS-REST-API:et för att utföra grundläggande ansiktsigenkänningsuppgifter. Lär dig sedan om de olika ansiktsidentifieringsmodellerna och hur du anger rätt modell för ditt användningsfall.