Share via

Avvio rapido: Usare il servizio Viso

  • Articolo

Importante

Se si usano prodotti o servizi Microsoft per elaborare dati biometrici, l'utente è responsabile di: (i) inviare comunicazioni agli interessati, indicando anche i periodi di conservazione e i termini di distruzione; (ii) ottenere il consenso dagli interessati; infine (iii) eliminare i dati biometrici; tutto questo secondo quanto richiesto e opportuno, in conformità con i requisiti applicabili di protezione dati. Il termine "Dati biometrici" acquisisce il significato indicato nell'articolo 4 del GDPR e, se applicabile, nelle condizioni equivalenti esposte in altri requisiti di protezione dei dati. Per informazioni correlate, vedere Dati e privacy per Viso.

Attenzione

L'accesso al servizio Viso è limitato in base ai criteri di idoneità e utilizzo al fine di supportare i nostri principi di intelligenza artificiale responsabile. Il servizio Viso è disponibile solo per i clienti e i partner gestiti da Microsoft. Usare il modulo di acquisizione riconoscimento volto per richiedere l'accesso. Per altre informazioni, vedere la pagina Accesso limitato alla funzione Viso.

Introduzione al riconoscimento facciale con la libreria client di Viso per .NET. Il servizio Viso fornisce l'accesso ad algoritmi avanzati per il rilevamento e il riconoscimento dei visi umani nelle immagini. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per eseguire l'autenticazione dei volti di base per mezzo di immagini remote.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (NuGet) | Esempi

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • IDE di Visual Studio o la versione corrente di .NET Core.
  • L'account Azure deve avere un Cognitive Services Contributor ruolo assegnato per consentire all'utente di accettare le condizioni di intelligenza artificiale responsabili e creare una risorsa. Per assegnare questo ruolo all'account, seguire la procedura descritta nella documentazione Assegnare ruoli oppure contattare l'amministratore.
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Viso nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Viso.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Vai al portale di Azure. Se la risorsa creata nella sezione Prerequisiti è stata distribuita correttamente, selezionare Vai alla risorsa in Passaggi successivi. È possibile trovare la chiave e l'endpoint in Gestione risorse nella pagina Chiavi ed endpoint. La chiave della risorsa non corrisponde all'ID sottoscrizione di Azure.

Suggerimento

Non includere la chiave direttamente nel codice e non renderla mai pubblica. Vedere l'articolo sulla sicurezza dei Servizi di Azure AI per altre opzioni di autenticazione, ad esempio Azure Key Vault.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

  1. Per impostare la VISION_KEYvariabile di ambiente, sostituire your-key con una delle chiavi della risorsa.
  2. Per impostare la VISION_ENDPOINTvariabile di ambiente, sostituire your-endpoint con l'endpoint della risorsa.
setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare gli eventuali programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Identificare e verificare i visi

  1. Creare una nuova applicazione C#

    Creare un'applicazione .NET Core con Visual Studio.

    Installare la libreria client

    Dopo aver creato un nuovo progetto, installare la libreria client facendo clic con il pulsante destro del mouse sulla soluzione del progetto in Esplora soluzioni e scegliendo Gestisci pacchetti NuGet. Nella finestra di dialogo Gestione pacchetti visualizzata selezionare Sfoglia, Includi versione preliminare e cercare Microsoft.Azure.CognitiveServices.Vision.Face. Selezionare la versione più recente e fare clic su Installa.

  2. Aggiungere il codice seguente nel file Program.cs.

    Nota

    Se non è stato ricevuto l'accesso al servizio Viso usando il modulo di assunzione, alcune di queste funzioni non funzioneranno.

    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. Eseguire l'applicazione

    Eseguire l'applicazione facendo clic sul pulsante Debug nella parte superiore della finestra dell'ambiente di sviluppo integrato.

Output

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

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

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

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

End of quickstart.

Suggerimento

L'API Viso esegue una serie di modelli predefiniti che sono per natura statici (le prestazioni del modello non regrediscono né migliorano durante l'esecuzione del servizio). I risultati generati dal modello potrebbero cambiare se Microsoft ne aggiorna il back-end senza eseguire la migrazione a una versione interamente nuova. Per trarre vantaggio da una versione più recente di un modello, è possibile ripetere il training di PersonGroup specificando il nuovo modello come parametro con le stesse immagini di registrazione.

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione a Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Per eliminare il PersonGroup creato in queste istruzioni di avvio rapido, eseguire il codice seguente nel programma:

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

Definire il metodo di eliminazione con il codice seguente:

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

Passaggi successivi

In queste istruzioni di avvio rapido si è appreso come usare la libreria client di Viso per .NET per eseguire l'identificazione facciale di base. Informazioni sui diversi modelli di rilevamento dei volti e su come specificare il modello appropriato per il caso d'uso.

Specificare la versione di un modello di rilevamento dei volti

Introduzione al riconoscimento facciale con la libreria client di Viso per JavaScript. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per le attività di base. Il servizio Viso fornisce l'accesso ad algoritmi avanzati per il rilevamento e il riconoscimento dei visi umani nelle immagini. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per eseguire l'autenticazione dei volti di base per mezzo di immagini remote.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (npm) | Esempi

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • La versione più recente di Node.js
  • L'account Azure deve avere un Cognitive Services Contributor ruolo assegnato per consentire all'utente di accettare le condizioni di intelligenza artificiale responsabili e creare una risorsa. Per assegnare questo ruolo all'account, seguire la procedura descritta nella documentazione Assegnare ruoli oppure contattare l'amministratore.
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Viso nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Viso.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Vai al portale di Azure. Se la risorsa creata nella sezione Prerequisiti è stata distribuita correttamente, selezionare Vai alla risorsa in Passaggi successivi. È possibile trovare la chiave e l'endpoint in Gestione risorse nella pagina Chiavi ed endpoint. La chiave della risorsa non corrisponde all'ID sottoscrizione di Azure.

Suggerimento

Non includere la chiave direttamente nel codice e non renderla mai pubblica. Vedere l'articolo sulla sicurezza dei Servizi di Azure AI per altre opzioni di autenticazione, ad esempio Azure Key Vault.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

  1. Per impostare la VISION_KEYvariabile di ambiente, sostituire your-key con una delle chiavi della risorsa.
  2. Per impostare la VISION_ENDPOINTvariabile di ambiente, sostituire your-endpoint con l'endpoint della risorsa.
setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare gli eventuali programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Identificare e verificare i visi

  1. Creare una nuova applicazione Node.js

    In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

    mkdir myapp && cd myapp

    Eseguire il comando npm init per creare un'applicazione Node con un file package.json.

    npm init

  2. Installare i pacchetti npm ms-rest-azure e azure-cognitiveservices-face:

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

    Il file package.json dell'app viene aggiornato con le dipendenze.

  3. Creare un file denominato index.js, aprirlo in un editor di testo e incollarlo nel codice seguente:

    Nota

    Se non è stato ricevuto l'accesso al servizio Viso usando il modulo di assunzione, alcune di queste funzioni non funzioneranno.

    '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. Eseguire l'applicazione con il comando node nel file quickstart.

    node index.js

Output

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

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

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

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

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione a Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

In queste istruzioni di avvio rapido si è appreso come usare la libreria client di Viso per JavaScript per eseguire l'identificazione facciale di base. Informazioni sui diversi modelli di rilevamento dei volti e su come specificare il modello appropriato per il caso d'uso.

Specificare la versione di un modello di rilevamento dei volti

Introduzione al riconoscimento facciale con la libreria client di Viso per Python. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per le attività di base. Il servizio Viso fornisce l'accesso ad algoritmi avanzati per il rilevamento e il riconoscimento dei visi umani nelle immagini. Seguire questi passaggi per installare il pacchetto e provare il codice di esempio per eseguire l'autenticazione dei volti di base per mezzo di immagini remote.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (PiPy) | Esempi

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • Python 3.8+
    • L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo pip --version nella riga di comando. Ottenere pip installando la versione più recente di Python.
  • L'account Azure deve avere un Cognitive Services Contributor ruolo assegnato per consentire all'utente di accettare le condizioni di intelligenza artificiale responsabili e creare una risorsa. Per assegnare questo ruolo all'account, seguire la procedura descritta nella documentazione Assegnare ruoli oppure contattare l'amministratore.
  • Dopo aver creato la sottoscrizione di Azure, Creare una risorsa Viso nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Viso.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Creare variabili di ambiente

In questo esempio scrivere le credenziali nelle variabili di ambiente nel computer locale che esegue l'applicazione.

Vai al portale di Azure. Se la risorsa creata nella sezione Prerequisiti è stata distribuita correttamente, selezionare Vai alla risorsa in Passaggi successivi. È possibile trovare la chiave e l'endpoint in Gestione risorse nella pagina Chiavi ed endpoint. La chiave della risorsa non corrisponde all'ID sottoscrizione di Azure.

Suggerimento

Non includere la chiave direttamente nel codice e non renderla mai pubblica. Vedere l'articolo sulla sicurezza dei Servizi di Azure AI per altre opzioni di autenticazione, ad esempio Azure Key Vault.

Per impostare la variabile di ambiente per la chiave e l'endpoint, aprire una finestra della console e seguire le istruzioni del sistema operativo e dell'ambiente di sviluppo.

  1. Per impostare la VISION_KEYvariabile di ambiente, sostituire your-key con una delle chiavi della risorsa.
  2. Per impostare la VISION_ENDPOINTvariabile di ambiente, sostituire your-endpoint con l'endpoint della risorsa.
setx VISION_KEY your-key

setx VISION_ENDPOINT your-endpoint

Dopo aver aggiunto le variabili di ambiente, potrebbe essere necessario riavviare gli eventuali programmi in esecuzione che leggeranno le variabili di ambiente, inclusa la finestra della console.

Identificare e verificare i visi

  1. Installare la libreria client

    Dopo l'installazione di Python, è possibile installare la libreria client con:

    python -m pip install azure-ai-vision-face

  2. Creare una nuova applicazione Python

    Creare un nuovo script Python, ad esempio quickstart-file.py. Successivamente, aprirlo nell'editor o nell'IDE preferito e incollarlo nel codice seguente.

    Nota

    Se non è stato ricevuto l'accesso al servizio Viso usando il modulo di assunzione, alcune di queste funzioni non funzioneranno.

    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. Eseguire l'app di riconoscimento volto dalla directory dell'applicazione con il comando python.

    python quickstart-file.py

    Suggerimento

    L'API Viso esegue una serie di modelli predefiniti che sono per natura statici (le prestazioni del modello non regrediscono né migliorano durante l'esecuzione del servizio). I risultati generati dal modello potrebbero cambiare se Microsoft ne aggiorna il back-end senza eseguire la migrazione a una versione interamente nuova. Per trarre vantaggio da una versione più recente di un modello, è possibile ripetere il training di PersonGroup specificando il nuovo modello come parametro con le stesse immagini di registrazione.

Output

Person group: dbd92bf0-8b74-43fc-a27a-b127c1bb1b66
face 1d09b50e-0fb6-430c-a47c-9bb235761c17 added to person ea92a5d5-5250-44db-88fb-3b32e1a1ecaf
face 74e1807a-6c86-4c74-b497-a3bcdda8c631 added to person ea92a5d5-5250-44db-88fb-3b32e1a1ecaf
face 512cc8ff-e18a-4702-9413-3c83af9a0915 added to person f03219b3-c2dc-4ad6-b00b-bd71792686ac
face 899bbe8e-2d03-4941-8221-d087911df21b added to person f03219b3-c2dc-4ad6-b00b-bd71792686ac
face dfc0d142-36b0-4d90-982b-b51570ead5a8 added to person 8697d263-be7b-4d78-ba40-b55305dbbeb6
face 29939a66-9da2-46f2-b572-abbe4e0d754a added to person 8697d263-be7b-4d78-ba40-b55305dbbeb6
Train the person group dbd92bf0-8b74-43fc-a27a-b127c1bb1b66
The person group dbd92bf0-8b74-43fc-a27a-b127c1bb1b66 is trained successfully.
Pausing for 10 seconds to avoid triggering rate limit on free account...
Identifying faces in image
Person is identified for face ID 5779a986-238c-499d-b22a-d2a7cec92e88 in image, with a confidence of 0.96725.
verification result: True. confidence: 0.96725
Person is identified for face ID a28a4997-600e-4595-be39-d7a7d0f8afc8 in image, with a confidence of 0.96921.
verification result: True. confidence: 0.96921
No person identified for face ID 02a56d35-f3a4-43eb-a295-f23a1b772de9 in image.
Person is identified for face ID 5de2019a-c4d3-4021-b8d0-9a3b86adceb7 in image, with a confidence of 0.92886.
verification result: True. confidence: 0.92886

The person group dbd92bf0-8b74-43fc-a27a-b127c1bb1b66 is deleted.

End of quickstart.

Pulire le risorse

Se si vuole pulire e rimuovere una sottoscrizione a Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

In queste istruzioni di avvio rapido si è appreso come usare la libreria client di Viso per Python per eseguire l'identificazione facciale di base. Informazioni sui diversi modelli di rilevamento dei volti e su come specificare il modello appropriato per il caso d'uso.

Specificare la versione di un modello di rilevamento dei volti

Introduzione al riconoscimento facciale con l'API REST Viso. Il servizio Viso fornisce l'accesso ad algoritmi avanzati per il rilevamento e il riconoscimento dei visi umani nelle immagini.

Nota

Questa guida di avvio rapido usa comandi cURL per chiamare l'API REST. È anche possibile chiamare l'API REST usando un linguaggio di programmazione. Scenari complessi come l'identificazione del viso sono più facili da implementare usando un SDK del linguaggio. In GitHub sono disponibili esempi in C#, Python, Java, JavaScript e Go.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • L'account Azure deve avere un Cognitive Services Contributor ruolo assegnato per consentire all'utente di accettare le condizioni di intelligenza artificiale responsabili e creare una risorsa. Per assegnare questo ruolo all'account, seguire la procedura descritta nella documentazione Assegnare ruoli oppure contattare l'amministratore.
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa Viso nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Viso. La chiave e l'endpoint verranno incollati nel codice riportato di seguito nell'argomento di avvio rapido.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
  • PowerShell versione 6.0+ o un'applicazione della riga di comando simile.

Identificare e verificare i visi

Nota

Se non è stato ricevuto l'accesso al servizio Viso usando il modulo di assunzione, alcune di queste funzioni non funzioneranno.

  1. Prima di tutto, chiamare l'API Rilevamento sul viso di origine. Questo è il viso che tenteremo di identificare dal gruppo più grande. Copiare il comando seguente in un editor di testo, inserire la propria chiave, copiarla in una finestra della shell ed eseguirla.

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

    Salvare la stringa di ID viso restituita in un percorso temporaneo. Verrà usato di nuovo alla fine.

  2. Sarà quindi necessario creare un LargePersonGroup. Questo oggetto archivierà i dati aggregati sui visi di varie persone. Eseguire il comando seguente, inserendo la propria chiave. Facoltativamente, modificare il nome e i metadati del gruppo nel corpo della richiesta.

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

    Salvare l'ID restituito del gruppo creato in un percorso temporaneo.

  3. Successivamente, si creeranno oggetti Persona che appartengono al gruppo. Eseguire il comando seguente, inserendo la propria chiave e l'ID di LargePersonGroup del passaggio precedente. Questo comando crea una Persona denominata "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.\"
}"

    Dopo aver eseguito questo comando, eseguirlo di nuovo con dati di input differenti per creare altri oggetti Persona: "Family1-Mom", "Family1-Son", "Family1-Daughter", "Family2-Lady" e "Family2-Man".

    Salvare gli ID di ogni Persona creata. È importante tenere traccia dell'ID di ogni persona.

  4. Sarà quindi necessario rilevare nuovi visi e associarli agli oggetti Persona esistenti. Il comando seguente rileva un viso dall'immagine Family1-Dad1.jpg e lo aggiunge alla persona corrispondente. È necessario specificare personId come ID restituito quando è stato creato l'oggetto Persona "Family1-Dad". Il nome dell'immagine corrisponde al nome della Persona creata. Immettere anche l'ID LargePersonGroup e la chiave nei campi appropriati.

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

    Eseguire quindi di nuovo il comando precedente con un'immagine di origine e una Persona di destinazione differenti. Le immagini disponibili sono: 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 e Family2-Man2.jpg. Assicurarsi che la Persona il cui ID si ha specificato nella chiamata API corrisponda al nome del file di immagine nel corpo della richiesta.

    Al termine di questo passaggio, si dovrebbe disporre di vari oggetti Persona con uno o più visi corrispondenti, rilevati direttamente dalle immagini fornite.

  5. Eseguire quindi il training di LargePersonGroup con i dati sul viso correnti. L'operazione di training insegna al modello come associare le caratteristiche facciali, talvolta aggregate da diverse immagini di origine, a ogni singola persona. Inserire l'ID LargePersonGroup e la chiave prima di eseguire il comando.

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

  6. A questo punto è possibile chiamare l'API Identificazione, usando l'ID del viso di origine del primo passaggio e l'ID LargePersonGroup. Inserire questi valori nei campi appropriati nel corpo della richiesta, quindi inserire la chiave.

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

    La risposta deve fornire un'ID Persona che indica la persona identificata con il viso di origine. Deve essere l'ID che corrisponde alla persona "Family1-Dad", perché il viso di origine è di quella persona.

  7. Per eseguire la verifica del viso, si userà l'ID Persona restituito nel passaggio precedente, l'ID LargePersonGroup e anche l'ID viso di origine. Inserire questi valori nei campi nel corpo della richiesta e inserire la chiave.

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

    La risposta deve fornire un risultato di verifica booleano insieme a un valore di attendibilità.

Pulire le risorse

Per eliminare il LargePersonGroup creato in questo esercizio, eseguire la chiamata LargePersonGroup - Delete.

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

Se si vuole pulire e rimuovere una sottoscrizione a Servizi di Azure AI, è possibile eliminare la risorsa o il gruppo di risorse. L'eliminazione del gruppo di risorse comporta anche l'eliminazione di tutte le altre risorse associate.

Passaggi successivi

In questo argomento di avvio rapido si è appreso come usare l'API REST Viso per eseguire attività di riconoscimento facciale di base. Informazioni sui diversi modelli di rilevamento dei volti e su come specificare il modello appropriato per il caso d'uso.

Specificare la versione di un modello di rilevamento dei volti