Rychlý Start: použití klientské knihovny pro tvář

Začněte s rozpoznáváním obličeje pomocí klientské knihovny pro tvář pro .NET. Pomocí těchto kroků nainstalujete balíček a vyzkoušíte ukázkový kód pro základní úlohy. Služba Faceer poskytuje přístup k pokročilým algoritmům pro zjišťování a rozpoznávání lidských plošek na obrázcích.

Pomocí klientské knihovny obličeje pro .NET:

• Detekovat a analyzovat plošky
• Identifikace obličeje
• Hledání podobných plošek

Referenční dokumentace | Zdrojový kód knihovny | Balíček (NuGet) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma .
• Visual Studio integrované vývojové prostředí (IDE ) nebo aktuální verze .net Core.
• Váš účet Azure musí mít přiřazenou Cognitive Services přispěvatele, abyste mohli odsouhlasit podmínky AI a vytvořit prostředek. Požádejte správce, aby tuto roli přiřadil vašemu účtu.
• Jakmile budete mít předplatné Azure, pro vytváření obličeje a vytvořte na Azure Portal prostředek, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k rozhraní API pro rozpoznávání tváře budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace v C#

dotnet new console -n face-quickstart

dotnet build

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

dotnet add package Microsoft.Azure.CognitiveServices.Vision.Face --version 2.7.0-preview.1

Z adresáře projektu otevřete soubor program. cs a přidejte následující using direktivy:

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;

Do třídy programu aplikace vytvořte proměnné pro klíč a koncový bod prostředku.

// From your Face subscription in the Azure portal, get your subscription key and endpoint.
const string SUBSCRIPTION_KEY = "PASTE_YOUR_FACE_SUBSCRIPTION_KEY_HERE";
const string ENDPOINT = "PASTE_YOUR_FACE_ENDPOINT_HERE";

V metodě Main aplikace přidejte volání metod používaných v rámci tohoto rychlého startu. Budete je implementovat později.

// Authenticate.
IFaceClient client = Authenticate(ENDPOINT, SUBSCRIPTION_KEY);

// Detect - get features from faces.
DetectFaceExtract(client, IMAGE_BASE_URL, RECOGNITION_MODEL4).Wait();
// Find Similar - find a similar face from a list of faces.
FindSimilar(client, IMAGE_BASE_URL, RECOGNITION_MODEL4).Wait();
// Verify - compare two images if the same person or not.
Verify(client, IMAGE_BASE_URL, RECOGNITION_MODEL4).Wait();

// 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();
// LargePersonGroup - create, then get data.
LargePersonGroup(client, IMAGE_BASE_URL, RECOGNITION_MODEL4).Wait();
// Group faces - automatically group similar faces.
Group(client, IMAGE_BASE_URL, RECOGNITION_MODEL4).Wait();
// FaceList - create a face list, then get data

Objektový model

Následující třídy a rozhraní zpracovávají některé hlavní funkce klientské knihovny rozhraní .NET pro obličej:

Příklady kódu

Níže uvedené fragmenty kódu ukazují, jak provádět následující úlohy pomocí klientské knihovny pro tvář pro .NET:

• Ověření klienta
• Detekovat a analyzovat plošky
• Identifikace obličeje
• Hledání podobných plošek

Ověření klienta

V nové metodě vytvořte instanci klienta s vaším koncovým bodem a klíčem. Vytvořte objekt ApiKeyServiceClientCredentials s klíčem a použijte ho u svého koncového bodu k vytvoření objektu FaceClient .

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

Deklarace pomocných polí

Následující pole jsou nutná pro několik operací tváře, které přidáte později. V kořenovém adresáři třídy programu definujte následující řetězec adresy URL. Tato adresa URL odkazuje na složku ukázkových imagí.

// Used for all examples.
// URL for the images.
const string IMAGE_BASE_URL = "https://csdx.blob.core.windows.net/resources/Face/Images/";

V metodě Main definujte řetězce, které odkazují na různé typy modelů rozpoznávání. Později budete moct určit, který model rozpoznávání se má použít pro rozpoznávání tváře. Informace o těchto možnostech najdete v tématu Určení modelu rozpoznávání .

// 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;

Detekovat a analyzovat plošky

Rozpoznávání tváře se vyžaduje jako první krok ve všech ostatních scénářích. V této části se dozvíte, jak vrátit data atributu extra Face. Pokud chcete detekovat jenom obličeje pro identifikaci nebo ověřování obličeje, přeskočte na další části.

Získat zjištěné objekty Face

Vytvořte novou metodu pro detekci plošek. DetectFaceExtractMetoda zpracuje tři obrázky na dané adrese URL a vytvoří seznam objektů DetectedFace v paměti pro programy. Seznam hodnot FaceAttributeType určuje, které funkce se mají extrahovat.

/* 
 * DETECT FACES
 * Detects features from faces and IDs them.
 */
public static async Task DetectFaceExtract(IFaceClient client, string url, string recognitionModel)
{
    Console.WriteLine("========DETECT FACES========");
    Console.WriteLine();

    // Create a list of images
    List<string> imageFileNames = new List<string>
                    {
                        "detection1.jpg",    // single female with glasses
                        // "detection2.jpg", // (optional: single man)
                        // "detection3.jpg", // (optional: single male construction worker)
                        // "detection4.jpg", // (optional: 3 people at cafe, 1 is blurred)
                        "detection5.jpg",    // family, woman child man
                        "detection6.jpg"     // elderly couple, male female
                    };

    foreach (var imageFileName in imageFileNames)
    {
        IList<DetectedFace> detectedFaces;

        // Detect faces with all attributes from image url.
        detectedFaces = await client.Face.DetectWithUrlAsync($"{url}{imageFileName}",
                returnFaceAttributes: new List<FaceAttributeType> { FaceAttributeType.Accessories, FaceAttributeType.Age,
                FaceAttributeType.Blur, FaceAttributeType.Emotion, FaceAttributeType.Exposure, FaceAttributeType.FacialHair,
                FaceAttributeType.Gender, FaceAttributeType.Glasses, FaceAttributeType.Hair, FaceAttributeType.HeadPose,
                FaceAttributeType.Makeup, FaceAttributeType.Noise, FaceAttributeType.Occlusion, FaceAttributeType.Smile },
                // We specify detection model 1 because we are retrieving attributes.
                detectionModel: DetectionModel.Detection01,
                recognitionModel: recognitionModel);

        Console.WriteLine($"{detectedFaces.Count} face(s) detected from image `{imageFileName}`.");

Zobrazit zjištěná data obličeje

Zbytek DetectFaceExtract metody analyzuje a tiskne data atributu pro každou zjištěnou plochu. Každý atribut se musí zadat samostatně v původním volání rozhraní API pro detekci obličeje (v seznamu FaceAttributeType ). Následující kód zpracuje každý atribut, ale bude pravděpodobně nutné použít pouze jeden nebo několik.

        // Parse and print all attributes of each detected face.
        foreach (var face in detectedFaces)
        {
            Console.WriteLine($"Face attributes for {imageFileName}:");

            // Get bounding box of the faces
            Console.WriteLine($"Rectangle(Left/Top/Width/Height) : {face.FaceRectangle.Left} {face.FaceRectangle.Top} {face.FaceRectangle.Width} {face.FaceRectangle.Height}");

            // Get accessories of the faces
            List<Accessory> accessoriesList = (List<Accessory>)face.FaceAttributes.Accessories;
            int count = face.FaceAttributes.Accessories.Count;
            string accessory; string[] accessoryArray = new string[count];
            if (count == 0) { accessory = "NoAccessories"; }
            else
            {
                for (int i = 0; i < count; ++i) { accessoryArray[i] = accessoriesList[i].Type.ToString(); }
                accessory = string.Join(",", accessoryArray);
            }
            Console.WriteLine($"Accessories : {accessory}");

            // Get face other attributes
            Console.WriteLine($"Age : {face.FaceAttributes.Age}");
            Console.WriteLine($"Blur : {face.FaceAttributes.Blur.BlurLevel}");

            // Get emotion on the face
            string emotionType = string.Empty;
            double emotionValue = 0.0;
            Emotion emotion = face.FaceAttributes.Emotion;
            if (emotion.Anger > emotionValue) { emotionValue = emotion.Anger; emotionType = "Anger"; }
            if (emotion.Contempt > emotionValue) { emotionValue = emotion.Contempt; emotionType = "Contempt"; }
            if (emotion.Disgust > emotionValue) { emotionValue = emotion.Disgust; emotionType = "Disgust"; }
            if (emotion.Fear > emotionValue) { emotionValue = emotion.Fear; emotionType = "Fear"; }
            if (emotion.Happiness > emotionValue) { emotionValue = emotion.Happiness; emotionType = "Happiness"; }
            if (emotion.Neutral > emotionValue) { emotionValue = emotion.Neutral; emotionType = "Neutral"; }
            if (emotion.Sadness > emotionValue) { emotionValue = emotion.Sadness; emotionType = "Sadness"; }
            if (emotion.Surprise > emotionValue) { emotionType = "Surprise"; }
            Console.WriteLine($"Emotion : {emotionType}");

            // Get more face attributes
            Console.WriteLine($"Exposure : {face.FaceAttributes.Exposure.ExposureLevel}");
            Console.WriteLine($"FacialHair : {string.Format("{0}", face.FaceAttributes.FacialHair.Moustache + face.FaceAttributes.FacialHair.Beard + face.FaceAttributes.FacialHair.Sideburns > 0 ? "Yes" : "No")}");
            Console.WriteLine($"Gender : {face.FaceAttributes.Gender}");
            Console.WriteLine($"Glasses : {face.FaceAttributes.Glasses}");

            // Get hair color
            Hair hair = face.FaceAttributes.Hair;
            string color = null;
            if (hair.HairColor.Count == 0) { if (hair.Invisible) { color = "Invisible"; } else { color = "Bald"; } }
            HairColorType returnColor = HairColorType.Unknown;
            double maxConfidence = 0.0f;
            foreach (HairColor hairColor in hair.HairColor)
            {
                if (hairColor.Confidence <= maxConfidence) { continue; }
                maxConfidence = hairColor.Confidence; returnColor = hairColor.Color; color = returnColor.ToString();
            }
            Console.WriteLine($"Hair : {color}");

            // Get more attributes
            Console.WriteLine($"HeadPose : {string.Format("Pitch: {0}, Roll: {1}, Yaw: {2}", Math.Round(face.FaceAttributes.HeadPose.Pitch, 2), Math.Round(face.FaceAttributes.HeadPose.Roll, 2), Math.Round(face.FaceAttributes.HeadPose.Yaw, 2))}");
            Console.WriteLine($"Makeup : {string.Format("{0}", (face.FaceAttributes.Makeup.EyeMakeup || face.FaceAttributes.Makeup.LipMakeup) ? "Yes" : "No")}");
            Console.WriteLine($"Noise : {face.FaceAttributes.Noise.NoiseLevel}");
            Console.WriteLine($"Occlusion : {string.Format("EyeOccluded: {0}", face.FaceAttributes.Occlusion.EyeOccluded ? "Yes" : "No")} " +
                $" {string.Format("ForeheadOccluded: {0}", face.FaceAttributes.Occlusion.ForeheadOccluded ? "Yes" : "No")}   {string.Format("MouthOccluded: {0}", face.FaceAttributes.Occlusion.MouthOccluded ? "Yes" : "No")}");
            Console.WriteLine($"Smile : {face.FaceAttributes.Smile}");
            Console.WriteLine();
        }
    }
}

Identifikace obličeje

Operace identifikace přebírá obrázek osoby (nebo více lidí) a hledá uložený objekt person přidružený k jednotlivým ploškám v obrázku (vyhledávání rozpoznávání obličeje). Porovnává každou zjištěnou plochu s osobou, databázi různých objektů osob , jejichž data obličeje jsou známá. Aby bylo možné operaci identifikace provést, musíte nejprve vytvořit a naučit pracovní samostatnou osobu .

Vytvoření osoby

Následující kód vytvoří osobu , která má šest různých objektů Person . Přidružuje každou osobu k sadě ukázkových imagí a pak vlaky zaznamená, aby každou osobu rozpoznali vlastnostmi obličeje. Objekty Person a Person se používají při operacích ověřit, identifikovat a seskupit.

Deklarujte řetězcovou proměnnou v kořenu vaší třídy, která bude představovat ID osoby , kterou vytvoříte.

static string personGroupId = Guid.NewGuid().ToString();

V nové metodě přidejte následující kód. Tato metoda provede operaci identifikace. První blok kódu přidruží názvy osob k jejich ukázkovým obrázkům.

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

Všimněte si, že tento kód definuje proměnnou sourceImageFileName . Tato proměnná odpovídá zdrojové imagi — obrázku, který obsahuje lidi k identifikaci.

Dále přidejte následující kód pro vytvoření objektu Person pro každého uživatele ve slovníku a přidejte Obličejová data z příslušných imagí. Každý objekt Person je přidružen ke stejnému objektu Person prostřednictvím jeho jedinečného řetězce ID. Nezapomeňte předat proměnné client , url a RECOGNITION_MODEL1 do této metody.

// 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($"Add face to the person group person({groupedFace}) from image `{similarImage}`");
        PersistedFace face = await client.PersonGroupPerson.AddFaceFromUrlAsync(personGroupId, person.PersonId,
            $"{url}{similarImage}", similarImage);
    }
}

Naučit se ve službě person

Po extrakci dat ze svých imagí a jejich jejich řazení do různých objektů osob je potřeba, abyste ve své osobě nastavili identifikaci vizuálních funkcí přidružených k jednotlivým objektům osob . Následující kód volá metodu asynchronního vlaku a provede dotaz na výsledky a vytiskne stav do konzoly.

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

Tato skupina uživatelů a její přidružené objekty osoby jsou teď připravené k použití v operacích ověřování, identifikace nebo seskupení.

Identifikace tváří

Následující kód převezme zdrojový obraz a vytvoří seznam všech ploch zjištěných v obrázku. Jedná se o plošky, které se identifikují vůči osobě person.

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

Další fragment kódu volá operaci IdentifyAsync a vytiskne výsledky do konzoly. V tomto případě se služba pokusí porovnat jednotlivé obličeje od zdrojové image k osobě v dané osobě person. Tím se ukončí vaše metoda identifikace.

    // Identify the faces in a person group. 
    var identifyResults = await client.Face.IdentifyAsync(sourceFaceIds, personGroupId);

    foreach (var identifyResult in identifyResults)
    {
        Person person = await client.PersonGroupPerson.GetAsync(personGroupId, identifyResult.Candidates[0].PersonId);
        Console.WriteLine($"Person '{person.Name}' is identified for face in: {sourceImageFileName} - {identifyResult.FaceId}," +
            $" confidence: {identifyResult.Candidates[0].Confidence}.");
    }
    Console.WriteLine();
}

Vyhledání podobných tváří

Následující kód přebírá jednu zjištěnou plošku (zdroj) a hledá v sadě dalších tváře (cíle) k nalezení shody (hledání na základě obrázku). Pokud najde shodu, vytiskne ID spárovaného obličeje konzole.

Detekovat plošky pro porovnání

Nejdřív Definujte metodu detekce druhé plochy. Je potřeba detekovat plošky na obrázcích předtím, než je můžete porovnat, a tato metoda detekce je optimalizována pro operace porovnání. Neextrahuje podrobné atributy obličeje jako v části výše a používá jiný model rozpoznávání.

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);
    Console.WriteLine($"{detectedFaces.Count} face(s) detected from image `{Path.GetFileName(url)}`");
    return detectedFaces.ToList();
}

Najít shody

Následující metoda detekuje plošky v sadě cílových imagí a v jediné zdrojové imagi. Pak je porovná a vyhledá všechny cílové image, které jsou podobné zdrojové imagi.

/*
 * FIND SIMILAR
 * This example will take an image and find a similar one to it in another image.
 */
public static async Task FindSimilar(IFaceClient client, string url, string recognition_model)
{
    Console.WriteLine("========FIND SIMILAR========");
    Console.WriteLine();

    List<string> targetImageFileNames = new List<string>
                        {
                            "Family1-Dad1.jpg",
                            "Family1-Daughter1.jpg",
                            "Family1-Mom1.jpg",
                            "Family1-Son1.jpg",
                            "Family2-Lady1.jpg",
                            "Family2-Man1.jpg",
                            "Family3-Lady1.jpg",
                            "Family3-Man1.jpg"
                        };

    string sourceImageFileName = "findsimilar.jpg";
    IList<Guid?> targetFaceIds = new List<Guid?>();
    foreach (var targetImageFileName in targetImageFileNames)
    {
        // Detect faces from target image url.
        var faces = await DetectFaceRecognize(client, $"{url}{targetImageFileName}", recognition_model);
        // Add detected faceId to list of GUIDs.
        targetFaceIds.Add(faces[0].FaceId.Value);
    }

    // Detect faces from source image url.
    IList<DetectedFace> detectedFaces = await DetectFaceRecognize(client, $"{url}{sourceImageFileName}", recognition_model);
    Console.WriteLine();

    // Find a similar face(s) in the list of IDs. Comapring only the first in list for testing purposes.
    IList<SimilarFace> similarResults = await client.Face.FindSimilarAsync(detectedFaces[0].FaceId.Value, null, null, targetFaceIds);

Tisk shody

Následující kód vytiskne podrobnosti o shodě do konzoly:

foreach (var similarResult in similarResults)
{
    Console.WriteLine($"Faces from {sourceImageFileName} & ID:{similarResult.FaceId} are similar with confidence: {similarResult.Confidence}.");
}
Console.WriteLine();

Spuštění aplikace

dotnet run

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Pokud jste v tomto rychlém startu vytvořili pole Person a chcete ho odstranit, spusťte v programu následující kód:

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

Metodu odstranění definujte pomocí následujícího kódu:

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

Další kroky

V tomto rychlém startu jste se dozvěděli, jak používat funkci klientské knihovny pro tvář pro .NET k provádění základních úloh rozpoznávání obličeje. V dalším kroku se dozvíte o různých modelech detekce obličeje a o tom, jak zadat správný model pro váš případ použití.

• Co je služba Rozpoznávání tváře?
• Zdrojový kód pro tuto ukázku najdete na GitHub.

Začněte s rozpoznáváním obličeje pomocí klientské knihovny pro tvář pro funkci přejít. Pomocí těchto kroků nainstalujete balíček a vyzkoušíte ukázkový kód pro základní úlohy. Služba Faceer poskytuje přístup k pokročilým algoritmům pro zjišťování a rozpoznávání lidských plošek na obrázcích.

Použijte klientskou knihovnu služby FACET k přechodu na:

• Detekovat a analyzovat plošky
• Identifikace obličeje
• Ověřit plošky
• Hledání podobných plošek

Referenční dokumentace | Zdrojový kód knihovny | Stažení sady SDK

Požadavky

• Nejnovější verze nástroje Přejít
• Předplatné Azure – Vytvořte si ho zdarma .
• Váš účet Azure musí mít přiřazenou Cognitive Services přispěvatele, abyste mohli odsouhlasit podmínky AI a vytvořit prostředek. Požádejte správce, aby tuto roli přiřadil vašemu účtu.
• Jakmile budete mít předplatné Azure, pro vytváření obličeje a vytvořte na Azure Portal prostředek, abyste získali svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k rozhraní API pro rozpoznávání tváře budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do níže uvedeného kódu později v rychlém startu.
  • K vyzkoušení služby můžete použít bezplatnou cenovou úroveň ( F0 ) a upgradovat ji později na placenou úroveň pro produkční prostředí.
• Po získání klíče a koncového bodu vytvořte proměnné prostředí pro klíč a koncový bod s názvem FACE_SUBSCRIPTION_KEY a v FACE_ENDPOINT uvedeném pořadí.

Nastavení

Vytvořit adresář projektu přejít

V okně konzoly (cmd, PowerShell, terminál, bash) vytvořte nový pracovní prostor pro projekt na cestách s názvem my-app a přejděte na něj.

mkdir -p my-app/{src, bin, pkg}  
cd my-app

Váš pracovní prostor bude obsahovat tři složky:

• Src – tento adresář bude obsahovat zdrojový kód a balíčky. Všechny balíčky nainstalované s go get příkazem budou v této složce.
• pkg – tento adresář bude obsahovat kompilované objekty balíčku pro přechod. Všechny tyto soubory mají .a rozšíření.
• bin – tento adresář bude obsahovat binární spustitelné soubory, které se vytvoří při spuštění go install .

Instalace klientské knihovny pro přejít

Dále nainstalujte klientskou knihovnu pro přejít:

go get -u github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v1.0/face

nebo pokud používáte DEP, v rámci vašeho úložiště úložišť:

dep ensure -add https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v1.0/face

Vytvoření aplikace v cestách

Dále vytvořte soubor v adresáři Src s názvem sample-app.go :

cd src
touch sample-app.go

Otevřete sample-app.go v upřednostňovaném integrovaném vývojovém prostředí (IDE) nebo textovém editoru. Pak přidejte název balíčku a importujte následující knihovny:

package main

import (
    "encoding/json"
    "container/list"
    "context"
    "fmt"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v1.0/face"
    "github.com/Azure/go-autorest/autorest"
    "github.com/satori/go.uuid"
    "io"
    "io/ioutil"
    "log"
    "os"
    "path"
    "strconv"
    "strings"
    "time"
)

V dalším kroku začnete přidávat kód pro provádění různých operací služby obličeje.

Objektový model

Následující třídy a rozhraní zpracovávají některé z hlavních funkcí služby Face Service přejít do klientské knihovny.

Příklady kódu

Tyto ukázky kódu ukazují, jak dokončit základní úlohy pomocí klientské knihovny služby FACET pro službu přejít:

• Ověření klienta
• Detekovat a analyzovat plošky
• Identifikace obličeje
• Ověřit plošky
• Hledání podobných plošek

Ověření klienta

Vytvořte funkci Main a přidejte do ní následující kód, který vytvoří instanci klienta s vaším koncovým bodem a klíčem. Vytvoříte objekt CognitiveServicesAuthorizer s klíčem a použijete ho u svého koncového bodu k vytvoření objektu klienta . Tento kód také vytvoří instanci objektu kontextu, který je potřeba pro vytváření objektů klienta. Definuje také vzdálené umístění, kde se nachází některé z ukázkových imagí v tomto rychlém startu.

func main() {

    // A global context for use in all samples
    faceContext := context.Background()

    // Base url for the Verify and Large Face List examples
    const imageBaseURL = "https://csdx.blob.core.windows.net/resources/Face/Images/"

    /*
    Authenticate
    */
    subscriptionKey := "PASTE_YOUR_FACE_SUBSCRIPTION_KEY_HERE"
    endpoint := "PASTE_YOUR_FACE_ENDPOINT_HERE"

    // Client used for Detect Faces, Find Similar, and Verify examples.
    client := face.NewClient(endpoint)
    client.Authorizer = autorest.NewCognitiveServicesAuthorizer(subscriptionKey)
    /*
    END - Authenticate
    */

Detekovat a analyzovat plošky

Jako první krok při analýze a ověřování identity obličeje se vyžaduje detekce obličeje. V této části se dozvíte, jak vrátit data atributu extra Face. Pokud chcete detekovat jenom obličeje pro identifikaci nebo ověřování obličeje, přeskočte na další části.

Do metody Main přidejte následující kód. Tento kód definuje vzdálený ukázkový obrázek a určuje, které funkce obličeje z obrázku jsou extrahovány. Určuje také, který model AI se má použít k extrakci dat ze zjištěných tváře. Informace o těchto možnostech najdete v tématu Určení modelu rozpoznávání . Nakonec metoda DetectWithURL provede v imagi operaci detekce obličeje a uloží výsledky do paměti programu.

// Detect a face in an image that contains a single face
singleFaceImageURL := "https://www.biography.com/.image/t_share/MTQ1MzAyNzYzOTgxNTE0NTEz/john-f-kennedy---mini-biography.jpg" 
singleImageURL := face.ImageURL { URL: &singleFaceImageURL } 
singleImageName := path.Base(singleFaceImageURL)
// Array types chosen for the attributes of Face
attributes := []face.AttributeType {"age", "emotion", "gender"}
returnFaceID := true
returnRecognitionModel := false
returnFaceLandmarks := false

// API call to detect faces in single-faced image, using recognition model 4
// We specify detection model 1 because we are retrieving attributes.
detectSingleFaces, dErr := client.DetectWithURL(faceContext, singleImageURL, &returnFaceID, &returnFaceLandmarks, attributes, face.Recognition04, &returnRecognitionModel, face.Detection01)
if dErr != nil { log.Fatal(dErr) }

// Dereference *[]DetectedFace, in order to loop through it.
dFaces := *detectSingleFaces.Value

Zobrazit zjištěná data obličeje

Další blok kódu vezme první prvek v poli objektů DetectedFace a vytiskne jeho atributy do konzoly. Pokud jste použili obrázek s více ploškami, měli byste místo toho iterovat v poli.

fmt.Println("Detected face in (" + singleImageName + ") with ID(s): ")
fmt.Println(dFaces[0].FaceID)
fmt.Println()
// Find/display the age and gender attributes
for _, dFace := range dFaces { 
    fmt.Println("Face attributes:")
    fmt.Printf("  Age: %.0f", *dFace.FaceAttributes.Age) 
    fmt.Println("\n  Gender: " + dFace.FaceAttributes.Gender) 
} 
// Get/display the emotion attribute
emotionStruct := *dFaces[0].FaceAttributes.Emotion
// Convert struct to a map
var emotionMap map[string]float64
result, _ := json.Marshal(emotionStruct)
json.Unmarshal(result, &emotionMap)
// Find the emotion with the highest score (confidence level). Range is 0.0 - 1.0.
var highest float64 
emotion := ""
dScore := -1.0
for name, value := range emotionMap{
    if (value > highest) {
        emotion, dScore = name, value
        highest = value
    }
}
fmt.Println("  Emotion: " + emotion + " (score: " + strconv.FormatFloat(dScore, 'f', 3, 64) + ")")

Identifikace obličeje

Operace identifikace přebírá obrázek osoby (nebo více lidí) a hledá identitu každé plošky v imagi (vyhledávání rozpoznávání obličeje). Porovnává každou zjištěnou plochu s osobou, databázi různých objektů osob , jejichž funkce obličeje jsou známy.

Získat image osob

Pro krokování v tomto scénáři je nutné uložit následující image do kořenového adresáře projektu: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

Tato skupina imagí obsahuje tři sady imagí s jedním obličejem, které odpovídají třem různým lidem. Kód bude definovat tři objekty osob Person a přidružit je k souborům obrázků, které začínají woman na, man a child .

Vytvoření osoby

Po stažení imagí přidejte do dolní části metody Main následující kód. Tento kód ověří objekt PersonGroupClient a pak ho použije k definování nové osoby.

// Get working directory
root, rootErr := os.Getwd()
if rootErr != nil { log.Fatal(rootErr) }

// Full path to images folder
imagePathRoot := path.Join(root+"\\images\\")

// Authenticate - Need a special person group client for your person group
personGroupClient := face.NewPersonGroupClient(endpoint)
personGroupClient.Authorizer = autorest.NewCognitiveServicesAuthorizer(subscriptionKey)

// Create the Person Group
// Create an empty Person Group. Person Group ID must be lower case, alphanumeric, and/or with '-', '_'.
personGroupID := "unique-person-group"
fmt.Println("Person group ID: " + personGroupID)
metadata := face.MetaDataContract { Name: &personGroupID }

// Create the person group
personGroupClient.Create(faceContext, personGroupID, metadata)

Vytvořit osoby osoby

Další blok kódu ověří PersonGroupPersonClient a použije ho k definování tří objektů Person osoby. Jednotlivé objekty reprezentují jednu osobu v sadě imagí.

// Authenticate - Need a special person group person client for your person group person
personGroupPersonClient := face.NewPersonGroupPersonClient(endpoint)
personGroupPersonClient.Authorizer = autorest.NewCognitiveServicesAuthorizer(subscriptionKey)

// Create each person group person for each group of images (woman, man, child)
// Define woman friend
w := "Woman"
nameWoman := face.NameAndUserDataContract { Name: &w }
// Returns a Person type
womanPerson, wErr := personGroupPersonClient.Create(faceContext, personGroupID, nameWoman)
if wErr != nil { log.Fatal(wErr) }
fmt.Print("Woman person ID: ")
fmt.Println(womanPerson.PersonID)
// Define man friend
m := "Man"
nameMan := face.NameAndUserDataContract { Name: &m }
// Returns a Person type
manPerson, wErr := personGroupPersonClient.Create(faceContext, personGroupID, nameMan)
if wErr != nil { log.Fatal(wErr) }
fmt.Print("Man person ID: ")
fmt.Println(manPerson.PersonID)
// Define child friend
ch := "Child"
nameChild := face.NameAndUserDataContract { Name: &ch }
// Returns a Person type
childPerson, wErr := personGroupPersonClient.Create(faceContext, personGroupID, nameChild)
if wErr != nil { log.Fatal(wErr) }
fmt.Print("Child person ID: ")
fmt.Println(childPerson.PersonID)

Přiřazení plošek k osobám

Následující kód seřadí obrázky podle jejich předpony, detekuje plošky a přiřadí tyto obličeje k jednotlivým objektům person osoby na základě názvu obrázkového souboru.

// Detect faces and register to correct person
// Lists to hold all their person images
womanImages := list.New()
manImages := list.New()
childImages := list.New()

// Collect the local images for each person, add them to their own person group person
images, fErr := ioutil.ReadDir(imagePathRoot)
if fErr != nil { log.Fatal(fErr)}
for _, f := range images {
    path:= (imagePathRoot+f.Name())
    if strings.HasPrefix(f.Name(), "w") {
        var wfile io.ReadCloser
        wfile, err:= os.Open(path)
        if err != nil { log.Fatal(err) }
        womanImages.PushBack(wfile)
        personGroupPersonClient.AddFaceFromStream(faceContext, personGroupID, *womanPerson.PersonID, wfile, "", nil, face.Detection03)
    }
    if strings.HasPrefix(f.Name(), "m") {
        var mfile io.ReadCloser
        mfile, err:= os.Open(path)
        if err != nil { log.Fatal(err) }
        manImages.PushBack(mfile)
        personGroupPersonClient.AddFaceFromStream(faceContext, personGroupID, *manPerson.PersonID, mfile, "", nil, face.Detection03)
    }
    if strings.HasPrefix(f.Name(), "ch") {
        var chfile io.ReadCloser
        chfile, err:= os.Open(path)
        if err != nil { log.Fatal(err) }
        childImages.PushBack(chfile)
        personGroupPersonClient.AddFaceFromStream(faceContext, personGroupID, *childPerson.PersonID, chfile, "", nil, face.Detection03)
    }
}

Naučit se ve službě person

Jakmile budete mít k plošky, provedete tuto osobu , aby bylo možné identifikovat vizuální funkce přidružené k jednotlivým objektům osob . Následující kód volá metodu asynchronního vlaku a provede dotaz na výsledek a vytiskne stav do konzoly.

// Train the person group
personGroupClient.Train(faceContext, personGroupID)

// Wait for it to succeed in training
for {
    trainingStatus, tErr := personGroupClient.GetTrainingStatus(faceContext, personGroupID)
    if tErr != nil { log.Fatal(tErr) }
    
    if trainingStatus.Status == "succeeded" {
        fmt.Println("Training status:", trainingStatus.Status)
        break
    }
    time.Sleep(2)
}

Získat image testu

Následující kód vypadá v kořenu projektu test-image-person-group.jpg obrázku a načítá ho do paměti programu. Tuto image najdete ve stejném úložišti jako image použité k vytvoření osoby: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

personGroupTestImageName := "test-image-person-group.jpg"
// Use image path root from the one created in person group
personGroupTestImagePath := imagePathRoot
var personGroupTestImage io.ReadCloser
// Returns a ReaderCloser
personGroupTestImage, identErr:= os.Open(personGroupTestImagePath+personGroupTestImageName)
if identErr != nil { log.Fatal(identErr) }

Detekovat zdrojové plošky v testovací imagi

Další blok kódu provede normální detekci na obrázku testu, aby se načetly všechny plošky a ušetřily se do pole.

// Detect faces in group test image, using recognition model 1 (default)
returnIdentifyFaceID := true
// Returns a ListDetectedFaces
// Recognition04 is not compatible.
// We specify detection model 3 because we are not retrieving attributes.
detectedTestImageFaces, dErr := client.DetectWithStream(faceContext, personGroupTestImage, &returnIdentifyFaceID, nil, nil, face.Recognition01, nil, face.Detection03)
if dErr != nil { log.Fatal(dErr) }

// Make list of face IDs from the detection. 
length := len(*detectedTestImageFaces.Value)
testImageFaceIDs := make([]uuid.UUID, length)
// ListDetectedFace is a struct with a Value property that returns a *[]DetectedFace
for i, f := range *detectedTestImageFaces.Value {
    testImageFaceIDs[i] = *f.FaceID
}

Identifikace obličeje ze zdrojové image

Metoda Identifikace vezme pole zjištěných plošek a porovná je s danými osobami (definované a vyškolenou v předchozí části). Pokud se může porovnávat zjištěná ploška osobě ve skupině, uloží výsledek.

// Identify the faces in the test image with everyone in the person group as a query
identifyRequestBody := face.IdentifyRequest { FaceIds: &testImageFaceIDs, PersonGroupID: &personGroupID }
identifiedFaces, err := client.Identify(faceContext, identifyRequestBody)
if err != nil { log.Fatal(err) }

Tento kód pak vytiskne podrobné výsledky shody s konzolou.

// Get the result which person(s) were identified
iFaces := *identifiedFaces.Value
for _, person := range iFaces {
    fmt.Println("Person for face ID: " )
    fmt.Print(person.FaceID)
    fmt.Println(" is identified in " + personGroupTestImageName + ".")
}

Ověřit plošky

Operace ověření bere v případě ID obličeje a buď jiné ID obličeje, nebo objekt Person a určuje, zda patří stejné osobě. Ověřování lze použít k pokontrole shody obličeje vrácené operací identifikovat.

Následující kód detekuje plošky ve dvou zdrojových obrázcích a pak každý z nich ověřuje proti obličeji zjištěnému z cílové image.

Získání imagí testu

Následující bloky kódu deklaruje proměnné, které budou ukazovat na cílové a zdrojové image pro operaci ověřování.

// Create a slice list to hold the target photos of the same person
targetImageFileNames :=  make([]string, 2)
targetImageFileNames[0] = "Family1-Dad1.jpg"
targetImageFileNames[1] = "Family1-Dad2.jpg"

// The source photos contain this person, maybe
sourceImageFileName1 := "Family1-Dad3.jpg"
sourceImageFileName2 := "Family1-Son1.jpg"

Detekovat obličeje pro ověření

Následující kód detekuje plošky ve zdrojových a cílových obrázcích a ukládá je do proměnných.

// DetectWithURL parameters
urlSource1 := imageBaseURL + sourceImageFileName1
urlSource2 := imageBaseURL + sourceImageFileName2
url1 :=  face.ImageURL { URL: &urlSource1 }
url2 := face.ImageURL { URL: &urlSource2 }
returnFaceIDVerify := true
returnFaceLandmarksVerify := false
returnRecognitionModelVerify := false

// Detect face(s) from source image 1, returns a ListDetectedFace struct
// We specify detection model 3 because we are not retrieving attributes.
detectedVerifyFaces1, dErrV1 := client.DetectWithURL(faceContext, url1 , &returnFaceIDVerify, &returnFaceLandmarksVerify, nil, face.Recognition04, &returnRecognitionModelVerify, face.Detection03)
if dErrV1 != nil { log.Fatal(dErrV1) }
// Dereference the result, before getting the ID
dVFaceIds1 := *detectedVerifyFaces1.Value 
// Get ID of the detected face
imageSource1Id := dVFaceIds1[0].FaceID
fmt.Println(fmt.Sprintf("%v face(s) detected from image: %v", len(dVFaceIds1), sourceImageFileName1))

// Detect face(s) from source image 2, returns a ListDetectedFace struct
// We specify detection model 3 because we are not retrieving attributes.
detectedVerifyFaces2, dErrV2 := client.DetectWithURL(faceContext, url2 , &returnFaceIDVerify, &returnFaceLandmarksVerify, nil, face.Recognition04, &returnRecognitionModelVerify, face.Detection03)
if dErrV2 != nil { log.Fatal(dErrV2) }
// Dereference the result, before getting the ID
dVFaceIds2 := *detectedVerifyFaces2.Value 
// Get ID of the detected face
imageSource2Id := dVFaceIds2[0].FaceID
fmt.Println(fmt.Sprintf("%v face(s) detected from image: %v", len(dVFaceIds2), sourceImageFileName2))

// Detect faces from each target image url in list. DetectWithURL returns a VerifyResult with Value of list[DetectedFaces]
// Empty slice list for the target face IDs (UUIDs)
var detectedVerifyFacesIds [2]uuid.UUID
for i, imageFileName := range targetImageFileNames {
    urlSource := imageBaseURL + imageFileName 
    url :=  face.ImageURL { URL: &urlSource}
    // We specify detection model 3 because we are not retrieving attributes.
    detectedVerifyFaces, dErrV := client.DetectWithURL(faceContext, url, &returnFaceIDVerify, &returnFaceLandmarksVerify, nil, face.Recognition04, &returnRecognitionModelVerify, face.Detection03)
    if dErrV != nil { log.Fatal(dErrV) }
    // Dereference *[]DetectedFace from Value in order to loop through it.
    dVFaces := *detectedVerifyFaces.Value
    // Add the returned face's face ID
    detectedVerifyFacesIds[i] = *dVFaces[0].FaceID
    fmt.Println(fmt.Sprintf("%v face(s) detected from image: %v", len(dVFaces), imageFileName))
}

Získat výsledky ověřování

Následující kód porovnává každý zdrojový obraz s cílovou imagí a vytiskne zprávu, která označuje, zda patří stejné osobě.

// Verification example for faces of the same person. The higher the confidence, the more identical the faces in the images are.
// Since target faces are the same person, in this example, we can use the 1st ID in the detectedVerifyFacesIds list to compare.
verifyRequestBody1 := face.VerifyFaceToFaceRequest{ FaceID1: imageSource1Id, FaceID2: &detectedVerifyFacesIds[0] }
verifyResultSame, vErrSame := client.VerifyFaceToFace(faceContext, verifyRequestBody1)
if vErrSame != nil { log.Fatal(vErrSame) }

fmt.Println()

// Check if the faces are from the same person.
if (*verifyResultSame.IsIdentical) {
    fmt.Println(fmt.Sprintf("Faces from %v & %v are of the same person, with confidence %v", 
    sourceImageFileName1, targetImageFileNames[0], strconv.FormatFloat(*verifyResultSame.Confidence, 'f', 3, 64)))
} else {
    // Low confidence means they are more differant than same.
    fmt.Println(fmt.Sprintf("Faces from %v & %v are of a different person, with confidence %v", 
    sourceImageFileName1, targetImageFileNames[0], strconv.FormatFloat(*verifyResultSame.Confidence, 'f', 3, 64)))
}

// Verification example for faces of different persons. 
// Since target faces are same person, in this example, we can use the 1st ID in the detectedVerifyFacesIds list to compare.
verifyRequestBody2 := face.VerifyFaceToFaceRequest{ FaceID1: imageSource2Id, FaceID2: &detectedVerifyFacesIds[0] }
verifyResultDiff, vErrDiff := client.VerifyFaceToFace(faceContext, verifyRequestBody2)
if vErrDiff != nil { log.Fatal(vErrDiff) }
// Check if the faces are from the same person.
if (*verifyResultDiff.IsIdentical) {
    fmt.Println(fmt.Sprintf("Faces from %v & %v are of the same person, with confidence %v", 
    sourceImageFileName2, targetImageFileNames[0], strconv.FormatFloat(*verifyResultDiff.Confidence, 'f', 3, 64)))
} else {
    // Low confidence means they are more differant than same.
    fmt.Println(fmt.Sprintf("Faces from %v & %v are of a different person, with confidence %v", 
    sourceImageFileName2, targetImageFileNames[0], strconv.FormatFloat(*verifyResultDiff.Confidence, 'f', 3, 64)))
}

Vyhledání podobných tváří

Následující kód přebírá jednu zjištěnou plošku (zdroj) a hledá v sadě dalších tváře (cíle) k nalezení shody (hledání na základě obrázku). Pokud najde shodu, vytiskne ID spárovaného obličeje konzole.

Detekovat plošky pro porovnání

Nejdřív uložte odkaz na plochu, kterou jste zjistili v části detekce a analýza . Tato ploška bude zdrojem.

// Select an ID in single-faced image for comparison to faces detected in group image. Used in Find Similar.
firstImageFaceID := dFaces[0].FaceID

Poté zadejte následující kód pro detekci sady plošek v jiném obrázku. Tyto plošky budou cílem.

// Detect the faces in an image that contains multiple faces
groupImageURL := "http://www.historyplace.com/kennedy/president-family-portrait-closeup.jpg"
groupImageName := path.Base(groupImageURL)
groupImage := face.ImageURL { URL: &groupImageURL } 

// API call to detect faces in group image, using recognition model 4. This returns a ListDetectedFace struct.
// We specify detection model 3 because we are not retrieving attributes.
detectedGroupFaces, dgErr := client.DetectWithURL(faceContext, groupImage, &returnFaceID, &returnFaceLandmarks, nil, face.Recognition04, &returnRecognitionModel, face.Detection03)
if dgErr != nil { log.Fatal(dgErr) }
fmt.Println()

// Detect faces in the group image.
// Dereference *[]DetectedFace, in order to loop through it.
dFaces2 := *detectedGroupFaces.Value
// Make slice list of UUIDs
faceIDs := make([]uuid.UUID, len(dFaces2))
fmt.Print("Detected faces in (" + groupImageName + ") with ID(s):\n")
for i, face := range dFaces2 {
    faceIDs[i] = *face.FaceID // Dereference DetectedFace.FaceID
    fmt.Println(*face.FaceID)
}

Najít shody

Následující kód používá metodu FindSimilar k vyhledání všech cílových plošek, které odpovídají zdrojové ploše.

// Add single-faced image ID to struct
findSimilarBody := face.FindSimilarRequest { FaceID: firstImageFaceID, FaceIds: &faceIDs }
// Get the list of similar faces found in the group image of previously detected faces
listSimilarFaces, sErr := client.FindSimilar(faceContext, findSimilarBody)
if sErr != nil { log.Fatal(sErr) }

// The *[]SimilarFace 
simFaces := *listSimilarFaces.Value

Tisk shody

Následující kód vytiskne podrobnosti o shodě do konzoly.

// Print the details of the similar faces detected 
fmt.Print("Similar faces found in (" + groupImageName + ") with ID(s):\n")
var sScore float64
for _, face := range simFaces {
    fmt.Println(face.FaceID)
    // Confidence of the found face with range 0.0 to 1.0.
    sScore = *face.Confidence
    fmt.Println("The similarity confidence: ", strconv.FormatFloat(sScore, 'f', 3, 64))
}

Spuštění aplikace

Spusťte aplikaci pro rozpoznávání tváře z adresáře aplikace pomocí go run <app-name> příkazu.

go run sample-app.go

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete prostředek nebo skupinu prostředků odstranit. Odstraněním skupiny prostředků se odstraní také všechny další prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Pokud jste v tomto rychlém startu vytvořili pole Person a chcete ho odstranit, zavolejte metodu Delete .

Další kroky

V tomto rychlém startu jste zjistili, jak použít klientské knihovny pro tvář k přechodu na základní úkoly rozpoznávání obličeje. V dalším kroku se dozvíte o různých modelech detekce obličeje a o tom, jak zadat správný model pro váš případ použití.

• Co je služba Rozpoznávání tváře?
• Zdrojový kód pro tuto ukázku najdete na GitHub.

Rychlý start: Klientská knihovna pro službu Face pro JavaScript

Začínáme s rozpoznáváním obličeje pomocí klientské knihovny rozpoznávání tváře pro JavaScript. Postupujte podle těchto kroků a nainstalujte balíček a vyzkoušejte si příklad kódu pro základní úlohy. Služba Rozpoznávání tváře poskytuje přístup k pokročilým algoritmům pro rozpoznávání a rozpoznávání lidských tváří na obrázcích.

Pomocí klientské knihovny pro rozhraní face pro JavaScript můžete:

• Detekce a analýza tváří
• Identifikace tváře
• Vyhledání podobných tváří

Referenční dokumentace | Zdrojový kód knihovny | Balíček (npm) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Nejnovější verze Node.js
• Váš účet Azure musí mít přiřazenou Cognitive Services přispěvatele, abyste mohli odsouhlasit podmínky AI a vytvořit prostředek. Požádejte správce, aby tuto roli přiřadil vašemu účtu.
• Jakmile máte předplatné Azure, na webu Azure vytvořte prostředek Azure Portal a získejte svůj klíč a koncový bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k rozhraní API pro rozpoznávání tváře budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Vytvoření nové aplikace Node.js

V okně konzoly (například cmd, PowerShell nebo Bash) vytvořte nový adresář pro vaši aplikaci a přejděte do něj.

mkdir myapp && cd myapp

Spuštěním příkazu npm init vytvořte aplikaci Node se package.json souborem.

npm init

Instalace klientské knihovny

Nainstalujte ms-rest-azure azure-cognitiveservices-face balíčky NPM a :

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

Soubor vaší package.json aplikace se aktualizuje o závislosti.

Vytvořte soubor s názvem a index.js importujte následující knihovny:

const msRest = require("@azure/ms-rest-js");
const Face = require("@azure/cognitiveservices-face");
const uuid = require("uuid/v4");

Vytvořte proměnné pro koncový bod a klíč Azure vašeho prostředku.

key = "<paste-your-face-key-here>"
endpoint = "<paste-your-face-endpoint-here>"

Objektový model

Následující třídy a rozhraní se řídí některými hlavními funkcemi klientské knihovny rozhraní .NET pro tváře:

Příklady kódu

Následující fragmenty kódu ukazují, jak pomocí klientské knihovny pro rozhraní .NET provádět následující úlohy:

• Ověření klienta
• Detekce a analýza tváří
• Identifikace tváře
• Vyhledání podobných tváří

Ověření klienta

Vytvořte instanci klienta s koncovým bodem a klíčem. Vytvořte objekt ApiKeyCredentials s vaším klíčem a použijte ho s koncovým bodem k vytvoření objektu FaceClient.

const credentials = new msRest.ApiKeyCredentials({ inHeader: { 'Ocp-Apim-Subscription-Key': key } });
const client = new Face.FaceClient(credentials, endpoint);

Deklarace globálních hodnot a pomocná funkce

Pro několik operací s tváří, které přidáte později, jsou potřeba následující globální hodnoty.

Adresa URL odkazuje na složku ukázkových obrázků. UUID bude sloužit jako název i ID skupiny PersonGroup, kterou vytvoříte.

const image_base_url = "https://csdx.blob.core.windows.net/resources/Face/Images/";
const person_group_id = uuid();

K čekání na dokončení trénování skupiny PersonGroup použijete následující funkci.

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

Detekce a analýza tváří

Detekce tváří se vyžaduje jako první krok v analýze tváře a ověření identity. Tato část ukazuje, jak vrátit další data atributu tváře. Pokud chcete detekovat tváře pouze pro identifikaci nebo ověření tváře, přejděte k pozdějším částem.

Získání detekovaných objektů tváře

Vytvořte novou metodu pro rozpoznávání tváří. Metoda zpracuje tři obrázky na dané adrese URL a vytvoří seznam objektů DetectFaceExtract DetectedFace v paměti programu. Seznam hodnot FaceAttributeType určuje, které funkce se mají extrahovat.

Metoda DetectFaceExtract pak analyzuje a vytiskne data atributu pro každou zjištěnou tvář. Každý atribut musí být zadán samostatně v původním volání rozhraní API pro rozpoznávání tváře (v seznamu FaceAttributeType). Následující kód zpracuje každý atribut, ale pravděpodobně budete muset použít pouze jeden nebo několik atributů.

async function DetectFaceExtract() {
    console.log("========DETECT FACES========");
    console.log();

    // Create a list of images
    const image_file_names = [
        "detection1.jpg",    // single female with glasses
        // "detection2.jpg", // (optional: single man)
        // "detection3.jpg", // (optional: single male construction worker)
        // "detection4.jpg", // (optional: 3 people at cafe, 1 is blurred)
        "detection5.jpg",    // family, woman child man
        "detection6.jpg"     // elderly couple, male female
    ];

// NOTE await does not work properly in for, forEach, and while loops. Use Array.map and Promise.all instead.
    await Promise.all (image_file_names.map (async function (image_file_name) {
        let detected_faces = await client.face.detectWithUrl(image_base_url + image_file_name,
            {
                returnFaceAttributes: ["Accessories","Age","Blur","Emotion","Exposure","FacialHair","Gender","Glasses","Hair","HeadPose","Makeup","Noise","Occlusion","Smile"],
                // We specify detection model 1 because we are retrieving attributes.
                detectionModel: "detection_01"
            });
        console.log (detected_faces.length + " face(s) detected from image " + image_file_name + ".");
        console.log("Face attributes for face(s) in " + image_file_name + ":");

// Parse and print all attributes of each detected face.
        detected_faces.forEach (async function (face) {
            // Get the bounding box of the face
            console.log("Bounding box:\n  Left: " + face.faceRectangle.left + "\n  Top: " + face.faceRectangle.top + "\n  Width: " + face.faceRectangle.width + "\n  Height: " + face.faceRectangle.height);

            // Get the accessories of the face
            let accessories = face.faceAttributes.accessories.join();
            if (0 === accessories.length) {
                console.log ("No accessories detected.");
            }
            else {
                console.log ("Accessories: " + accessories);
            }

            // Get face other attributes
            console.log("Age: " + face.faceAttributes.age);
            console.log("Blur: " + face.faceAttributes.blur.blurLevel);

            // Get emotion on the face
            let emotions = "";
            let emotion_threshold = 0.0;
            if (face.faceAttributes.emotion.anger > emotion_threshold) { emotions += "anger, "; }
            if (face.faceAttributes.emotion.contempt > emotion_threshold) { emotions += "contempt, "; }
            if (face.faceAttributes.emotion.disgust > emotion_threshold) { emotions +=  "disgust, "; }
            if (face.faceAttributes.emotion.fear > emotion_threshold) { emotions +=  "fear, "; }
            if (face.faceAttributes.emotion.happiness > emotion_threshold) { emotions +=  "happiness, "; }
            if (face.faceAttributes.emotion.neutral > emotion_threshold) { emotions +=  "neutral, "; }
            if (face.faceAttributes.emotion.sadness > emotion_threshold) { emotions +=  "sadness, "; }
            if (face.faceAttributes.emotion.surprise > emotion_threshold) { emotions +=  "surprise, "; }
            if (emotions.length > 0) {
                console.log ("Emotions: " + emotions.slice (0, -2));
            }
            else {
                console.log ("No emotions detected.");
            }
            
            // Get more face attributes
            console.log("Exposure: " + face.faceAttributes.exposure.exposureLevel);
            if (face.faceAttributes.facialHair.moustache + face.faceAttributes.facialHair.beard + face.faceAttributes.facialHair.sideburns > 0) {
                console.log("FacialHair: Yes");
            }
            else {
                console.log("FacialHair: No");
            }
            console.log("Gender: " + face.faceAttributes.gender);
            console.log("Glasses: " + face.faceAttributes.glasses);

            // Get hair color
            var color = "";
            if (face.faceAttributes.hair.hairColor.length === 0) {
                if (face.faceAttributes.hair.invisible) { color = "Invisible"; } else { color = "Bald"; }
            }
            else {
                color = "Unknown";
                var highest_confidence = 0.0;
                face.faceAttributes.hair.hairColor.forEach (function (hair_color) {
                    if (hair_color.confidence > highest_confidence) {
                        highest_confidence = hair_color.confidence;
                        color = hair_color.color;
                    }
                });
            }
            console.log("Hair: " + color);

            // Get more attributes
            console.log("Head pose:");
            console.log("  Pitch: " + face.faceAttributes.headPose.pitch);
            console.log("  Roll: " + face.faceAttributes.headPose.roll);
            console.log("  Yaw: " + face.faceAttributes.headPose.yaw);
 
            console.log("Makeup: " + ((face.faceAttributes.makeup.eyeMakeup || face.faceAttributes.makeup.lipMakeup) ? "Yes" : "No"));
            console.log("Noise: " + face.faceAttributes.noise.noiseLevel);

            console.log("Occlusion:");
            console.log("  Eye occluded: " + (face.faceAttributes.occlusion.eyeOccluded ? "Yes" : "No"));
            console.log("  Forehead occluded: " + (face.faceAttributes.occlusion.foreheadOccluded ? "Yes" : "No"));
            console.log("  Mouth occluded: " + (face.faceAttributes.occlusion.mouthOccluded ? "Yes" : "No"));

            console.log("Smile: " + face.faceAttributes.smile);
            console.log();
        });
    }));
}

Identifikace tváře

Operace Identify posouvá obrázek osoby (nebo více lidí) a hledá uložený objekt osoby přidružený ke každému obličeje na obrázku (vyhledávání rozpoznávání obličeje). Porovná každou detekované tváře s databází PersonGroups různými objekty Person, jejichž obličejové rysy jsou známé. Abyste mohli provést operaci Identify, musíte nejprve vytvořit a vytrénovat skupinu PersonGroup.

Přidání tváří do skupiny PersonGroup

Vytvořte následující funkci pro přidání tváří do skupiny PersonGroup.

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];

        // Wait briefly so we do not exceed rate limits.
        await sleep (1000);

        let person = await client.personGroupPerson.create(person_group_id, { name : key });
        console.log("Create a person group person: " + key + ".");

        // Add faces to the person group person.
        await Promise.all (value.map (async function (similar_image) {
            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);
        }));
    }));

    console.log ("Done adding faces to person group.");
}

Čekání na trénování skupiny PersonGroup

Vytvořte následující pomocnou funkci, která počká na dokončení trénování skupinou PersonGroup.

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

Vytvoření skupiny PersonGroup

Následující kód:

• Vytvoří skupinu PersonGroup.
• Přidá tváře do skupiny PersonGroup voláním AddFacesToPersonGroup metody , kterou jste definovali dříve.
• Trénuje skupinu PersonGroup.
• Identifikuje tváře ve skupině PersonGroup.

Tato skupina PersonGroup a její přidružené objekty Person jsou teď připravené k použití v operacích Ověřit, Identifikovat nebo Seskupit.

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, { name : 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.
    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) {
        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 + ".");
    }));
    console.log();
}

Vyhledání podobných tváří

Následující kód vezme jednu zjištěnou tvář (zdroj) a prohledá sadu dalších tváří (cíl), aby našel shody (vyhledávání tváří podle obrázku). Když najde shodu, vytiskne ID srovnané tváře na konzole.

Rozpoznávání tváří pro porovnání

Nejprve definujte druhou metodu detekce obličeje. Před porovnáním tváří na obrázcích je potřeba detekovat a tato metoda detekce je optimalizovaná pro operace porovnání. Ne extractuje podrobné atributy tváře jako v části výše a používá jiný model rozpoznávání.

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 not retrieving attributes.
    let detected_faces = await client.face.detectWithUrl(url,
        {
            detectionModel: "detection_03",
            recognitionModel: "recognition_04"
        });
    return detected_faces;
}

Vyhledání shod

Následující metoda detekuje tváře v sadě cílových obrázků a v jednom zdrojovém obrázku. Pak je porovná a najde všechny cílové image, které jsou podobné zdrojové imagi. Nakonec vytiskne podrobnosti o shodě do konzoly.

async function FindSimilar() {
    console.log("========FIND SIMILAR========");
    console.log();

    const source_image_file_name = "findsimilar.jpg";
    const target_image_file_names = [
        "Family1-Dad1.jpg",
        "Family1-Daughter1.jpg",
        "Family1-Mom1.jpg",
        "Family1-Son1.jpg",
        "Family2-Lady1.jpg",
        "Family2-Man1.jpg",
        "Family3-Lady1.jpg",
        "Family3-Man1.jpg"
    ];

    let target_face_ids = (await Promise.all (target_image_file_names.map (async function (target_image_file_name) {
        // Detect faces from target image url.
        var faces = await DetectFaceRecognize(image_base_url + target_image_file_name);
        console.log(faces.length + " face(s) detected from image: " +  target_image_file_name + ".");
        return faces.map (function (face) { return face.faceId });;
    }))).flat();

    // Detect faces from source image url.
    let detected_faces = await DetectFaceRecognize(image_base_url + source_image_file_name);

    // Find a similar face(s) in the list of IDs. Comapring only the first in list for testing purposes.
    let results = await client.face.findSimilar(detected_faces[0].faceId, { faceIds : target_face_ids });
    results.forEach (function (result) {
        console.log("Faces from: " + source_image_file_name + " and ID: " + result.faceId + " are similar with confidence: " + result.confidence + ".");
    });
    console.log();
}

Hlavní

Nakonec vytvořte funkci main a zavolejte ji.

async function main() {
    await DetectFaceExtract();
    await FindSimilar();
    await IdentifyInPersonGroup();
    console.log ("Done.");
}
main();

Spuštění aplikace

Spusťte aplikaci pomocí node příkazu v souboru rychlého startu.

node index.js

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak pomocí klientské knihovny rozpoznávání tváře pro JavaScript provádět úlohy rozpoznávání obličeje. Dále se seznámíte s různými modely detekce tváří a zjistíte, jak určit správný model pro váš případ použití.

• Co je služba Rozpoznávání tváře?
• Zdrojový kód této ukázky najdete na GitHub.

Začínáme s rozpoznáváním tváří pomocí klientské knihovny pro rozpoznávání tváře pro Python. Postupujte podle těchto kroků a nainstalujte balíček a vyzkoušejte si příklad kódu pro základní úlohy. Služba Rozpoznávání tváře poskytuje přístup k pokročilým algoritmům pro rozpoznávání a rozpoznávání lidských tváří na obrázcích.

Pomocí klientské knihovny pro tváře pro Python můžete:

• Detekce a analýza tváří
• Identifikace tváře
• Ověření tváří
• Vyhledání podobných tváří

Referenční dokumentace | Zdrojový kód knihovny | Balíček (PiPy) | Ukázky

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Python 3.x
  • Instalace Pythonu by měla obsahovat pip. Spuštěním příkazu na příkazovém řádku můžete zkontrolovat, jestli máte nainstalovaný pip --version pip. Získejte pip instalací nejnovější verze Pythonu.
• Váš účet Azure musí mít přiřazenou Cognitive Services přispěvatele, abyste mohli odsouhlasit podmínky AI a vytvořit prostředek. Požádejte správce, aby tuto roli přiřadil vašemu účtu.
• Jakmile máte předplatné Azure, vytvořte prostředek Face (Tvář) a vytvořte prostředek Face (Tvář) v Azure Portal a získejte bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k rozhraní API pro rozpoznávání tváře budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.

Nastavení

Instalace klientské knihovny

Po instalaci Pythonu můžete klientskou knihovnu nainstalovat pomocí:

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

Vytvoření nové aplikace v Pythonu

Vytvořte nový skript — Pythonu quickstart-file.py, například . Pak ho otevřete v upřednostňovaném editoru nebo integrovaném vývojovém prostředí (IDE) a naimportujte následující knihovny.

import asyncio
import io
import glob
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

Pak vytvořte proměnné pro koncový bod a klíč Azure vašeho prostředku.

# This key will serve all examples in this document.
KEY = "PASTE_YOUR_FACE_SUBSCRIPTION_KEY_HERE"

# This endpoint will be used in all examples in this quickstart.
ENDPOINT = "PASTE_YOUR_FACE_ENDPOINT_HERE"

Objektový model

Následující třídy a rozhraní se řídí některými hlavními funkcemi klientské knihovny Pythonu pro tváře.

Příklady kódu

Tyto fragmenty kódu vám ukážou, jak provádět následující úlohy s klientskou knihovnou služby Face pro Python:

• Ověření klienta
• Detekce a analýza tváří
• Identifikace tváře
• Ověření tváří
• Vyhledání podobných tváří

Ověření klienta

Vytvořte instanci klienta s koncovým bodem a klíčem. Vytvořte objekt CognitiveServicesCredentials s vaším klíčem a použijte ho s koncovým bodem k vytvoření objektu FaceClient.

# Create an authenticated FaceClient.
face_client = FaceClient(ENDPOINT, CognitiveServicesCredentials(KEY))

Detekce a analýza tváří

Detekce tváří se vyžaduje v analýzách tváří a ověřování identity. Tato část ukazuje, jak vrátit další data atributu tváře. Pokud chcete detekovat tváře pouze pro identifikaci nebo ověření tváře, přejděte k pozdějším částem.

Následující kód rozpozná tvář na vzdáleném obrázku. Vytiskne ID detekované tváře do konzoly a uloží ho také do paměti programu. Pak rozpozná tváře na obrázku s více lidmi a vytiskne jejich ID také do konzoly. Změnou parametrů v metodě detect_with_url můžete vrátit různé informace s každým objektem DetectedFace.

# Detect a face in an image that contains a single face
single_face_image_url = 'https://www.biography.com/.image/t_share/MTQ1MzAyNzYzOTgxNTE0NTEz/john-f-kennedy---mini-biography.jpg'
single_image_name = os.path.basename(single_face_image_url)
# We use detection model 3 to get better performance.
detected_faces = face_client.face.detect_with_url(url=single_face_image_url, detection_model='detection_03')
if not detected_faces:
    raise Exception('No face detected from image {}'.format(single_image_name))

# Display the detected face ID in the first single-face image.
# Face IDs are used for comparison to faces (their IDs) detected in other images.
print('Detected face ID from', single_image_name, ':')
for face in detected_faces: print (face.face_id)
print()

# Save this ID for use in Find Similar
first_image_face_ID = detected_faces[0].face_id

Zobrazení a orámování tváří

Následující kód vygeneruje daný obrázek na zobrazení a pomocí vlastnosti DetectedFace.faceRectangle nakreslí obdélníky kolem tváří.

# Detect a face in an image that contains a single face
single_face_image_url = 'https://raw.githubusercontent.com/Microsoft/Cognitive-Face-Windows/master/Data/detection1.jpg'
single_image_name = os.path.basename(single_face_image_url)
# We use detection model 3 to get better performance.
detected_faces = face_client.face.detect_with_url(url=single_face_image_url, detection_model='detection_03')
if not detected_faces:
    raise Exception('No face detected from image {}'.format(single_image_name))

# Convert width height to a point in a rectangle
def getRectangle(faceDictionary):
    rect = faceDictionary.face_rectangle
    left = rect.left
    top = rect.top
    right = left + rect.width
    bottom = top + rect.height
    
    return ((left, top), (right, bottom))

def drawFaceRectangles() :
# Download the image from the url
    response = requests.get(single_face_image_url)
    img = Image.open(BytesIO(response.content))

# For each face returned use the face rectangle and draw a red box.
    print('Drawing rectangle around face... see popup for results.')
    draw = ImageDraw.Draw(img)
    for face in detected_faces:
        draw.rectangle(getRectangle(face), outline='red')

# Display the image in the default image browser.
    img.show()

# Uncomment this to show the face rectangles.
#    drawFaceRectangles()

Identifikace tváře

Operace Identify posouvá obrázek osoby (nebo více lidí) a hledá identitu každé tváře na obrázku (vyhledávání rozpoznávání obličeje). Porovná každou detekované tváře s databází PersonGroup s různými objekty Person, jejichž obličejové rysy jsou známé.

Vytvoření skupiny PersonGroup

Následující kód vytvoří skupinu PersonGroup se třemi různými objekty Person. Přidruží každou osobu k sadě příkladů obrázků a pak se vytrénuje, aby dokázala každou osobu rozpoznat.

Abyste si tento scénář prošli, musíte uložit následující obrázky do kořenového adresáře projektu: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

Tato skupina obrázků obsahuje tři sady obrázků tváří, které odpovídají třem různým lidem. Kód definuje tři objekty Person a přidruží je k souborům obrázků, které začínají woman na , a man child .

Po nastavení obrázků definujte v horní části skriptu popisek pro objekt PersonGroup, který vytvoříte.

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

Pak na konec skriptu přidejte následující kód. Tento kód vytvoří persongroup a tři objekty Person.

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

# Define woman friend
woman = face_client.person_group_person.create(PERSON_GROUP_ID, "Woman")
# Define man friend
man = face_client.person_group_person.create(PERSON_GROUP_ID, "Man")
# Define child friend
child = face_client.person_group_person.create(PERSON_GROUP_ID, "Child")

Přiřazení tváří osobám

Následující kód seřadí obrázky podle jejich předpony, rozpozná tváře a přiřadí tváře ke každému objektu Person.

'''
Detect faces and register to correct person
'''
# Find all jpeg images of friends in working directory
woman_images = [file for file in glob.glob('*.jpg') if file.startswith("w")]
man_images = [file for file in glob.glob('*.jpg') if file.startswith("m")]
child_images = [file for file in glob.glob('*.jpg') if file.startswith("ch")]

# Add to a woman person
for image in woman_images:
    w = open(image, 'r+b')
    face_client.person_group_person.add_face_from_stream(PERSON_GROUP_ID, woman.person_id, w)

# Add to a man person
for image in man_images:
    m = open(image, 'r+b')
    face_client.person_group_person.add_face_from_stream(PERSON_GROUP_ID, man.person_id, m)

# Add to a child person
for image in child_images:
    ch = open(image, 'r+b')
    face_client.person_group_person.add_face_from_stream(PERSON_GROUP_ID, child.person_id, ch)

Trénovat skupinu PersonGroup

Po přiřazení tváří musíte skupinu PersonGroup vytrénovat tak, aby identifikovala vizuální funkce přidružené ke každému z jejích objektů Person. Následující kód volá metodu asynchronního trénování a dotazuje se na výsledek a vytiskne stav do konzoly.

'''
Train PersonGroup
'''
print()
print('Training the person group...')
# Train the person group
face_client.person_group.train(PERSON_GROUP_ID)

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)

Získání testovacího obrázku

Následující kód vyhledá v kořenovém adresáři projektu obrázek test-image-person-group.jpg rozpozná tváře na obrázku. Tento obrázek najdete v obrázcích používaných pro správu skupiny PersonGroup: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

'''
Identify a face against a defined PersonGroup
'''
# Group image for testing against
test_image_array = glob.glob('test-image-person-group.jpg')
image = open(test_image_array[0], 'r+b')

print('Pausing for 60 seconds to avoid triggering rate limit on free account...')
time.sleep (60)

# Detect faces
face_ids = []
# We use detection model 3 to get better performance.
faces = face_client.face.detect_with_stream(image, detection_model='detection_03')
for face in faces:
    face_ids.append(face.face_id)

ID tváří identifikovaných výstupem

Metoda identify vezme pole detekovaných tváří a porovná je s persongroup. Pokud se zjištěná tvář shoduje s osobou , uloží výsledek. Tento kód vytiskne podrobné výsledky shody do konzoly.

# Identify faces
results = face_client.face.identify(face_ids, PERSON_GROUP_ID)
print('Identifying faces in {}'.format(os.path.basename(image.name)))
if not results:
    print('No person identified in the person group for faces from {}.'.format(os.path.basename(image.name)))
for person in results:
    if len(person.candidates) > 0:
        print('Person for face ID {} is identified in {} with a confidence of {}.'.format(person.face_id, os.path.basename(image.name), person.candidates[0].confidence)) # Get topmost confidence score
    else:
        print('No person identified for face ID {} in {}.'.format(person.face_id, os.path.basename(image.name)))

Ověření tváří

Operace Verify vezme ID tváře a další ID tváře nebo objekt Person a určí, jestli patří stejné osobě. Ověření se může použít k dvojité kontrole shody tváře vrácené operací Identify.

Následující kód rozpozná tváře ve dvou zdrojových obrázcích a pak je ověří proti obličeje zjištěnému z cílového obrázku.

Získání testovacích obrázků

Následující bloky kódu deklarují proměnné, které budou odkazovat na zdrojové a cílové image pro operaci ověření.

# Base url for the Verify and Facelist/Large Facelist operations
IMAGE_BASE_URL = 'https://csdx.blob.core.windows.net/resources/Face/Images/'

# Create a list to hold the target photos of the same person
target_image_file_names = ['Family1-Dad1.jpg', 'Family1-Dad2.jpg']
# The source photos contain this person
source_image_file_name1 = 'Family1-Dad3.jpg'
source_image_file_name2 = 'Family1-Son1.jpg'

Detekce tváří pro ověření

Následující kód rozpozná tváře ve zdrojovém a cílovém obrázky a uloží je do proměnných.

# Detect face(s) from source image 1, returns a list[DetectedFaces]
# We use detection model 3 to get better performance.
detected_faces1 = face_client.face.detect_with_url(IMAGE_BASE_URL + source_image_file_name1, detection_model='detection_03')
# Add the returned face's face ID
source_image1_id = detected_faces1[0].face_id
print('{} face(s) detected from image {}.'.format(len(detected_faces1), source_image_file_name1))

# Detect face(s) from source image 2, returns a list[DetectedFaces]
detected_faces2 = face_client.face.detect_with_url(IMAGE_BASE_URL + source_image_file_name2, detection_model='detection_03')
# Add the returned face's face ID
source_image2_id = detected_faces2[0].face_id
print('{} face(s) detected from image {}.'.format(len(detected_faces2), source_image_file_name2))

# List for the target face IDs (uuids)
detected_faces_ids = []
# Detect faces from target image url list, returns a list[DetectedFaces]
for image_file_name in target_image_file_names:
    # We use detection model 3 to get better performance.
    detected_faces = face_client.face.detect_with_url(IMAGE_BASE_URL + image_file_name, detection_model='detection_03')
    # Add the returned face's face ID
    detected_faces_ids.append(detected_faces[0].face_id)
    print('{} face(s) detected from image {}.'.format(len(detected_faces), image_file_name))

Získání výsledků ověření

Následující kód porovná jednotlivé zdrojové obrázky s cílovým obrázkem a vytiskne zprávu, která označuje, jestli patří stejné osobě.

# Verification example for faces of the same person. The higher the confidence, the more identical the faces in the images are.
# Since target faces are the same person, in this example, we can use the 1st ID in the detected_faces_ids list to compare.
verify_result_same = face_client.face.verify_face_to_face(source_image1_id, detected_faces_ids[0])
print('Faces from {} & {} are of the same person, with confidence: {}'
    .format(source_image_file_name1, target_image_file_names[0], verify_result_same.confidence)
    if verify_result_same.is_identical
    else 'Faces from {} & {} are of a different person, with confidence: {}'
        .format(source_image_file_name1, target_image_file_names[0], verify_result_same.confidence))

# Verification example for faces of different persons.
# Since target faces are same person, in this example, we can use the 1st ID in the detected_faces_ids list to compare.
verify_result_diff = face_client.face.verify_face_to_face(source_image2_id, detected_faces_ids[0])
print('Faces from {} & {} are of the same person, with confidence: {}'
    .format(source_image_file_name2, target_image_file_names[0], verify_result_diff.confidence)
    if verify_result_diff.is_identical
    else 'Faces from {} & {} are of a different person, with confidence: {}'
        .format(source_image_file_name2, target_image_file_names[0], verify_result_diff.confidence))

Vyhledání podobných tváří

Následující kód vezme jednu zjištěnou tvář (zdroj) a prohledá sadu dalších tváří (cíl), aby našel shody (vyhledávání tváří podle obrázku). Když najde shodu, vytiskne ID srovnané tváře na konzole.

Vyhledání shod

Nejprve spusťte kód ve výše uvedené části (Detekcea analýza tváří) a uložte odkaz na jednu tvář. Potom spusťte následující kód, abyste na obrázku skupiny získejte odkazy na několik tváří.

# Detect the faces in an image that contains multiple faces
# Each detected face gets assigned a new ID
multi_face_image_url = "http://www.historyplace.com/kennedy/president-family-portrait-closeup.jpg"
multi_image_name = os.path.basename(multi_face_image_url)
# We use detection model 3 to get better performance.
detected_faces2 = face_client.face.detect_with_url(url=multi_face_image_url, detection_model='detection_03')

Pak přidejte následující blok kódu pro vyhledání instancí první tváře ve skupině. Informace o find_similar chování najdete v tématu o metodě .

# Search through faces detected in group image for the single face from first image.
# First, create a list of the face IDs found in the second image.
second_image_face_IDs = list(map(lambda x: x.face_id, detected_faces2))
# Next, find similar face IDs like the one detected in the first image.
similar_faces = face_client.face.find_similar(face_id=first_image_face_ID, face_ids=second_image_face_IDs)
if not similar_faces:
    print('No similar faces found in', multi_image_name, '.')

Tisk shod

Pomocí následujícího kódu vytiskněte podrobnosti shody do konzoly.

# Print the details of the similar faces detected
else:
    print('Similar faces found in', multi_image_name + ':')
    for face in similar_faces:
        first_image_face_ID = face.face_id
        # The similar face IDs of the single face image and the group image do not need to match, 
        # they are only used for identification purposes in each image.
        # The similar faces are matched using the Cognitive Services algorithm in find_similar().
        face_info = next(x for x in detected_faces2 if x.face_id == first_image_face_ID)
        if face_info:
            print('  Face ID: ', first_image_face_ID)
            print('  Face rectangle:')
            print('    Left: ', str(face_info.face_rectangle.left))
            print('    Top: ', str(face_info.face_rectangle.top))
            print('    Width: ', str(face_info.face_rectangle.width))
            print('    Height: ', str(face_info.face_rectangle.height))

Spuštění aplikace

Spusťte aplikaci pro rozpoznávání tváře z adresáře aplikace pomocí python příkazu .

python quickstart-file.py

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Pokud jste v tomto rychlém startu vytvořili skupinu PersonGroup a chcete ji odstranit, spusťte ve skriptu následující kód:

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

Další kroky

V tomto rychlém startu jste zjistili, jak pomocí klientské knihovny rozpoznávání tváře pro Python provádět úlohy rozpoznávání obličeje. Dále se seznámíte s různými modely detekce tváří a zjistíte, jak určit správný model pro váš případ použití.

• Co je služba Rozpoznávání tváře?
• Zdrojový kód této ukázky najdete na GitHub.

Začínáme s rozpoznáváním tváří pomocí rozhraní REST API. Služba Rozpoznávání tváře poskytuje přístup k pokročilým algoritmům pro rozpoznávání a rozpoznávání lidských tváří na obrázcích.

Pomocí funkce Face REST API:

• Detekce a analýza tváří
• Vyhledání podobných tváří

Požadavky

• Předplatné Azure – Vytvořte si ho zdarma.
• Váš účet Azure musí mít přiřazenou Cognitive Services přispěvatele, abyste mohli odsouhlasit podmínky AI a vytvořit prostředek. Požádejte správce, aby tuto roli přiřadil vašemu účtu.
• Jakmile máte předplatné Azure, vytvořte prostředek Face (Tvář) a vytvořte prostředek Face (Tvář) v Azure Portal a získejte bod. Po nasazení klikněte na Přejít k prostředku.
  • K připojení aplikace k rozhraní API pro rozpoznávání tváře budete potřebovat klíč a koncový bod z prostředku, který vytvoříte. Svůj klíč a koncový bod vložíte do kódu níže v pozdější části tohoto rychlého startu.
  • K vyzkoušejí služby můžete použít bezplatnou cenovou úroveň ( ) a později upgradovat F0 na placenou úroveň pro produkční prostředí.
• PowerShell verze 6.0 nebonovější nebo podobná aplikace příkazového řádku.

Detekce a analýza tváří

K volání rozhraní API pro rozpoznávání tváře a získání dat atributu tváře z obrázku použijete příkaz jako následující. Nejprve zkopírujte kód do textového editoru. Než ho budete moci spustit, budete muset provést změny určitých — částí příkazu.

curl -H "Ocp-Apim-Subscription-Key: TODO_INSERT_YOUR_FACE_SUBSCRIPTION_KEY_HERE" "TODO_INSERT_YOUR_FACE_ENDPOINT_HERE/face/v1.0/detect?detectionModel=detection_03&returnFaceId=true&returnFaceLandmarks=false" -H "Content-Type: application/json" --data-ascii "{\"url\":\"https://upload.wikimedia.org/wikipedia/commons/c/c3/RH_Louise_Lillian_Gish.jpg\"}"

Proveďte následující změny:

1. Ocp-Apim-Subscription-KeyPřiřaďte platný klíč předplatného Pro tvář.
2. Změňte první část adresy URL dotazu tak, aby odpovídala koncovému bodu, který odpovídá vašemu klíči předplatného.

   Poznámka

   Nové prostředky vytvořené po 1. červenci 2019 budou používat názvy vlastních subdomén. Další informace a úplný seznam regionálních koncových bodů najdete v tématu názvy vlastních subdomén pro Cognitive Services.

3. Volitelně můžete změnit adresu URL v textu požadavku tak, aby odkazovat na jiný obrázek.

Po provedení změn otevřete příkazový řádek a zadejte nový příkaz.

Prozkoumání výsledků

Informace o tvářích by se měly v okně konzoly zobrazit jako data JSON. Příklad:

[
  {
    "faceId": "49d55c17-e018-4a42-ba7b-8cbbdfae7c6f",
    "faceRectangle": {
      "top": 131,
      "left": 177,
      "width": 162,
      "height": 162
    }
  }
]  

Získání atributů tváře

Pokud chcete extrahovat atributy tváře, zavolejte znovu rozhraní DETECT API, ale nastavte detectionModel na detection_01 . Přidejte returnFaceAttributes také parametr dotazu. Příkaz by teď měl vypadat takto. Stejně jako předtím vložte klíč předplatného a koncový bod služby Face.

curl -H "Ocp-Apim-Subscription-Key: TODO_INSERT_YOUR_FACE_SUBSCRIPTION_KEY_HERE" "TODO_INSERT_YOUR_FACE_ENDPOINT_HERE/face/v1.0/detect?detectionModel=detection_01&returnFaceId=true&returnFaceLandmarks=false&returnFaceAttributes=age,gender,headPose,smile,facialHair,glasses,emotion,hair,makeup,occlusion,accessories,blur,exposure,noise" -H "Content-Type: application/json" --data-ascii "{\"url\":\"https://upload.wikimedia.org/wikipedia/commons/c/c3/RH_Louise_Lillian_Gish.jpg\"}"

Prozkoumání výsledků

Vrácené informace o tvářích teď obsahují atributy tváře. Příklad:

[
  {
    "faceId": "49d55c17-e018-4a42-ba7b-8cbbdfae7c6f",
    "faceRectangle": {
      "top": 131,
      "left": 177,
      "width": 162,
      "height": 162
    },
    "faceAttributes": {
      "smile": 0,
      "headPose": {
        "pitch": 0,
        "roll": 0.1,
        "yaw": -32.9
      },
      "gender": "female",
      "age": 22.9,
      "facialHair": {
        "moustache": 0,
        "beard": 0,
        "sideburns": 0
      },
      "glasses": "NoGlasses",
      "emotion": {
        "anger": 0,
        "contempt": 0,
        "disgust": 0,
        "fear": 0,
        "happiness": 0,
        "neutral": 0.986,
        "sadness": 0.009,
        "surprise": 0.005
      },
      "blur": {
        "blurLevel": "low",
        "value": 0.06
      },
      "exposure": {
        "exposureLevel": "goodExposure",
        "value": 0.67
      },
      "noise": {
        "noiseLevel": "low",
        "value": 0
      },
      "makeup": {
        "eyeMakeup": true,
        "lipMakeup": true
      },
      "accessories": [],
      "occlusion": {
        "foreheadOccluded": false,
        "eyeOccluded": false,
        "mouthOccluded": false
      },
      "hair": {
        "bald": 0,
        "invisible": false,
        "hairColor": [
          {
            "color": "brown",
            "confidence": 1
          },
          {
            "color": "black",
            "confidence": 0.87
          },
          {
            "color": "other",
            "confidence": 0.51
          },
          {
            "color": "blond",
            "confidence": 0.08
          },
          {
            "color": "red",
            "confidence": 0.08
          },
          {
            "color": "gray",
            "confidence": 0.02
          }
        ]
      }
    }
  }
]

Vyhledání podobných tváří

Tato operace vezme jednu zjištěnou tvář (zdroj) a prohledá sadu dalších tváří (cíl), aby našla shody (vyhledávání tváří podle obrázku). Když najde shodu, vytiskne ID srovnané tváře na konzole.

Rozpoznávání tváří pro porovnání

Nejprve je potřeba rozpoznávat tváře na obrázcích, než je budete moci porovnat. Spusťte tento příkaz stejně jako v části Zjistit a analyzovat. Tato metoda detekce je optimalizovaná pro operace porovnání. Ne extractuje podrobné atributy tváře jako v části výše a používá jiný model detekce.

curl -H "Ocp-Apim-Subscription-Key: TODO_INSERT_YOUR_FACE_SUBSCRIPTION_KEY_HERE" "TODO_INSERT_YOUR_FACE_ENDPOINT_HERE/face/v1.0/detect?detectionModel=detection_03&returnFaceId=true&returnFaceLandmarks=false" -H "Content-Type: application/json" --data-ascii "{\"url\":\"https://csdx.blob.core.windows.net/resources/Face/Images/Family1-Dad1.jpg\"}"

Vyhledejte "faceId" hodnotu v odpovědi JSON a uložte ji do dočasného umístění. Potom znovu zavolejte výše uvedený příkaz pro tyto adresy URL ostatních obrázků a uložte také ID jejich tváří. Tato ID použijete jako cílovou skupinu tváří, ze kterých najdete podobnou tvář.

https://csdx.blob.core.windows.net/resources/Face/Images/Family1-Daughter1.jpg
https://csdx.blob.core.windows.net/resources/Face/Images/Family1-Mom1.jpg
https://csdx.blob.core.windows.net/resources/Face/Images/Family1-Son1.jpg
https://csdx.blob.core.windows.net/resources/Face/Images/Family2-Lady1.jpg
https://csdx.blob.core.windows.net/resources/Face/Images/Family2-Man1.jpg
https://csdx.blob.core.windows.net/resources/Face/Images/Family3-Lady1.jpg
https://csdx.blob.core.windows.net/resources/Face/Images/Family3-Man1.jpg

Nakonec detekovat jednu zdrojovou tvář, kterou použijete pro párování, a uložte její ID. Toto ID nechte oddělené od ostatních.

https://csdx.blob.core.windows.net/resources/Face/Images/findsimilar.jpg

Vyhledání shod

Zkopírujte následující příkaz do textového editoru.

curl -v -X POST "https://westus.api.cognitive.microsoft.com/face/v1.0/findsimilars" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {subscription key}" --data-ascii "{body}"

Pak proveďte následující změny:

1. Ocp-Apim-Subscription-KeyPřiřaďte platný klíč předplatného Pro tvář.
2. Změňte první část adresy URL dotazu tak, aby odpovídala koncovému bodu, který odpovídá vašemu klíči předplatného.

Jako hodnotu použijte následující obsah body JSON:

{
    "faceId": "",
    "faceIds": [],
    "maxNumOfCandidatesReturned": 10,
    "mode": "matchPerson"
}

1. Pro použijte ID zdrojové "faceId" tváře.
2. Ostatní ID tváří vložte jako termíny do "faceIds" pole.

Prozkoumání výsledků

Obdržíte odpověď JSON se seznamem ID tváří, které odpovídají vaší tváře dotazu.

[
    {
        "persistedFaceId" : "015839fb-fbd9-4f79-ace9-7675fc2f1dd9",
        "confidence" : 0.82
    },
    ...
] 

Vyčištění prostředků

Pokud chcete vyčistit a odebrat předplatné Cognitive Services, můžete odstranit prostředek nebo skupinu prostředků. Odstraněním skupiny prostředků se odstraní také všechny ostatní prostředky, které jsou k ní přidružené.

• Azure Portal
• Azure CLI

Další kroky

V tomto rychlém startu jste zjistili, jak pomocí rozhraní REST API provádět základní úlohy rozpoznávání tváře. Dále se seznámíte s různými modely detekce tváří a zjistíte, jak určit správný model pro váš případ použití.

• Co je služba Rozpoznávání tváře?