Szybki start: korzystanie z usługi rozpoznawania twarzy

  • Artykuł

Ważne

Jeśli używasz produktów lub usług firmy Microsoft do przetwarzania danych biometrycznych, odpowiadasz za: (i) powiadamianie podmiotów danych, w tym w odniesieniu do okresów przechowywania i zniszczenia; ii) uzyskiwanie zgody od podmiotów danych; oraz (iii) usunięcie danych biometrycznych, zgodnie z potrzebami i wymaganych zgodnie z odpowiednimi wymaganiami dotyczącymi ochrony danych. "Dane biometryczne" będą miały znaczenie określone w art. Aby uzyskać powiązane informacje, zobacz Dane i prywatność twarzy.

Uwaga

Dostęp do usługi rozpoznawania twarzy jest ograniczony na podstawie kryteriów kwalifikowalności i użycia w celu obsługi naszych zasad odpowiedzialnej sztucznej inteligencji. Usługa rozpoznawania twarzy jest dostępna tylko dla klientów i partnerów zarządzanych przez firmę Microsoft. Użyj formularza do wprowadzania rozpoznawania twarzy, aby ubiegać się o dostęp. Aby uzyskać więcej informacji, zobacz stronę Dostęp ograniczony do twarzy.

Rozpocznij pracę z rozpoznawaniem twarzy przy użyciu biblioteki klienta rozpoznawania twarzy dla platformy .NET. Usługa rozpoznawania twarzy zapewnia dostęp do zaawansowanych algorytmów do wykrywania i rozpoznawania ludzkich twarzy na obrazach. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod podstawowej identyfikacji twarzy przy użyciu obrazów zdalnych.

Dokumentacja referencyjna — pakiet | kodu | źródłowego biblioteki źródłowej (NuGet)Samples |

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz bezpłatnie
  • Środowisko IDE programu Visual Studio lub bieżąca wersja platformy .NET Core.
  • Twoje konto platformy Azure musi mieć przypisaną Cognitive Services Contributor rolę, aby wyrazić zgodę na warunki odpowiedzialnego używania sztucznej inteligencji i utworzyć zasób. Aby uzyskać przypisaną tę rolę do konta, wykonaj kroki opisane w dokumentacji Przypisywanie ról lub skontaktuj się z administratorem.
  • Po utworzeniu subskrypcji platformy Azure utwórz zasób rozpoznawania twarzy w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Po wdrożeniu wybierz pozycję Przejdź do zasobu.
    • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z interfejsem API rozpoznawania twarzy.
    • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie zapisz swoje poświadczenia w zmiennych środowiskowych na komputerze lokalnym, na których jest uruchamiana aplikacja.

Przejdź do portalu Azure Portal. Jeśli zasób utworzony w sekcji Wymagania wstępne został wdrożony pomyślnie, wybierz pozycję Przejdź do zasobu w obszarze Następne kroki. Klucz i punkt końcowy można znaleźć w obszarze Zarządzanie zasobami na stronie Klucze i punkt końcowy . Klucz zasobu nie jest taki sam jak identyfikator subskrypcji platformy Azure.

Napiwek

Nie dołączaj klucza bezpośrednio do kodu i nigdy nie publikuj go publicznie. Aby uzyskać więcej opcji uwierzytelniania, takich jak usługa Azure Key Vault, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

Aby ustawić zmienną środowiskową dla klucza i punktu końcowego, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

  1. Aby ustawić zmienną VISION_KEY środowiskową, zastąp your-key element jednym z kluczy zasobu.
  2. Aby ustawić zmienną VISION_ENDPOINT środowiskową, zastąp your-endpoint element punktem końcowym zasobu.
setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które będą odczytywać zmienne środowiskowe, w tym okno konsoli.

Identyfikowanie i weryfikowanie twarzy

  1. Tworzenie nowej aplikacji w języku C#

    Za pomocą programu Visual Studio utwórz nową aplikację .NET Core.

    Instalowanie biblioteki klienta

    Po utworzeniu nowego projektu zainstaluj bibliotekę klienta, klikając prawym przyciskiem myszy rozwiązanie projektu w Eksplorator rozwiązań i wybierając polecenie Zarządzaj pakietami NuGet. W otwartym menedżerze pakietów wybierz pozycję Przeglądaj, zaznacz opcję Uwzględnij wersję wstępną i wyszukaj ciąg Microsoft.Azure.CognitiveServices.Vision.Face. Wybierz najnowszą wersję, a następnie pozycję Zainstaluj.

  2. Dodaj następujący kod do pliku Program.cs .

    Uwaga

    Jeśli nie otrzymasz dostępu do usługi rozpoznawania twarzy przy użyciu formularza do wprowadzania, niektóre z tych funkcji nie będą działać.

    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. Uruchamianie aplikacji

    Uruchom aplikację, klikając przycisk Debuguj w górnej części okna IDE.

Wyjście

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

Napiwek

Interfejs API rozpoznawania twarzy działa na zestawie wstępnie utworzonych modeli, które są statyczne z natury (wydajność modelu nie ulegnie pogorszeniu ani nie poprawi się w miarę uruchamiania usługi). Wyniki generowane przez model mogą ulec zmianie, jeśli firma Microsoft aktualizuje zaplecze modelu bez migracji do całkowicie nowej wersji modelu. Aby skorzystać z nowszej wersji modelu, możesz ponownie wytrenować grupę PersonGroup, określając nowszy model jako parametr z tymi samymi obrazami rejestracji.

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Azure AI, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów.

Aby usunąć grupę PersonGroup utworzoną w tym przewodniku Szybki start, uruchom następujący kod w programie:

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

Zdefiniuj metodę usuwania przy użyciu następującego kodu:

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

Następne kroki

W tym przewodniku Szybki start pokazano, jak używać biblioteki klienta rozpoznawania twarzy dla platformy .NET do wykonywania podstawowej identyfikacji twarzy. Następnie dowiesz się więcej o różnych modelach wykrywania twarzy i sposobach określania odpowiedniego modelu dla danego przypadku użycia.

Określanie wersji modelu wykrywania twarzy

Wprowadzenie do rozpoznawania twarzy przy użyciu biblioteki klienta rozpoznawania twarzy dla języka JavaScript. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod dla podstawowych zadań. Usługa rozpoznawania twarzy zapewnia dostęp do zaawansowanych algorytmów do wykrywania i rozpoznawania ludzkich twarzy na obrazach. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod podstawowej identyfikacji twarzy przy użyciu obrazów zdalnych.

Dokumentacja referencyjna — przykłady | pakietu kodu | źródłowego biblioteki źródłowej (npm)Samples |

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz bezpłatnie
  • Najnowsza wersja Node.js
  • Twoje konto platformy Azure musi mieć przypisaną Cognitive Services Contributor rolę, aby wyrazić zgodę na warunki odpowiedzialnego używania sztucznej inteligencji i utworzyć zasób. Aby uzyskać przypisaną tę rolę do konta, wykonaj kroki opisane w dokumentacji Przypisywanie ról lub skontaktuj się z administratorem.
  • Po utworzeniu subskrypcji platformy Azure utwórz zasób rozpoznawania twarzy w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Po wdrożeniu wybierz pozycję Przejdź do zasobu.
    • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z interfejsem API rozpoznawania twarzy.
    • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie zapisz swoje poświadczenia w zmiennych środowiskowych na komputerze lokalnym, na których jest uruchamiana aplikacja.

Przejdź do portalu Azure Portal. Jeśli zasób utworzony w sekcji Wymagania wstępne został wdrożony pomyślnie, wybierz pozycję Przejdź do zasobu w obszarze Następne kroki. Klucz i punkt końcowy można znaleźć w obszarze Zarządzanie zasobami na stronie Klucze i punkt końcowy . Klucz zasobu nie jest taki sam jak identyfikator subskrypcji platformy Azure.

Napiwek

Nie dołączaj klucza bezpośrednio do kodu i nigdy nie publikuj go publicznie. Aby uzyskać więcej opcji uwierzytelniania, takich jak usługa Azure Key Vault, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

Aby ustawić zmienną środowiskową dla klucza i punktu końcowego, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

  1. Aby ustawić zmienną VISION_KEY środowiskową, zastąp your-key element jednym z kluczy zasobu.
  2. Aby ustawić zmienną VISION_ENDPOINT środowiskową, zastąp your-endpoint element punktem końcowym zasobu.
setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które będą odczytywać zmienne środowiskowe, w tym okno konsoli.

Identyfikowanie i weryfikowanie twarzy

  1. Tworzenie nowej aplikacji Node.js

    W oknie konsoli (na przykład cmd, PowerShell lub Bash) utwórz nowy katalog dla aplikacji i przejdź do niego.

    mkdir myapp && cd myapp

    Uruchom polecenie npm init, aby utworzyć aplikację Node przy użyciu pliku package.json.

    npm init

  2. ms-rest-azure Zainstaluj pakiety npm i azure-cognitiveservices-face :

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

    Plik aplikacji package.json jest aktualizowany przy użyciu zależności.

  3. Utwórz plik o nazwie index.js, otwórz go w edytorze tekstów i wklej następujący kod:

    Uwaga

    Jeśli nie otrzymasz dostępu do usługi rozpoznawania twarzy przy użyciu formularza do wprowadzania, niektóre z tych funkcji nie będą działać.

    '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. Uruchom aplikację, wykonując polecenie node dla pliku szybkiego startu.

    node index.js

Wyjście

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

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Azure AI, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów.

Następne kroki

W tym przewodniku Szybki start przedstawiono sposób użycia biblioteki klienta rozpoznawania twarzy dla języka JavaScript do podstawowej identyfikacji twarzy. Następnie dowiesz się więcej o różnych modelach wykrywania twarzy i sposobach określania odpowiedniego modelu dla danego przypadku użycia.

Określanie wersji modelu wykrywania twarzy

Wprowadzenie do rozpoznawania twarzy przy użyciu biblioteki klienta rozpoznawania twarzy dla języka Python. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod dla podstawowych zadań. Usługa rozpoznawania twarzy zapewnia dostęp do zaawansowanych algorytmów do wykrywania i rozpoznawania ludzkich twarzy na obrazach. Wykonaj następujące kroki, aby zainstalować pakiet i wypróbować przykładowy kod podstawowej identyfikacji twarzy przy użyciu obrazów zdalnych.

Dokumentacja referencyjna — przykłady | pakietu kodu | źródłowego biblioteki źródłowej (PiPy)Samples |

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz bezpłatnie
  • Python 3.x
    • Instalacja języka Python powinna zawierać narzędzie pip. Możesz sprawdzić, czy masz zainstalowane narzędzie pip, uruchamiając polecenie pip --version w wierszu polecenia. Pobierz narzędzie pip, instalując najnowszą wersję języka Python.
  • Twoje konto platformy Azure musi mieć przypisaną Cognitive Services Contributor rolę, aby wyrazić zgodę na warunki odpowiedzialnego używania sztucznej inteligencji i utworzyć zasób. Aby uzyskać przypisaną tę rolę do konta, wykonaj kroki opisane w dokumentacji Przypisywanie ról lub skontaktuj się z administratorem.
  • Po utworzeniu subskrypcji platformy Azure utwórz zasób rozpoznawania twarzy w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Po wdrożeniu wybierz pozycję Przejdź do zasobu.
    • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z interfejsem API rozpoznawania twarzy.
    • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.

Tworzenie zmiennych środowiskowych

W tym przykładzie zapisz swoje poświadczenia w zmiennych środowiskowych na komputerze lokalnym, na których jest uruchamiana aplikacja.

Przejdź do portalu Azure Portal. Jeśli zasób utworzony w sekcji Wymagania wstępne został wdrożony pomyślnie, wybierz pozycję Przejdź do zasobu w obszarze Następne kroki. Klucz i punkt końcowy można znaleźć w obszarze Zarządzanie zasobami na stronie Klucze i punkt końcowy . Klucz zasobu nie jest taki sam jak identyfikator subskrypcji platformy Azure.

Napiwek

Nie dołączaj klucza bezpośrednio do kodu i nigdy nie publikuj go publicznie. Aby uzyskać więcej opcji uwierzytelniania, takich jak usługa Azure Key Vault, zobacz artykuł Dotyczący zabezpieczeń usług Azure AI.

Aby ustawić zmienną środowiskową dla klucza i punktu końcowego, otwórz okno konsoli i postępuj zgodnie z instrukcjami dotyczącymi systemu operacyjnego i środowiska programistycznego.

  1. Aby ustawić zmienną VISION_KEY środowiskową, zastąp your-key element jednym z kluczy zasobu.
  2. Aby ustawić zmienną VISION_ENDPOINT środowiskową, zastąp your-endpoint element punktem końcowym zasobu.
setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Po dodaniu zmiennych środowiskowych może być konieczne ponowne uruchomienie wszystkich uruchomionych programów, które będą odczytywać zmienne środowiskowe, w tym okno konsoli.

Identyfikowanie i weryfikowanie twarzy

  1. Instalowanie biblioteki klienta

    Po zainstalowaniu środowiska Python możesz zainstalować bibliotekę klienta przy użyciu następującego polecenia:

    pip install --upgrade azure-cognitiveservices-vision-face

  2. Tworzenie nowej aplikacji w języku Python

    Utwórz nowy skrypt języka Python — na przykład quickstart-file.py. Następnie otwórz go w preferowanym edytorze lub środowisku IDE i wklej następujący kod.

    Uwaga

    Jeśli nie otrzymasz dostępu do usługi rozpoznawania twarzy przy użyciu formularza do wprowadzania, niektóre z tych funkcji nie będą działać.

    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. Uruchom aplikację rozpoznawania twarzy z katalogu aplikacji za python pomocą polecenia .

    python quickstart-file.py

    Napiwek

    Interfejs API rozpoznawania twarzy działa na zestawie wstępnie utworzonych modeli, które są statyczne z natury (wydajność modelu nie ulegnie pogorszeniu ani nie poprawi się w miarę uruchamiania usługi). Wyniki generowane przez model mogą ulec zmianie, jeśli firma Microsoft aktualizuje zaplecze modelu bez migracji do całkowicie nowej wersji modelu. Aby skorzystać z nowszej wersji modelu, możesz ponownie wytrenować grupę PersonGroup, określając nowszy model jako parametr z tymi samymi obrazami rejestracji.

Wyjście

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.

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Azure AI, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów.

Aby usunąć grupę PersonGroup utworzoną w tym przewodniku Szybki start, uruchom następujący kod w skrypicie:

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

Następne kroki

W tym przewodniku Szybki start pokazano, jak używać biblioteki klienta rozpoznawania twarzy dla języka Python do wykonywania podstawowej identyfikacji twarzy. Następnie dowiesz się więcej o różnych modelach wykrywania twarzy i sposobach określania odpowiedniego modelu dla danego przypadku użycia.

Określanie wersji modelu wykrywania twarzy

Wprowadzenie do rozpoznawania twarzy przy użyciu interfejsu API REST rozpoznawania twarzy. Usługa rozpoznawania twarzy zapewnia dostęp do zaawansowanych algorytmów do wykrywania i rozpoznawania ludzkich twarzy na obrazach.

Uwaga

Ten przewodnik Szybki start używa poleceń cURL do wywoływania interfejsu API REST. Interfejs API REST można również wywołać przy użyciu języka programowania. Złożone scenariusze, takie jak identyfikacja twarzy, są łatwiejsze do zaimplementowania przy użyciu zestawu SDK języka. Zobacz przykłady dotyczące usługi GitHub, aby zapoznać się z przykładami w językach C#, Python, Java, JavaScript i Go.

Wymagania wstępne

  • Subskrypcja platformy Azure — utwórz bezpłatnie
  • Twoje konto platformy Azure musi mieć przypisaną Cognitive Services Contributor rolę, aby wyrazić zgodę na warunki odpowiedzialnego używania sztucznej inteligencji i utworzyć zasób. Aby uzyskać przypisaną tę rolę do konta, wykonaj kroki opisane w dokumentacji Przypisywanie ról lub skontaktuj się z administratorem.
  • Po utworzeniu subskrypcji platformy Azure utwórz zasób rozpoznawania twarzy w witrynie Azure Portal, aby uzyskać klucz i punkt końcowy. Po wdrożeniu wybierz pozycję Przejdź do zasobu.
    • Będziesz potrzebować klucza i punktu końcowego z utworzonego zasobu, aby połączyć aplikację z interfejsem API rozpoznawania twarzy. W dalszej części przewodnika Szybki start wklejesz klucz i punkt końcowy do poniższego kodu.
    • Możesz użyć warstwy cenowej bezpłatna (F0), aby wypróbować usługę, a następnie uaktualnić ją do warstwy płatnej dla środowiska produkcyjnego.
  • PowerShell w wersji 6.0 lub podobnej aplikacji wiersza polecenia.

Identyfikowanie i weryfikowanie twarzy

Uwaga

Jeśli nie otrzymasz dostępu do usługi rozpoznawania twarzy przy użyciu formularza do wprowadzania, niektóre z tych funkcji nie będą działać.

  1. Najpierw wywołaj interfejs API wykrywania na źródłowej twarzy. Jest to twarz, którą spróbujemy zidentyfikować z większej grupy. Skopiuj następujące polecenie do edytora tekstów, wstaw własny klucz, a następnie skopiuj go do okna powłoki i uruchom go.

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

    Zapisz zwrócony ciąg face ID w lokalizacji tymczasowej. Użyjesz go ponownie na końcu.

  2. Następnie należy utworzyć grupę LargePersonGroup. Ten obiekt będzie przechowywać zagregowane dane twarzy kilku osób. Uruchom następujące polecenie, wstaw własny klucz. Opcjonalnie zmień nazwę i metadane grupy w treści żądania.

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

    Zapisz zwrócony identyfikator utworzonej grupy w lokalizacji tymczasowej.

  3. Następnie utworzysz obiekty Person , które należą do grupy. Uruchom następujące polecenie, wstawiając własny klucz i identyfikator grupy LargePersonGroup z poprzedniego kroku. To polecenie tworzy osobę o nazwie "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.\"
}"

    Po uruchomieniu tego polecenia uruchom je ponownie z różnymi danymi wejściowymi, aby utworzyć więcej obiektów Osób : "Family1-Mom", "Family1-Son", "Family1-Daughter", "Family2-Lady" i "Family2-Man".

    Zapisz identyfikatory każdej utworzonej osoby . Ważne jest, aby śledzić, które imię i nazwisko ma identyfikator.

  4. Następnie należy wykryć nowe twarze i skojarzyć je z obiektami Person , które istnieją. Następujące polecenie wykrywa twarz z obrazu Family1-Dad1.jpg i dodaje ją do odpowiedniej osoby. Musisz określić personId identyfikator, który został zwrócony podczas tworzenia obiektu Person "Family1-Dad". Nazwa obrazu odpowiada nazwie utworzonej osoby. Wprowadź również identyfikator LargePersonGroup i klucz w odpowiednich polach.

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

    Następnie ponownie uruchom powyższe polecenie z innym obrazem źródłowym i docelową osobą. Dostępne obrazy to: 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 i Family2-Man2.jpg. Upewnij się, że osoba , której identyfikator określony w wywołaniu interfejsu API jest zgodna z nazwą pliku obrazu w treści żądania.

    Na końcu tego kroku powinno istnieć wiele obiektów Osoba , które mają co najmniej jedną odpowiednią twarz, wykrytą bezpośrednio z dostarczonych obrazów.

  5. Następnie przeszkolij grupę LargePersonGroup przy użyciu bieżących danych twarzy. Operacja trenowania uczy modelu, jak skojarzyć cechy twarzy, czasami agregowane z wielu obrazów źródłowych, do każdej pojedynczej osoby. Przed uruchomieniem polecenia wstaw identyfikator LargePersonGroup i klucz.

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

  6. Teraz możesz wywołać interfejs API identyfikowania przy użyciu źródłowego identyfikatora twarzy z pierwszego kroku i identyfikatora LargePersonGroup . Wstaw te wartości do odpowiednich pól w treści żądania i wstaw klucz.

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

    Odpowiedź powinna zawierać identyfikator osoby wskazujący osobę zidentyfikowaną z twarzą źródłową. Powinien to być identyfikator odpowiadający osobie "Family1-Dad", ponieważ źródłowa twarz jest tej osoby.

  7. Aby przeprowadzić weryfikację twarzy, użyjesz identyfikatora osoby zwróconego w poprzednim kroku, identyfikatora LargePersonGroup , a także źródłowego identyfikatora twarzy. Wstaw te wartości do pól w treści żądania i wstaw klucz.

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

    Odpowiedź powinna dać wynik weryfikacji logicznej wraz z wartością ufności.

Czyszczenie zasobów

Aby usunąć grupę LargePersonGroup utworzoną w tym ćwiczeniu, uruchom wywołanie LargePersonGroup — Delete.

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

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Azure AI, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów.

Następne kroki

W tym przewodniku Szybki start przedstawiono sposób używania interfejsu API REST rozpoznawania twarzy do wykonywania podstawowych zadań rozpoznawania twarzy. Następnie dowiesz się więcej o różnych modelach wykrywania twarzy i sposobach określania odpowiedniego modelu dla danego przypadku użycia.

Określanie wersji modelu wykrywania twarzy