Guia de início rápido: usar o serviço Face

Artigo
06/13/2024

Importante

Se estiver a utilizar produtos ou serviços da Microsoft para processar Dados Biométricos, é responsável por: (i) notificar os titulares dos dados, incluindo no que diz respeito a períodos de retenção e destruição; (ii) obtenção do consentimento dos titulares dos dados; e (iii) eliminar os Dados Biométricos, tudo conforme adequado e exigido ao abrigo dos Requisitos de Proteção de Dados aplicáveis. "Dados Biométricos" terá o significado definido no Artigo 4 do RGPD e, se aplicável, termos equivalentes em outros requisitos de proteção de dados. Para obter informações relacionadas, consulte Dados e privacidade para o rosto.

Atenção

O acesso ao serviço presencial é limitado com base em critérios de elegibilidade e uso, a fim de apoiar nossos princípios de IA responsável. O serviço Face só está disponível para clientes e parceiros geridos pela Microsoft. Use o formulário de admissão de Reconhecimento Facial para solicitar acesso. Para obter mais informações, consulte a página Acesso limitado Face.

Introdução ao reconhecimento facial usando a biblioteca de cliente Face para .NET. O serviço Azure AI Face fornece acesso a algoritmos avançados para detetar e reconhecer rostos humanos em imagens. Siga estas etapas para instalar o pacote e experimente o código de exemplo para identificação facial básica usando imagens remotas.

Documentação | de referência Pacote de código-fonte | da biblioteca (NuGet)Amostras |

Pré-requisitos

Subscrição do Azure - Criar uma gratuitamente
O IDE do Visual Studio ou a versão atual do .NET Core.
Sua conta do Azure deve ter uma Cognitive Services Contributor função atribuída para que você concorde com os termos de IA responsável e crie um recurso. Para atribuir essa função à sua conta, siga as etapas na documentação Atribuir funções ou entre em contato com o administrador.
Depois de ter sua assinatura do Azure, crie um recurso Face no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Face.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se o recurso criado na seção Pré-requisitos for implantado com êxito, selecione Ir para o recurso em Próximas etapas. Você pode encontrar sua chave e ponto de extremidade em Gerenciamento de Recursos na página Chaves e Ponto de Extremidade . Sua chave de recurso não é a mesma que sua ID de assinatura do Azure.

Gorjeta

Não inclua a chave diretamente no seu código e nunca a publique publicamente. Consulte o artigo de segurança dos serviços de IA do Azure para obter mais opções de autenticação, como o Azure Key Vault.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

Para definir a VISION_KEY variável de ambiente, substitua your-key por uma das chaves do seu recurso.
Para definir a variável de VISION_ENDPOINT ambiente, substitua your-endpoint pelo ponto de extremidade do seu recurso.

Windows
Linux

setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=your-key

export VISION_ENDPOINT=your-endpoint

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Identificar e verificar rostos

Criar um novo aplicativo C#
- Visual Studio IDE
- CLI
Usando o Visual Studio, crie um novo aplicativo .NET Core.

Instalar a biblioteca de cliente

Depois de criar um novo projeto, instale a biblioteca de cliente clicando com o botão direito do mouse na solução do projeto no Gerenciador de Soluções e selecionando Gerenciar Pacotes NuGet. No gestor de pacotes que abre, selecione Procurar, marque a caixa Incluir pré-lançamento e procure Microsoft.Azure.CognitiveServices.Vision.Face. Selecione a versão mais recente e, em seguida , Instalar.
Em uma janela de console (como cmd, PowerShell ou Bash), use o dotnet new comando para criar um novo aplicativo de console com o nome face-quickstart. Este comando cria um projeto C# "Hello World" simples com um único arquivo de origem: program.cs.
```
dotnet new console -n face-quickstart
```
Altere seu diretório para a pasta do aplicativo recém-criada. Você pode criar o aplicativo com:
```
dotnet build
```
A saída da compilação não deve conter avisos ou erros.
```
...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...
```
Instalar a biblioteca de cliente

Dentro do diretório do aplicativo, instale a biblioteca de cliente Face para .NET com o seguinte comando:
```
dotnet add package Microsoft.Azure.CognitiveServices.Vision.Face --prerelease
```

Adicione o seguinte código ao arquivo Program.cs .

Nota

Se você não recebeu acesso ao serviço Face usando o formulário de admissão, algumas dessas funções não funcionarão.

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

Executar a aplicação
- Visual Studio IDE
- CLI
Execute o aplicativo clicando no botão Depurar na parte superior da janela do IDE.
Execute o aplicativo a partir do diretório do aplicativo com o dotnet run comando.
```
dotnet run
```

Saída

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

Gorjeta

A API Face é executada em um conjunto de modelos pré-construídos que são estáticos por natureza (o desempenho do modelo não regredirá ou melhorará à medida que o serviço for executado). Os resultados que o modelo produz podem mudar se a Microsoft atualizar o back-end do modelo sem migrar para uma versão de modelo totalmente nova. Para aproveitar uma versão mais recente de um modelo, você pode treinar novamente seu PersonGroup, especificando o modelo mais recente como um parâmetro com as mesmas imagens de registro.

Clean up resources (Limpar recursos)

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados a ele.

Para excluir o PersonGroup que você criou neste início rápido, execute o seguinte código em seu programa:

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

Defina o método de exclusão com o seguinte código:

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

Próximos passos

Neste guia de início rápido, você aprendeu como usar a biblioteca de cliente Face para .NET para fazer a identificação facial básica. Em seguida, saiba mais sobre os diferentes modelos de deteção de rosto e como especificar o modelo certo para o seu caso de uso.

Especificar uma versão do modelo de deteção de rosto

O que é o serviço Face?
Um código de exemplo mais extenso pode ser encontrado no GitHub.

Comece a usar o reconhecimento facial usando a biblioteca de cliente Face para Python. Siga estas etapas para instalar o pacote e experimentar o código de exemplo para tarefas básicas. O serviço Face fornece acesso a algoritmos avançados para detetar e reconhecer rostos humanos em imagens. Siga estas etapas para instalar o pacote e experimente o código de exemplo para identificação facial básica usando imagens remotas.

Documentação | de referência Pacote de código-fonte | da biblioteca (PiPy)Amostras |

Pré-requisitos

Subscrição do Azure - Criar uma gratuitamente
Python 3.x
- Sua instalação do Python deve incluir pip. Você pode verificar se você tem pip instalado executando pip --version na linha de comando. Obtenha pip instalando a versão mais recente do Python.
Sua conta do Azure deve ter uma Cognitive Services Contributor função atribuída para que você concorde com os termos de IA responsável e crie um recurso. Para atribuir essa função à sua conta, siga as etapas na documentação Atribuir funções ou entre em contato com o administrador.
Depois de ter sua assinatura do Azure, crie um recurso Face no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Face.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Gorjeta

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

Para definir a VISION_KEY variável de ambiente, substitua your-key por uma das chaves do seu recurso.
Para definir a variável de VISION_ENDPOINT ambiente, substitua your-endpoint pelo ponto de extremidade do seu recurso.

Windows
Linux

setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=your-key

export VISION_ENDPOINT=your-endpoint

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Identificar e verificar rostos

Instalar a biblioteca de cliente

Depois de instalar o Python, pode instalar a biblioteca de cliente com:
```
pip install --upgrade azure-cognitiveservices-vision-face
```

Criar uma aplicação Python nova

Crie um novo script Python — quickstart-file.py, por exemplo. Em seguida, abra-o no seu editor ou IDE preferido e cole no código a seguir.

Nota

Se você não recebeu acesso ao serviço Face usando o formulário de admissão, algumas dessas funções não funcionarão.

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

Execute seu aplicativo de reconhecimento facial a partir do diretório do aplicativo com o python comando.
```
python quickstart-file.py
```
Gorjeta

A API Face é executada em um conjunto de modelos pré-construídos que são estáticos por natureza (o desempenho do modelo não regredirá ou melhorará à medida que o serviço for executado). Os resultados que o modelo produz podem mudar se a Microsoft atualizar o back-end do modelo sem migrar para uma versão de modelo totalmente nova. Para aproveitar uma versão mais recente de um modelo, você pode treinar novamente seu PersonGroup, especificando o modelo mais recente como um parâmetro com as mesmas imagens de registro.

Saída

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.

Clean up resources (Limpar recursos)

Para excluir o PersonGroup que você criou neste início rápido, execute o seguinte código em seu script:

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

Próximos passos

Neste início rápido, você aprendeu como usar a biblioteca de cliente Face para Python para fazer identificação facial básica. Em seguida, saiba mais sobre os diferentes modelos de deteção de rosto e como especificar o modelo certo para o seu caso de uso.

Especificar uma versão do modelo de deteção de rosto

O que é o serviço Face?
Um código de exemplo mais extenso pode ser encontrado no GitHub.

Comece a usar o reconhecimento facial usando a biblioteca de cliente Face para JavaScript. Siga estas etapas para instalar o pacote e experimentar o código de exemplo para tarefas básicas. O serviço Face fornece acesso a algoritmos avançados para detetar e reconhecer rostos humanos em imagens. Siga estas etapas para instalar o pacote e experimente o código de exemplo para identificação facial básica usando imagens remotas.

Documentação | de referência Pacote de código-fonte | da biblioteca (npm)Exemplos |

Pré-requisitos

Subscrição do Azure - Criar uma gratuitamente
A última versão do Node.js
Sua conta do Azure deve ter uma Cognitive Services Contributor função atribuída para que você concorde com os termos de IA responsável e crie um recurso. Para atribuir essa função à sua conta, siga as etapas na documentação Atribuir funções ou entre em contato com o administrador.
Depois de ter sua assinatura do Azure, crie um recurso Face no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Face.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Gorjeta

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

Para definir a VISION_KEY variável de ambiente, substitua your-key por uma das chaves do seu recurso.
Para definir a variável de VISION_ENDPOINT ambiente, substitua your-endpoint pelo ponto de extremidade do seu recurso.

Windows
Linux

setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=your-key

export VISION_ENDPOINT=your-endpoint

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Identificar e verificar rostos

Criar uma nova aplicação Node.js

Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue para a mesma.
```
mkdir myapp && cd myapp
```
Execute o comando npm init para criar uma aplicação de nó com um ficheiro package.json.
```
npm init
```
Instale os @azure-rest/ai-vision-face pacotes npm:
```
npm install @azure-rest/ai-vision-face
```
O arquivo do package.json seu aplicativo é atualizado com as dependências.

Crie um arquivo chamado index.js, abra-o em um editor de texto e cole o seguinte código:

Nota

Se você não recebeu acesso ao serviço Face usando o formulário de admissão, algumas dessas funções não funcionarão.

const { randomUUID } = require("crypto");

const { AzureKeyCredential } = require("@azure/core-auth");

const createFaceClient = require("@azure-rest/ai-vision-face").default,
  { FaceAttributeTypeRecognition04, getLongRunningPoller } = require("@azure-rest/ai-vision-face");

/**
 * NOTE This sample 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.
 */
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const main = async () => {
  const endpoint = process.env["FACE_ENDPOINT"] ?? "<endpoint>";
  const apikey = process.env["FACE_APIKEY"] ?? "<apikey>";
  const credential = new AzureKeyCredential(apikey);
  const client = createFaceClient(endpoint, credential);

  const imageBaseUrl =
    "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/Face/images/";
  const personGroupId = randomUUID();

  console.log("========IDENTIFY FACES========");
  console.log();

  // Create a dictionary for all your images, grouping similar ones under the same key.
  const personDictionary = {
    "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.
  const sourceImageFileName = "identification1.jpg";

  // Create a person group.
  console.log(`Creating a person group with ID: ${personGroupId}`);
  await client.path("/persongroups/{personGroupId}", personGroupId).put({
    body: {
      name: personGroupId,
      recognitionModel: "recognition_04",
    },
  });

  // The similar faces will be grouped into a single person group person.
  console.log("Adding faces to person group...");
  await Promise.all(
    Object.keys(personDictionary).map(async (name) => {
      console.log(`Create a persongroup person: ${name}`);
      const createPersonGroupPersonResponse = await client
        .path("/persongroups/{personGroupId}/persons", personGroupId)
        .post({
          body: { name },
        });

      const { personId } = createPersonGroupPersonResponse.body;

      await Promise.all(
        personDictionary[name].map(async (similarImage) => {
          // Check if the image is of sufficent quality for recognition.
          const detectResponse = await client.path("/detect").post({
            contentType: "application/json",
            queryParameters: {
              detectionModel: "detection_03",
              recognitionModel: "recognition_04",
              returnFaceId: false,
              returnFaceAttributes: [FaceAttributeTypeRecognition04.QUALITY_FOR_RECOGNITION],
            },
            body: { url: `${imageBaseUrl}${similarImage}` },
          });

          const sufficientQuality = detectResponse.body.every(
            (face) => face.faceAttributes?.qualityForRecognition === "high",
          );
          if (!sufficientQuality) {
            return;
          }

          // Quality is sufficent, add to group.
          console.log(
            `Add face to the person group person: (${name}) from image: (${similarImage})`,
          );
          await client
            .path(
              "/persongroups/{personGroupId}/persons/{personId}/persistedfaces",
              personGroupId,
              personId,
            )
            .post({
              queryParameters: { detectionModel: "detection_03" },
              body: { url: `${imageBaseUrl}${similarImage}` },
            });
        }),
      );
    }),
  );
  console.log("Done adding faces to person group.");

  // Start to train the person group.
  console.log();
  console.log(`Training person group: ${personGroupId}`);
  const trainResponse = await client
    .path("/persongroups/{personGroupId}/train", personGroupId)
    .post();
  const poller = await getLongRunningPoller(client, trainResponse);
  await poller.pollUntilDone();
  console.log(`Training status: ${poller.getOperationState().status}`);
  if (poller.getOperationState().status !== "succeeded") {
    return;
  }

  // Detect faces from source image url and only take those with sufficient quality for recognition.
  const detectResponse = await client.path("/detect").post({
    contentType: "application/json",
    queryParameters: {
      detectionModel: "detection_03",
      recognitionModel: "recognition_04",
      returnFaceId: true,
    },
    body: { url: `${imageBaseUrl}${sourceImageFileName}` },
  });
  const faceIds = detectResponse.body.map((face) => face.faceId);

  // Identify the faces in a person group.
  const identifyResponse = await client.path("/identify").post({
    body: { faceIds, personGroupId },
  });
  await Promise.all(
    identifyResponse.body.map(async (result) => {
      try {
        const getPersonGroupPersonResponse = await client
          .path(
            "/persongroups/{personGroupId}/persons/{personId}",
            personGroupId,
            result.candidates[0].personId,
          )
          .get();
        const person = getPersonGroupPersonResponse.body;
        console.log(
          `Person: ${person.name} is identified for face in: ${sourceImageFileName} with ID: ${result.faceId}. Confidence: ${result.candidates[0].confidence}`,
        );

        // Verification:
        const verifyResponse = await client.path("/verify").post({
          body: {
            faceId: result.faceId,
            personGroupId,
            personId: person.personId,
          },
        });
        console.log(
          `Verification result between face ${result.faceId} and person ${person.personId}: ${verifyResponse.body.isIdentical} with confidence: ${verifyResponse.body.confidence}`,
        );
      } catch (error) {
        console.log(`No persons identified for face with ID ${result.faceId}`);
      }
    }),
  );
  console.log();

  // Delete person group.
  console.log(`Deleting person group: ${personGroupId}`);
  await client.path("/persongroups/{personGroupId}", personGroupId).delete();
  console.log();

  console.log("Done.");
};

main().catch(console.error);

Execute a aplicação com o comando node no seu ficheiro de início rápido.
```
node index.js
```

Saída

========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.
Training status: succeeded.
No persons identified for face with ID 259dd648-be70-499c-9942-3512594e21eb
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.
Verification result between face bb7f7f542-c338-4a40-ad52-e61772bc6e14 and person de1d7dea-a393-4f69-9062-10cb66d4cf17: true with confidence: 0.96921
Verification result between face 600dc1b4-b2c4-4516-87de-edbbdd8d7632 and person 05fd84e4-41b0-4716-b767-4376e33fa207: true with confidence: 0.92886
Verification result between face e83b494f-9ad2-473f-9d86-3de79c01e345 and person c5124fe2-39dd-47ba-9163-1ed2998fdeb2: true with confidence: 0.96725

Deleting person group: c08484e0-044b-4610-8b7e-c957584e5d2d

Done.

Clean up resources (Limpar recursos)

Próximos passos

Neste guia de início rápido, você aprendeu como usar a biblioteca de cliente Face para JavaScript para fazer a identificação facial básica. Em seguida, saiba mais sobre os diferentes modelos de deteção de rosto e como especificar o modelo certo para o seu caso de uso.

Especificar uma versão do modelo de deteção de rosto

O que é o serviço Face?
Um código de exemplo mais extenso pode ser encontrado no GitHub.

Comece a usar o reconhecimento facial usando a API Face REST. O serviço Face fornece acesso a algoritmos avançados para detetar e reconhecer rostos humanos em imagens.

Nota

Este guia de início rápido usa comandos cURL para chamar a API REST. Você também pode chamar a API REST usando uma linguagem de programação. Cenários complexos, como a identificação facial, são mais fáceis de implementar usando um SDK de linguagem. Consulte os exemplos do GitHub para obter exemplos em C#, Python, Java, JavaScript e Go.

Pré-requisitos

Subscrição do Azure - Criar uma gratuitamente
Sua conta do Azure deve ter uma Cognitive Services Contributor função atribuída para que você concorde com os termos de IA responsável e crie um recurso. Para atribuir essa função à sua conta, siga as etapas na documentação Atribuir funções ou entre em contato com o administrador.
Depois de ter sua assinatura do Azure, crie um recurso Face no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API do Face. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no início rápido.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.
PowerShell versão 6.0+ ou um aplicativo de linha de comando semelhante.
cURL instalado.

Identificar e verificar rostos

Nota

Se você não recebeu acesso ao serviço Face usando o formulário de admissão, algumas dessas funções não funcionarão.

Primeiro, chame a API de deteção na face de origem. Este é o rosto que tentaremos identificar do grupo maior. Copie o comando a seguir para um editor de texto, insira sua própria chave e ponto de extremidade e, em seguida, copie-o em uma janela do shell e execute-o.

Windows
Linux

curl.exe -v -X POST "https://{resource endpoint}/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""}"

curl -v -X POST "https://{resource endpoint}/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\"}"

Salve a cadeia de caracteres de identificação facial retornada em um local temporário. Você vai usá-lo novamente no final.

Em seguida, você precisará criar um LargePersonGroup e dar-lhe uma ID arbitrária que corresponda ao padrão ^[a-z0-9-_]+$regex. Este objeto armazenará os dados de face agregados de várias pessoas. Execute o seguinte comando, inserindo sua própria chave. Opcionalmente, altere o nome e os metadados do grupo no corpo da solicitação.

Windows
Linux

curl.exe -v -X PUT "https://{resource endpoint}/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_04""
}"

curl -v -X PUT "https://{resource endpoint}/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_04\"
}"

Salve a ID especificada do grupo criado em um local temporário.

Em seguida, você criará objetos Person que pertencem ao grupo. Execute o seguinte comando, inserindo sua própria chave e a ID do LargePersonGroup da etapa anterior. Este comando cria uma Pessoa chamada "Family1-Dad".

Windows
Linux

curl.exe -v -X POST "https://{resource endpoint}/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.""
}"

curl -v -X POST "https://{resource endpoint}/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.\"
}"

Depois de executar esse comando, execute-o novamente com diferentes dados de entrada para criar mais objetos Person : "Family1-Mom", "Family1-Son", "Family1-Daughter", "Family2-Lady" e "Family2-Man".

Salve os IDs de cada Pessoa criada, é importante acompanhar qual nome de pessoa tem qual ID.

Em seguida, você precisará detetar novos rostos e associá-los aos objetos Person existentes. O comando a seguir deteta um rosto da imagem Family1-Dad1.jpg e o adiciona à pessoa correspondente. Você precisa especificar o personId como o ID que foi retornado quando você criou o objeto Person "Family1-Dad". O nome da imagem corresponde ao nome da Pessoa criada. Insira também o ID LargePersonGroup e sua chave nos campos apropriados.
- Windows
- Linux
```
curl.exe -v -X POST "https://{resource endpoint}/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""}"
```
```
curl -v -X POST "https://{resource endpoint}/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\"}"
```
Em seguida, execute o comando acima novamente com uma imagem de origem diferente e Pessoa de destino. As imagens disponíveis são: Family1-Dad1.jpg, Family1-Dad2.jpg Family1-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 e Family2-Man2.jpg. Certifique-se de que a Pessoa cujo ID você especifica na chamada da API corresponde ao nome do arquivo de imagem no corpo da solicitação.

No final desta etapa, você deve ter vários objetos Person cada um com uma ou mais faces correspondentes, detetados diretamente das imagens fornecidas.

Em seguida, treine o LargePersonGroup com os dados faciais atuais. A operação de treinamento ensina o modelo a associar características faciais, às vezes agregadas a partir de várias imagens de origem, a cada pessoa. Insira o ID LargePersonGroup e sua chave antes de executar o comando.

Windows
Linux

curl.exe -v -X POST "https://{resource endpoint}/face/v1.0/largepersongroups/{largePersonGroupId}/train" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data ""

curl -v -X POST "https://{resource endpoint}/face/v1.0/largepersongroups/{largePersonGroupId}/train" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data ""

Verifique se o status do treinamento foi bem-sucedido. Caso contrário, aguarde um pouco e consulte novamente.

Windows
Linux

curl.exe -v "https://{resource endpoint}/face/v1.0/largepersongroups/{largePersonGroupId}/training" -H "Ocp-Apim-Subscription-Key: {subscription key}"

curl -v "https://{resource endpoint}/face/v1.0/largepersongroups/{largePersonGroupId}/training" -H "Ocp-Apim-Subscription-Key: {subscription key}"

Agora você está pronto para chamar a API de identificação, usando o ID do rosto de origem da primeira etapa e o ID do LargePersonGroup . Insira esses valores nos campos apropriados no corpo da solicitação e insira sua chave.

Windows
Linux

curl.exe -v -X POST "https://{resource endpoint}/face/v1.0/identify" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii "{
    ""largePersonGroupId"": ""INSERT_PERSONGROUP_ID"",
    ""faceIds"": [
        ""INSERT_SOURCE_FACE_ID""
    ],
    ""maxNumOfCandidatesReturned"": 1,
    ""confidenceThreshold"": 0.5
}"

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

A resposta deve fornecer-lhe um ID de Pessoa indicando a pessoa identificada com o rosto de origem. Deve ser o ID que corresponde à pessoa "Família1-Pai", porque o rosto de origem é dessa pessoa.

Para fazer a verificação facial, você usará o ID da pessoa retornado na etapa anterior, o ID do LargePersonGroup e também o ID do rosto de origem. Insira esses valores nos campos no corpo da solicitação e insira sua chave.

Windows
Linux

curl.exe -v -X POST "https://{resource endpoint}/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""
}"

curl -v -X POST "https://{resource endpoint}/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\"
}"

A resposta deve fornecer um resultado de verificação booleano juntamente com um valor de confiança.

Clean up resources (Limpar recursos)

Para excluir o LargePersonGroup criado neste exercício, execute a chamada LargePersonGroup - Delete .

Windows
Linux

curl.exe -v -X DELETE "https://{resource endpoint}/face/v1.0/largepersongroups/{largePersonGroupId}" -H "Ocp-Apim-Subscription-Key: {subscription key}"

curl -v -X DELETE "https://{resource endpoint}/face/v1.0/largepersongroups/{largePersonGroupId}" -H "Ocp-Apim-Subscription-Key: {subscription key}"

Próximos passos

Neste guia de início rápido, você aprendeu como usar a API Face REST para fazer tarefas básicas de reconhecimento facial. Em seguida, saiba mais sobre os diferentes modelos de deteção de rosto e como especificar o modelo certo para o seu caso de uso.

Especificar uma versão do modelo de deteção de rosto

O que é o serviço Face?

Partilhar via

Guia de início rápido: usar o serviço Face

Pré-requisitos

Criar variáveis de ambiente

Identificar e verificar rostos

Instalar a biblioteca de cliente

Instalar a biblioteca de cliente

Saída

Clean up resources (Limpar recursos)

Próximos passos

Pré-requisitos

Criar variáveis de ambiente

Identificar e verificar rostos

Saída

Clean up resources (Limpar recursos)

Próximos passos

Pré-requisitos

Criar variáveis de ambiente

Identificar e verificar rostos

Saída

Clean up resources (Limpar recursos)

Próximos passos

Pré-requisitos

Identificar e verificar rostos

Clean up resources (Limpar recursos)

Próximos passos

Comentários

Comentários

Recursos adicionais