Snabbstart: Använda ansiktsklientbiblioteket

Kom igång med ansiktsigenkänning med hjälp av klientbiblioteket för ansiktsigenkänning för .NET. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Tjänsten Ansiktsigenkänning ger dig tillgång till avancerade algoritmer för att identifiera och identifiera ansikten i bilder.

Använd ansiktsklientbiblioteket för .NET för att:

• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Hitta liknande ansikten

Referensdokumentation | Bibliotekskällkod | Paket (NuGet) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Den Visual Studio IDE eller den aktuella versionen av .NET Core.
• Ditt Azure-konto måste ha en tilldelad Cognitive Services för att du ska kunna godkänna de ansvarsfulla AI-villkoren och skapa en resurs. Kontakta administratören för att få den här rollen tilldelad till ditt konto.
• När du har din Azure-prenumeration skapar du en ansiktsresurs i Azure Portal för att slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till ansikts-API:et. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt C#-program

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

Öppna filen program.cs från projektkatalogen och lägg till följande using -direktiv:

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;

I programmets Program-klass skapar du variabler för resursens nyckel och slutpunkt.

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

I programmets Main-metod lägger du till anrop för de metoder som används i den här snabbstarten. Du implementerar dessa senare.

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i .NET-klientbiblioteket för ansiktsdrag:

Kodexempel

Kodfragmenten nedan visar hur du utför följande uppgifter med ansiktsklientbiblioteket för .NET:

• Autentisera klienten
• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Hitta liknande ansikten

Autentisera klienten

I en ny metod instansierar du en klient med din slutpunkt och nyckel. Skapa ett ApiKeyServiceClientCredentials-objekt med din nyckel och använd det med slutpunkten för att skapa ett FaceClient-objekt.

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

Deklarera hjälpfält

Följande fält behövs för flera av ansiktsåtgärderna som du ska lägga till senare. Definiera följande URL-sträng i roten för klassen Program. Den här URL:en pekar på en mapp med exempelbilder.

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

I Main-metoden definierar du strängar som pekar på de olika typerna av igenkänningsmodeller. Senare kan du ange vilken igenkänningsmodell som du vill använda för ansiktsavkänning. Se Ange en igenkänningsmodell för information om dessa alternativ.

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

Identifiera och analysera ansikten

Ansiktsavkänning krävs som ett första steg i alla andra scenarier. Det här avsnittet visar hur du returnerar extra ansiktsattributdata. Om du bara vill identifiera ansikten för ansiktsidentifiering eller ansiktsverifiering går du vidare till de senare avsnitten.

Hämta identifierade ansiktsobjekt

Skapa en ny metod för att identifiera ansikten. Metoden DetectFaceExtract bearbetar tre av bilderna på den angivna URL:en och skapar en lista över DetectedFace-objekt i programminnet. Listan över FaceAttributeType-värden anger vilka funktioner som ska extraheras.

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

Visa identifierade ansiktsdata

Resten av metoden DetectFaceExtract parsar och skriver ut attributdata för varje identifierat ansikte. Varje attribut måste anges separat i det ursprungliga API-anropet för ansiktsigenkänning (i listan FaceAttributeType). Följande kod bearbetar alla attribut, men du behöver förmodligen bara använda ett eller några få.

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

Identifiera ett ansikte

Åtgärden Identifiera tar en bild av en person (eller flera personer) och letar efter det lagrade personobjektet som är associerat med varje ansikte i bilden (sökning efter ansiktsigenkänning). Den jämför varje identifierat ansikte med en PersonGroup, en databas med olika Person-objekt vars ansiktsdata är kända. För att kunna göra identifieringsåtgärden måste du först skapa och träna en PersonGroup

Skapa en PersonGroup

Följande kod skapar en PersonGroup med sex olika Person-objekt. Den associerar varje person med en uppsättning exempelbilder och tränar sedan att känna igen varje person med hjälp av deras ansiktsdrag. Person- och PersonGroup-objekt används i åtgärderna Verifiera, Identifiera och Grupp.

Deklarera en strängvariabel i roten för klassen för att representera ID:t för den PersonGroup som du skapar.

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

Lägg till följande kod i en ny metod. Den här metoden utför åtgärden Identifiera. Det första kodblocket associerar namnen på personer med deras exempelbilder.

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

Observera att den här koden definierar variabeln sourceImageFileName . Den här variabeln motsvarar källbilden — som bilden innehåller personer att identifiera.

Lägg sedan till följande kod för att skapa ett Person-objekt för varje person i ordlistan och lägg till ansiktsdata från lämpliga bilder. Varje Person-objekt associeras med samma PersonGroup via dess unika ID-sträng. Kom ihåg att skicka client variablerna , url och till den RECOGNITION_MODEL1 här metoden.

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

Träna PersonGroup

När du har extraherat ansiktsdata från dina bilder och sorterat dem till olika Person-objekt måste du träna PersonGroup att identifiera de visuella funktioner som är associerade med vart och ett av dess Person-objekt. Följande kod anropar den asynkrona metoden train och avsöker resultaten och skriver ut statusen till konsolen.

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

Den här gruppen Person och dess associerade Person-objekt är nu redo att användas i åtgärderna Verifiera, Identifiera eller Grupp.

Identifiera ansikten

Följande kod tar källbilden och skapar en lista över alla ansikten som identifierats i bilden. Det här är de ansikten som identifieras mot PersonGroup.

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

Nästa kodfragment anropar åtgärden IdentifyAsync och skriver ut resultatet till konsolen. Här försöker tjänsten matcha varje ansikte från källbilden med en Person i den angivna PersonGroup. Då stängs metoden Identifiera.

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

Hitta liknande ansikten

Följande kod tar ett enda identifierat ansikte (källa) och söker igenom en uppsättning andra ansikten (mål) för att hitta matchningar (ansiktssökning efter bild). När den hittar en matchning skrivs ID:t för det matchade ansiktet ut till konsolen.

Identifiera ansikten för jämförelse

Definiera först en andra metod för ansiktsavkänning. Du måste identifiera ansikten i bilder innan du kan jämföra dem, och den här identifieringsmetoden är optimerad för jämförelseåtgärder. Den extraherar inte detaljerade ansiktsattribut som i avsnittet ovan och använder en annan igenkänningsmodell.

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

Hitta matchningar

Följande metod identifierar ansikten i en uppsättning målbilder och i en enda källbild. Sedan jämförs de och hittar alla målbilder som liknar källavbildningen.

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

Utskriftsmatchning

Följande kod skriver ut matchningsinformationen till konsolen:

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

Kör programmet

dotnet run

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Om du har skapat en PersonGroup i den här snabbstarten och vill ta bort den kör du följande kod i programmet:

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

Definiera borttagningsmetoden med följande kod:

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

Nästa steg

I den här snabbstarten har du lärt dig hur du använder klientbiblioteket för ansiktsigenkänning för .NET för att utföra grundläggande uppgifter för ansiktsigenkänning. Härnäst får du lära dig mer om de olika ansiktsavkänningsmodellerna och hur du anger rätt modell för ditt användningsfall.

• Vad är tjänsten Ansiktsigenkänning?
• Källkoden för det här exemplet finns på GitHub.

Kom igång med ansiktsigenkänning med hjälp av ansiktsklientbiblioteket för Go. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Tjänsten Ansiktsigenkänning ger dig tillgång till avancerade algoritmer för identifiering och igenkänning av ansikten i bilder.

Använd ansiktstjänstens klientbibliotek för Go till:

• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Verifiera ansikten
• Hitta liknande ansikten

Referensdokumentation | Bibliotekskällkod | SDK-nedladdning

Förutsättningar

• Den senaste versionen av Go
• Azure-prenumeration – Skapa en utan kostnad
• Ditt Azure-konto måste ha en tilldelad Cognitive Services för att du ska kunna godkänna de ansvarsfulla AI-villkoren och skapa en resurs. Kontakta administratören för att få den här rollen tilldelad till ditt konto.
• När du har din Azure-prenumeration skapar du en ansiktsresurs i Azure Portal för slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från resursen som du skapar för att ansluta ditt program till ansikts-API:et. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.
• När du har fått en nyckel och slutpunkt skapar du miljövariabler för nyckeln och slutpunkten med namnet respektive FACE_SUBSCRIPTION_KEY FACE_ENDPOINT .

Inrätta

Skapa en Go-projektkatalog

I ett konsolfönster (cmd, PowerShell, Terminal, Bash) skapar du en ny arbetsyta för Go-projektet med namnet my-app och navigerar till den.

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

Arbetsytan innehåller tre mappar:

• src – Den här katalogen innehåller källkod och paket. Alla paket som installeras go get med kommandot finns i den här mappen.
• pkg – den här katalogen innehåller de kompilerade Go-paketobjekten. Alla dessa filer har ett .a tillägg.
• bin – Den här katalogen innehåller de binära körbara filer som skapas när du kör go install .

Installera klientbiblioteket för Go

Installera sedan klientbiblioteket för Go:

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

eller i din lagringsplatskörning om du använder dep:

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

Skapa ett Go-program

Skapa sedan en fil i katalogen src med namnet sample-app.go :

cd src
touch sample-app.go

Öppna sample-app.go i önskad IDE eller textredigerare. Lägg sedan till paketnamnet och importera följande bibliotek:

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

Nu ska du börja lägga till kod för att utföra olika ansiktstjänståtgärder.

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Ansiktstjänstens Go-klientbibliotek.

Kodexempel

Dessa kodexempel visar hur du utför grundläggande uppgifter med hjälp av ansiktstjänstens klientbibliotek för Go:

• Autentisera klienten
• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Verifiera ansikten
• Hitta liknande ansikten

Autentisera klienten

Skapa en huvudfunktion och lägg till följande kod i den för att instansiera en klient med din slutpunkt och nyckel. Du skapar ett CognitiveServicesAuthorizer-objekt med din nyckel och använder det med slutpunkten för att skapa ett Client-objekt. Den här koden instansierar också ett kontextobjekt som behövs för att skapa klientobjekt. Den definierar också en fjärrplats där några av exempelbilderna i den här snabbstarten hittas.

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

Identifiera och analysera ansikten

Ansiktsavkänning krävs som ett första steg i Ansiktsanalys och Identitetsverifiering. Det här avsnittet visar hur du returnerar extra ansiktsattributdata. Om du bara vill identifiera ansikten för ansiktsidentifiering eller ansiktsverifiering går du vidare till de senare avsnitten.

Lägg till följande kod i main-metoden. Den här koden definierar en fjärrexempelbild och anger vilka ansiktsfunktioner som ska extraheras från bilden. Den anger också vilken AI-modell som ska användas för att extrahera data från de identifierade ansiktena. Se Ange en igenkänningsmodell för information om dessa alternativ. Slutligen gör metoden DetectWithURL ansiktsavkänningen på bilden och sparar resultatet i programminnet.

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

Visa identifierade ansiktsdata

Nästa kodblock tar det första elementet i matrisen med DetectedFace-objekt och skriver ut dess attribut till konsolen. Om du använde en bild med flera ansikten bör du iterera genom matrisen i stället.

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) + ")")

Identifiera ett ansikte

Åtgärden Identifiera tar en bild av en person (eller flera personer) och letar efter identiteten för varje ansikte i bilden (sökning efter ansiktsigenkänning). Den jämför varje identifierat ansikte med en PersonGroup, en databas med olika Person-objekt vars ansiktsdrag är kända.

Hämta personbilder

Om du vill gå igenom det här scenariot måste du spara följande avbildningar i rotkatalogen för projektet: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

Den här gruppen med bilder innehåller tre uppsättningar bilder med ett enda ansikte som motsvarar tre olika personer. Koden definierar tre PersonGroup Person-objekt och associerar dem med bildfiler som börjar woman med , och man child .

Skapa en PersonGroup

När du har laddat ned bilderna lägger du till följande kod längst ned i huvudmetoden. Den här koden autentiserar ett PersonGroupClient-objekt och använder det sedan för att definiera en ny PersonGroup.

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

Skapa PersonGroup Persons

Nästa kodblock autentiserar en PersonGroupPersonClient och använder den för att definiera tre nya PersonGroup Person-objekt. Vart och ett av dessa objekt representerar en enda person i uppsättningen bilder.

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

Tilldela ansikten till personer

Följande kod sorterar bilderna efter prefix, identifierar ansikten och tilldelar ansikten till varje respektive PersonGroup Person-objekt, baserat på bildens filnamn.

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

Träna PersonGroup

När du har tilldelat ansikten tränar du PersonGroup så att den kan identifiera de visuella funktioner som är associerade med vart och ett av dess Person-objekt. Följande kod anropar den asynkrona metoden train och avsöker resultatet och skriver ut statusen till konsolen.

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

Hämta en testbild

Följande kod söker i roten av ditt projekt efter en bildtest-image-person-group.jpg läser in den i programminnet. Du hittar den här avbildningen på samma lagringsplatsen som de avbildningar som användes för att skapa PersonGroup: 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) }

Identifiera källytor i testbild

Nästa kodblock gör vanlig ansiktsavkänning på testbilden för att hämta alla ansikten och spara dem i en matris.

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

Identifiera ansikten från källbilden

Metoden Identifiera tar matrisen med identifierade ansikten och jämför dem med den angivna PersonGroup (definierade och tränade i det tidigare avsnittet). Om det kan matcha ett identifierat ansikte med en Person i gruppen sparas resultatet.

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

Den här koden skriver sedan ut detaljerade matchningsresultat till konsolen.

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

Verifiera ansikten

Åtgärden Verifiera tar ett ansikts-ID och antingen ett annat ansikts-ID eller ett Person-objekt och avgör om de tillhör samma person. Verifiering kan användas för att dubbelkontrollera ansiktsmatchningen som returneras av åtgärden Identifiera.

Följande kod identifierar ansikten i två källbilder och verifierar sedan var och en av dem mot ett ansikte som identifierats från en målbild.

Hämta testbilder

Följande kod blockerar deklarerar variabler som pekar på mål- och källbilderna för verifieringsåtgärden.

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

Identifiera ansikten för verifiering

Följande kod identifierar ansikten i käll- och målbilderna och sparar dem i variabler.

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

Hämta verifieringsresultat

Följande kod jämför var och en av källbilderna med målbilden och skriver ut ett meddelande som anger om de tillhör samma person.

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

Hitta liknande ansikten

Följande kod tar ett enda identifierat ansikte (källa) och söker igenom en uppsättning andra ansikten (mål) för att hitta matchningar (ansiktssökning efter bild). När den hittar en matchning skriver den ut ID:t för det matchade ansiktet till konsolen.

Identifiera ansikten för jämförelse

Spara först en referens till det ansikte som du identifierade i avsnittet Identifiera och analysera. Det här ansiktet är källan.

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

Ange sedan följande kod för att identifiera en uppsättning ansikten i en annan bild. Dessa ansikten är målet.

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

Hitta matchningar

I följande kod används metoden FindSimilar för att hitta alla mål ansikten som matchar källans ansikte.

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

Utskriftsmatchning

Följande kod skriver ut matchningsinformationen till konsolen.

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

Kör programmet

Kör din ansiktsigenkänningsapp från programkatalogen med go run <app-name> kommandot .

go run sample-app.go

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Om du har skapat en PersonGroup i den här snabbstarten och vill ta bort den anropar du delete-metoden.

Nästa steg

I den här snabbstarten har du lärt dig hur du använder ansiktsigenkänningsklientbiblioteket för Go för att utföra uppgifter för ansiktsigenkänning. Lär dig sedan om de olika ansiktsavkänningsmodellerna och hur du anger rätt modell för ditt användningsfall.

• Vad är tjänsten Ansiktsigenkänning?
• Källkoden för det här exemplet finns på GitHub.

Snabbstart: Ansiktsklientbibliotek för JavaScript

Kom igång med ansiktsigenkänning med hjälp av ansiktsklientbiblioteket för JavaScript. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Tjänsten Ansiktsigenkänning ger dig tillgång till avancerade algoritmer för att identifiera och identifiera ansikten i bilder.

Använd ansiktsklientbiblioteket för JavaScript för att:

• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Hitta liknande ansikten

Referensdokumentation | Bibliotekskällkod | Paket (npm) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Den senaste versionen av Node.js
• Ditt Azure-konto måste ha en tilldelad Cognitive Services för att du ska kunna godkänna de ansvarsfulla AI-villkoren och skapa en resurs. Kontakta administratören för att få den här rollen tilldelad till ditt konto.
• När du har din Azure-prenumeration skapar du en ansiktsresurs i Azure Portal för att hämta din nyckel och slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till ansikts-API:et. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Skapa ett nytt Node.js-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) skapar du en ny katalog för din app och navigerar till den.

mkdir myapp && cd myapp

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

npm init

Installera klientbiblioteket

Installera ms-rest-azure azure-cognitiveservices-face NPM-paketen och :

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

Appens package.json fil uppdateras med beroendena.

Skapa en fil med index.js namnet och importera följande bibliotek:

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

Skapa variabler för resursens Azure-slutpunkt och nyckel.

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i .NET-klientbiblioteket för ansiktsdrag:

Kodexempel

Kodfragmenten nedan visar hur du utför följande uppgifter med ansiktsklientbiblioteket för .NET:

• Autentisera klienten
• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Hitta liknande ansikten

Autentisera klienten

Instansiera en klient med din slutpunkt och nyckel. Skapa ett ApiKeyCredentials-objekt med din nyckel och använd det med slutpunkten för att skapa ett FaceClient-objekt.

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

Deklarera globala värden och hjälpfunktion

Följande globala värden behövs för flera av ansiktsåtgärderna som du ska lägga till senare.

URL:en pekar på en mapp med exempelbilder. UUID fungerar som både namn och ID för den PersonGroup som du skapar.

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

Du använder följande funktion för att vänta tills träningen av PersonGroup har slutförts.

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

Identifiera och analysera ansikten

Ansiktsavkänning krävs som ett första steg i Ansiktsanalys och Identitetsverifiering. Det här avsnittet visar hur du returnerar extra ansiktsattributdata. Om du bara vill identifiera ansikten för ansiktsidentifiering eller ansiktsverifiering går du vidare till de senare avsnitten.

Hämta identifierade ansiktsobjekt

Skapa en ny metod för att identifiera ansikten. Metoden DetectFaceExtract bearbetar tre av bilderna på den angivna URL:en och skapar en lista över DetectedFace-objekt i programminnet. Listan över FaceAttributeType-värden anger vilka funktioner som ska extraheras.

Metoden DetectFaceExtract parsar sedan och skriver ut attributdata för varje identifierat ansikte. Varje attribut måste anges separat i det ursprungliga API-anropet för ansiktsigenkänning (i listan FaceAttributeType). Följande kod bearbetar alla attribut, men du behöver förmodligen bara använda ett eller några få.

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

Identifiera ett ansikte

Åtgärden Identifiera tar en bild av en person (eller flera personer) och letar efter det lagrade personobjektet som är associerat med varje ansikte i bilden (sökning efter ansiktsigenkänning). Den jämför varje identifierat ansikte med en PersonGroup, en databas med olika personobjekt vars ansiktsdrag är kända. För att kunna göra identifieringsåtgärden måste du först skapa och träna en PersonGroup.

Lägga till ansikten i PersonGroup

Skapa följande funktion för att lägga till ansikten i 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.");
}

Vänta på träning av PersonGroup

Skapa följande hjälpfunktion för att vänta tills PersonGroup har avslutat träningen.

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

Skapa en PersonGroup

Följande kod:

• Skapar en PersonGroup
• Lägger till ansikten i PersonGroup genom att anropa AddFacesToPersonGroup , som du definierade tidigare.
• Tränar PersonGroup.
• Identifierar ansiktena i PersonGroup.

Den här PersonGroup och dess associerade Person-objekt är nu redo att användas i åtgärderna Verifiera, Identifiera eller Grupp.

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

Hitta liknande ansikten

Följande kod tar ett enda identifierat ansikte (källa) och söker igenom en uppsättning andra ansikten (mål) för att hitta matchningar (ansiktssökning efter bild). När den hittar en matchning skrivs ID:t för det matchade ansiktet ut till konsolen.

Identifiera ansikten för jämförelse

Definiera först en andra metod för ansiktsavkänning. Du måste identifiera ansikten i bilder innan du kan jämföra dem, och den här identifieringsmetoden är optimerad för jämförelseåtgärder. Den extraherar inte detaljerade ansiktsattribut som i avsnittet ovan och använder en annan igenkänningsmodell.

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

Hitta matchningar

Följande metod identifierar ansikten i en uppsättning målbilder och i en enda källbild. Sedan jämförs de och hittar alla målbilder som liknar källavbildningen. Slutligen skrivs matchningsinformationen ut till konsolen.

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

Main

Skapa slutligen funktionen main och anropa den.

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

Kör programmet

Kör programmet med kommandot node i snabbstartsfilen.

node index.js

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du använder klientbiblioteket för ansiktsigenkänning för JavaScript för att utföra uppgifter för ansiktsigenkänning. Härnäst får du lära dig mer om de olika ansiktsavkänningsmodellerna och hur du anger rätt modell för ditt användningsfall.

• Vad är tjänsten Ansiktsigenkänning?
• Källkoden för det här exemplet finns på GitHub.

Kom igång med ansiktsigenkänning med hjälp av klientbiblioteket för ansiktsigenkänning för Python. Följ de här stegen för att installera paketet och prova exempelkoden för grundläggande uppgifter. Tjänsten Ansiktsigenkänning ger dig tillgång till avancerade algoritmer för att identifiera och identifiera ansikten i bilder.

Använd ansiktsklientbiblioteket för Python för att:

• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Verifiera ansikten
• Hitta liknande ansikten

Referensdokumentation | Bibliotekskällkod | Paket (PiPy) | Exempel

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt
• Python 3.x
  • Python-installationen bör innehålla pip. Du kan kontrollera om pip har installerats genom pip --version att köra på kommandoraden. Hämta pip genom att installera den senaste versionen av Python.
• Ditt Azure-konto måste ha en tilldelad Cognitive Services för att du ska kunna godkänna de ansvarsfulla AI-villkoren och skapa en resurs. Kontakta administratören för att få den här rollen tilldelad till ditt konto.
• När du har din Azure-prenumeration skapar du en ansiktsresurs i Azure Portal för att slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till ansikts-API:et. Du klistrar in din nyckel och slutpunkt i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

Inrätta

Installera klientbiblioteket

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

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

Skapa ett nytt Python-program

Skapa till exempel ett — quickstart-file.py Python-skript. Öppna den sedan i önskad redigerare eller IDE och importera följande bibliotek.

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

Skapa sedan variabler för resursens Azure-slutpunkt och nyckel.

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

Objektmodell

Följande klasser och gränssnitt hanterar några av de viktigaste funktionerna i Python-klientbiblioteket för ansiktsdrag.

Kodexempel

De här kodfragmenten visar hur du utför följande uppgifter med ansiktsklientbiblioteket för Python:

• Autentisera klienten
• Identifiera och analysera ansikten
• Identifiera ett ansikte
• Verifiera ansikten
• Hitta liknande ansikten

Autentisera klienten

Instansiera en klient med din slutpunkt och nyckel. Skapa ett CognitiveServicesCredentials-objekt med din nyckel och använd det med slutpunkten för att skapa ett FaceClient-objekt.

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

Identifiera och analysera ansikten

Ansiktsavkänning krävs i Ansiktsanalys och Identitetsverifiering. Det här avsnittet visar hur du returnerar extra ansiktsattributdata. Om du bara vill identifiera ansikten för ansiktsidentifiering eller ansiktsverifiering går du vidare till de senare avsnitten.

Följande kod identifierar ett ansikte i en fjärrbild. Det identifierade ansiktets ID skrivs ut till konsolen och lagras även i programminnet. Sedan identifierar den ansiktena i en bild med flera personer och skriver ut sina-ID:n till konsolen också. Genom att ändra parametrarna i detect_with_url kan du returnera olika information med varje DetectedFace-objekt.

# 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

Visa och rama in ansikten

Följande kod matar ut den angivna bilden till visningen och ritar rektanglar runt ansiktena med hjälp av egenskapen DetectedFace.faceRectangle.

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

Identifiera ett ansikte

Åtgärden Identifiera tar en bild av en person (eller flera personer) och letar efter identiteten för varje ansikte i bilden (sökning efter ansiktsigenkänning). Den jämför varje identifierat ansikte med en PersonGroup, en databas med olika personobjekt vars ansiktsdrag är kända.

Skapa en PersonGroup

Följande kod skapar en PersonGroup med tre olika Person-objekt. Den associerar varje person med en uppsättning exempelbilder och tränar sedan för att kunna identifiera varje person.

Om du vill gå igenom det här scenariot måste du spara följande avbildningar i projektets rotkatalog: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

Den här gruppen med bilder innehåller tre uppsättningar ansiktsbilder som motsvarar tre olika personer. Koden definierar tre Person-objekt och associerar dem med bildfiler som börjar med woman , och man child .

När du har ställt in dina bilder definierar du en etikett överst i skriptet för det PersonGroup-objekt som du ska skapa.

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

Lägg sedan till följande kod längst ned i skriptet. Den här koden skapar en PersonGroup och tre Person-objekt.

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

Tilldela ansikten till personer

Följande kod sorterar dina bilder efter deras prefix, identifierar ansikten och tilldelar ansikten till varje Person-objekt.

'''
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äna PersonGroup

När du har tilldelat ansikten måste du träna PersonGroup så att den kan identifiera de visuella funktioner som är associerade med vart och ett av dess Person-objekt. Följande kod anropar den asynkrona metoden train och avsöker resultatet och skriver ut statusen till konsolen.

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

Hämta en testbild

Följande kod söker i roten av projektet efter en bildtest-image-person-group.jpg identifierar ansiktena i bilden. Du hittar den här avbildningen med de avbildningar som används för PersonGroup-hantering: 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)

Utdata identifierade ansikts-ID:er

Identifieringsmetoden tar en matris med identifierade ansikten och jämför dem med en PersonGroup. Om det kan matcha ett identifierat ansikte med en Person sparas resultatet. Den här koden skriver ut detaljerade matchningsresultat till konsolen.

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

Verifiera ansikten

Åtgärden Verifiera tar ett ansikts-ID och antingen ett annat ansikts-ID eller ett Person-objekt och avgör om de tillhör samma person. Verifiering kan användas för att dubbelkontrollera ansiktsmatchningen som returneras av åtgärden Identifiera.

Följande kod identifierar ansikten i två källbilder och verifierar dem sedan mot ett ansikte som identifierats från en målbild.

Hämta testbilder

Följande kod blockerar deklarera variabler som pekar på käll- och målbilderna för verifieringsåtgärden.

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

Identifiera ansikten för verifiering

Följande kod identifierar ansikten i käll- och målbilderna och sparar dem i variabler.

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

Hämta verifieringsresultat

Följande kod jämför var och en av källbilderna med målbilden och skriver ut ett meddelande som anger om de tillhör samma person.

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

Hitta liknande ansikten

Följande kod tar ett enda identifierat ansikte (källa) och söker igenom en uppsättning andra ansikten (mål) för att hitta matchningar (ansiktssökning efter bild). När den hittar en matchning skriver den ut ID:t för det matchade ansiktet till konsolen.

Hitta matchningar

Kör först koden i avsnittet ovan ( Identifiera och analyseraansikten) för att spara en referens till ett enda ansikte. Kör sedan följande kod för att hämta referenser till flera ansikten i en gruppbild.

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

Lägg sedan till följande kodblock för att hitta instanser av det första ansiktet i gruppen. Se find_similar för att lära dig hur du ändrar det här beteendet.

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

Utskriftsmatchning

Använd följande kod för att skriva ut matchningsinformationen till konsolen.

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

Kör programmet

Kör din ansiktsigenkänningsapp från programkatalogen med python kommandot .

python quickstart-file.py

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Om du har skapat en PersonGroup i den här snabbstarten och vill ta bort den kör du följande kod i skriptet:

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

Nästa steg

I den här snabbstarten har du lärt dig hur du använder klientbiblioteket för ansiktsigenkänning för Python för att utföra uppgifter för ansiktsigenkänning. Lär dig sedan om de olika ansiktsavkänningsmodellerna och hur du anger rätt modell för ditt användningsfall.

• Vad är tjänsten Ansiktsigenkänning?
• Källkoden för det här exemplet finns på GitHub.

Kom igång med ansiktsigenkänning med hjälp av REST API. Tjänsten Ansiktsigenkänning ger dig tillgång till avancerade algoritmer för identifiering och igenkänning av ansikten i bilder.

Använd ansikts-REST API för att:

• Identifiera och analysera ansikten
• Hitta liknande ansikten

Förutsättningar

• Azure-prenumeration – Skapa en utan kostnad
• Ditt Azure-konto måste ha en tilldelad Cognitive Services för att du ska kunna godkänna de ansvarsfulla AI-villkoren och skapa en resurs. Kontakta administratören för att få den här rollen tilldelad till ditt konto.
• När du har din Azure-prenumeration skapar du en ansiktsresurs i Azure Portal för slutpunkt. När den har distribuerats klickar du på Gå till resurs.
  • Du behöver nyckeln och slutpunkten från resursen du skapar för att ansluta ditt program till ansikts-API:et. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten.
  • Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och uppgradera senare till en betald nivå för produktion.
• PowerShell version 6.0+eller ett liknande kommandoradsprogram.

Identifiera och analysera ansikten

Du använder ett kommando som följande för att anropa ansikts-API:et och hämta ansiktsattributdata från en bild. Kopiera först koden till ett redigeringsprogram—du måste göra ändringar av vissa delar av kommandot innan du kan köra den.

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

Gör följande ändringar:

1. Tilldela Ocp-Apim-Subscription-Key till din giltiga ansiktsprenumerationsnyckel.
2. Ändra den första delen av fråge-URL:en så att den matchar den slutpunkt som motsvarar din prenumerationsnyckel.

   Anteckning

   Nya resurser som skapats efter den 1 juli 2019 kommer att använda anpassade under domän namn. Mer information och en fullständig lista över regionala slut punkter finns i anpassade under domän namn för Cognitive Services.

3. Du kan också ändra URL:en i brödtexten i begäran så att den pekar på en annan bild.

När du har gjort dina ändringar öppnar du en kommandotolk och anger det nya kommandot.

Granska resultaten

Du bör se ansiktsinformationen som visas som JSON-data i konsolfönstret. Exempel:

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

Hämta ansiktsattribut

Om du vill extrahera ansiktsattribut anropar du IDENTIFIERINGs-API:et igen, men anger detectionModel till detection_01 . Lägg även returnFaceAttributes till frågeparametern. Kommandot bör nu se ut så här. Som tidigare infogar du ansiktsprenumerationens nyckel och slutpunkt.

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

Granska resultaten

Den returnerade ansiktsinformationen innehåller nu ansiktsattribut. Exempel:

[
  {
    "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
          }
        ]
      }
    }
  }
]

Hitta liknande ansikten

Den här åtgärden tar ett enda identifierat ansikte (källa) och söker igenom en uppsättning andra ansikten (mål) för att hitta matchningar (ansiktssökning efter bild). När den hittar en matchning skrivs ID:t för det matchade ansiktet ut till konsolen.

Identifiera ansikten för jämförelse

Först måste du identifiera ansikten i bilder innan du kan jämföra dem. Kör det här kommandot som du gjorde i avsnittet Identifiera och analysera. Den här identifieringsmetoden är optimerad för jämförelseåtgärder. Den extraherar inte detaljerade ansiktsattribut som i avsnittet ovan och använder en annan identifieringsmodell.

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

Hitta värdet "faceId" i JSON-svaret och spara det på en tillfällig plats. Anropa sedan kommandot ovan igen för dessa andra bild-URL:er och spara även deras ansikts-ID:n. Du använder dessa ID:er som målgrupp för ansikten som du vill hitta ett liknande ansikte från.

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

Identifiera slutligen det enda käll-ansikte som du ska använda för matchning och spara dess ID. Håll det här ID:t separat från de andra.

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

Hitta matchningar

Kopiera följande kommando till en textredigerare.

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

Gör sedan följande ändringar:

1. Tilldela Ocp-Apim-Subscription-Key till din giltiga ansiktsprenumerationsnyckel.
2. Ändra den första delen av fråge-URL:en så att den matchar den slutpunkt som motsvarar din prenumerationsnyckel.

Använd följande JSON-innehåll för body värdet:

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

1. Använd källans ansikts-ID för "faceId" .
2. Klistra in de andra ansikts-ID:erna som termer i "faceIds" matrisen.

Granska resultaten

Du får ett JSON-svar som visar en lista över de ansikten som matchar ditt frågeuttryck.

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

Rensa resurser

Om du vill rensa och ta bort en Cognitive Services prenumeration kan du ta bort resursen eller resursgruppen. När du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

• Portal
• Azure CLI

Nästa steg

I den här snabbstarten har du lärt dig hur du använder REST API för att utföra grundläggande uppgifter för ansiktsigenkänning. Härnäst får du lära dig mer om de olika ansiktsavkänningsmodellerna och hur du anger rätt modell för ditt användningsfall.

• Vad är tjänsten Ansiktsigenkänning?