Hızlı başlangıç: yüz istemci kitaplığını kullanma

Kullanmaya başlayın .NET için Yüz Tanıma istemci kitaplığını kullanarak yüz tanıma ile bağlantı. Paketi yüklemek ve temel görevler için örnek kodu denemek için bu adımları izleyin. Yüz Tanıma hizmeti, görüntülerde insan yüzlerini algılamak ve tanımak için gelişmiş algoritmalara erişmeniz için size erişim sağlar.

.NET için Yüz Yüze istemci kitaplığını kullanarak şunları yapmak için:

• Yüzleri algılama ve analiz etme
• Bir yüzü tanımlama
• Benzer yüzleri bulma

Başvuru belgeleri | Kitaplık kaynak kodu | Paket (NuGet) | Örnekler

Önkoşullar

• Azure aboneliği - Ücretsiz bir abonelik oluşturun
• Visual Studio IDE veya .NET Core'un geçerli sürümü.
• Sorumlu AI koşullarını kabul etmek ve kaynak oluşturmak için Azure hesabınıza bir Bilişsel Hizmetler Katkıda Bulunanı rolü atanmış olması gerekir. Bu rolü hesabınıza ataması için yöneticinize başvurun.
• Azure aboneliğinize sahip olduktan sonra, Anahtarınızı ve uç noktanızı almak için Yüz Azure portal kaynağı oluşturun. Dağıtımdan sonra Kaynağa git'e tıklayın.
  • Uygulamanıza Yüz Tanıma API'sini bağlamak için, oluşturmakta olduğu kaynakta yer alan anahtara ve uç noktaya ihtiyacınız vardır. Hızlı başlangıçta anahtarınızı ve uç noktanızı aşağıdaki koda yapıştırabilirsiniz.
  • Hizmeti denemek ve daha sonra üretim için ücretli bir katmana yükseltmek üzere ücretsiz fiyatlandırma katmanını ( F0 ) kullanabilirsiniz.

Ayarlama

Yeni bir C# uygulaması oluşturma

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

Proje dizininden program.cs dosyasını açın ve aşağıdaki using yönergeleri ekleyin:

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;

Uygulamanın Program sınıfında, kaynağınız anahtarı ve uç noktası için değişkenler oluşturun.

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

Uygulamanın Main yönteminde, bu hızlı başlangıçta kullanılan yöntemler için çağrılar ekleyin. Bunları daha sonra uygulayacağız.

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

Nesne modeli

Aşağıdaki sınıflar ve arabirimler Face .NET istemci kitaplığının bazı önemli özelliklerini işlemektedir:

Kod örnekleri

Aşağıdaki kod parçacıklarında .NET için Yüz Yüz İstemci kitaplığıyla aşağıdaki görevlerin nasıl gerçekleştirebilirsiniz:

• İstemcinin kimliğini doğrulama
• Yüzleri algılama ve analiz etme
• Bir yüzü tanımlama
• Benzer yüzleri bulma

İstemcinin kimliğini doğrulama

Yeni bir yöntemde, uç noktanız ve anahtarınız ile bir istemci örneği. Anahtarınız ile bir ApiKeyServiceClientCredentials nesnesi oluşturun ve bunu uç noktanız ile birlikte kullanarak bir FaceClient nesnesi oluşturun.

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

Yardımcı alanları bildir

Aşağıdaki alanlar, daha sonra ekleyeceğimiz birkaç Yüz Yüze işlem için gereklidir. Program sınıfnizin kökünde aşağıdaki URL dizesini tanımlayın. Bu URL, örnek görüntülerin bir klasörünü gösterir.

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

Main yönteminde, farklı tanıma modeli türlerini işaret etmek için dizeleri tanımlayın. Daha sonra, yüz algılama için kullanmak istediğiniz tanıma modelini belirtebilirsiniz. Bu seçenekler hakkında bilgi için bkz. Tanıma modeli belirtme.

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

Yüzleri algılama ve analiz etme

Yüz algılama, diğer tüm senaryolarda ilk adım olarak gereklidir. Bu bölümde, ek yüz özniteliği verilerini nasıl geri getiryebilirsiniz? Yüzleri yalnızca yüz tanımlama veya doğrulama için algılamak için sonraki bölümlere atlayabilirsiniz.

Algılanan yüz nesnelerini al

Yüzleri algılamak için yeni bir yöntem oluşturun. yöntemi, DetectFaceExtract belirtilen URL'de yer alan üç resmi işler ve program belleğinde DetectedFace nesnelerinin bir listesini oluşturur. FaceAttributeType değerlerinin listesi, ayıklanacak özellikleri belirtir.

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

Algılanan yüz verilerini görüntüleme

Yöntemin geri DetectFaceExtract kalanı algılanan her yüz için öznitelik verilerini ayrıştırır ve yazdırır. Her öznitelik, özgün yüz algılama API'si çağrısında (FaceAttributeType listesinde) ayrı ayrı belirtilmelidir. Aşağıdaki kod her özniteliği işlemektedir, ancak büyük olasılıkla yalnızca bir veya birkaç tane kullanacağız.

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

Bir yüzü tanımlama

Identify işlemi bir kişinin (veya birden çok kişinin) görüntüsünü alır ve görüntüde her bir yüzle ilişkili depolanan kişi nesnesini (yüz tanıma araması) bulmak için arama eder. Algılanan her yüzü, yüz verileri bilinen farklı Kişi nesnelerinden bir veritabanı olan PersonGroup ile karşılar. Identify işlemi yapmak için öncelikle bir PersonGroup oluşturmanız ve eğitip eğitin

PersonGroup oluşturma

Aşağıdaki kod, altı farklı Person nesnesine sahip bir PersonGroup oluşturur. Her kişiyi bir örnek görüntü kümesiyle ilişkilendirir ve sonra her kişiyi yüz özellikleriyle tanıyacak şekilde algılar. Person ve Persongroup nesneleri, Verify, tanımla ve Gruplandır işlemlerinde kullanılır.

Oluşturduğunuz Persongroup 'un kimliğini temsil etmek için sınıfınızın kökünde bir dize değişkeni bildirin.

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

Yeni bir yöntemde aşağıdaki kodu ekleyin. Bu yöntem, tanımla işlemini çalıştırır. İlk kod bloğu, kişilerin adlarını örnek görüntülerle ilişkilendirir.

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

Bu kodun bir değişken tanımladığına dikkat edin sourceImageFileName . Bu değişken, — tanımlamak üzere kişileri içeren görüntünün kaynak görüntüsüne karşılık gelir.

Sonra, Sözlükteki her kişi için bir kişi nesnesi oluşturmak ve uygun görüntülerden yüz verilerini eklemek için aşağıdaki kodu ekleyin. Her kişi nesnesi, benzersiz kimlik dizesi aracılığıyla aynı persongroup ile ilişkilendirilir. , client url Ve değişkenlerini RECOGNITION_MODEL1 Bu yönteme geçirmeye unutmayın.

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

PersonGroup 'ı eğitme

Görüntülerinizden yüz verilerini ayıkladıktan ve farklı kişi nesnelerine sıraladıktan sonra, kişi nesnelerinden her biriyle ilişkili görsel özellikleri belirlemek için persongroup 'u eğitmeniz gerekir. Aşağıdaki kod, zaman uyumsuz eğitme yöntemini çağırır ve sonuçları, durumu konsola yazdırarak tarar.

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

Bu kişi grubu ve ilişkili kişi nesneleri artık doğrulama, tanımla veya grupla işlemlerinde kullanılmak üzere hazırdır.

Yüzleri belirleme

Aşağıdaki kod, kaynak görüntüyü alır ve görüntüde algılanan tüm yüzlerin bir listesini oluşturur. Bunlar, Persongroup ile ilgili olarak tanımlanabilecek yüzlerdir.

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

Sonraki kod parçacığı, ıdentıyasync işlemini çağırır ve sonuçları konsola yazdırır. Burada hizmet, kaynak görüntüdeki her yüzü, belirtilen Person grubundaki bir kişiye eşleştirmeye çalışır. Bu, tanımlana yöntemini kapatır.

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

Benzer yüzleri bulma

Aşağıdaki kod, algılanan tek bir yüzeyi (kaynak) alır ve eşleşmeleri (yüz görüntüye göre arama) bulmak için bir dizi diğer yüzeyi (hedef) arar. Bir eşleşme bulduğunda, eşleşen yüzün KIMLIĞINI konsola yazdırır.

Karşılaştırılacak Yüzleri Algıla

İlk olarak, ikinci bir yüz algılama yöntemi tanımlayın. Bunları karşılaştırabilmeniz için görüntülerdeki yüzeyleri saptamanız gerekir ve bu algılama yöntemi karşılaştırma işlemleri için iyileştirilmiştir. Yukarıdaki bölümde olduğu gibi ayrıntılı yüz özniteliklerini ayıklamaz ve farklı bir tanıma modeli kullanır.

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

Eşleşmeleri bul

Aşağıdaki yöntem, bir hedef görüntüler kümesindeki yüzeyleri ve tek bir kaynak görüntüyü algılar. Ardından, bunları karşılaştırır ve kaynak görüntüye benzer tüm hedef görüntüleri bulur.

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

Yazdırma eşleşmeleri

Aşağıdaki kod, eşleşme ayrıntılarını konsola yazdırır:

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

Uygulamayı çalıştırma

dotnet run

Kaynakları temizleme

Bilişsel hizmetler aboneliğini temizlemek ve kaldırmak istiyorsanız, kaynağı veya kaynak grubunu silebilirsiniz. Kaynak grubunun silinmesi, onunla ilişkili diğer tüm kaynakları da siler.

• Portal
• Azure CLI

Bu hızlı başlangıçta bir kişilik grubu oluşturduysanız ve silmek istiyorsanız, programınızda aşağıdaki kodu çalıştırın:

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

Aşağıdaki kodla birlikte silme yöntemini tanımlayın:

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

Sonraki adımlar

Bu hızlı başlangıçta, temel yüz tanıma görevlerini yapmak için .NET için yüz istemci kitaplığı 'nı nasıl kullanacağınızı öğrendiniz. Daha sonra, farklı yüz algılama modelleri hakkında bilgi edinin ve kullanım örneği için doğru modeli nasıl belirteceğinizi öğrenin.

• Yüz Tanıma hizmeti nedir?
• Bu örneğin kaynak kodu GitHubbulunabilir.

Kullanmaya başlayın Go için Yüz Tanıma istemci kitaplığını kullanarak yüz tanıma ile bağlantı oluşturma. Paketi yüklemek ve temel görevler için örnek kodu denemek için bu adımları izleyin. Yüz Tanıma hizmeti, görüntülerde insan yüzlerini algılamak ve tanımak için gelişmiş algoritmalara erişmeniz için size erişim sağlar.

Git için Yüz Hizmeti istemci kitaplığını kullanarak şu yere gidin:

• Yüzleri algılama ve analiz etme
• Bir yüzü tanımlama
• Yüzleri doğrulama
• Benzer yüzleri bulma

Başvuru belgeleri | Kitaplık kaynak kodu | SDK indirme

Önkoşullar

• Go'un en son sürümü
• Azure aboneliği - Ücretsiz bir abonelik oluşturun
• Sorumlu AI koşullarını kabul etmek ve kaynak oluşturmak için Azure hesabınıza bir Bilişsel Hizmetler Katkıda Bulunanı rolü atanmış olması gerekir. Bu rolü hesabınıza ataması için yöneticinize başvurun.
• Azure aboneliğinize sahip olduktan sonra, Anahtarınızı ve uç noktanızı almak için Yüz Azure portal kaynağı oluşturun. Dağıtımdan sonra Kaynağa git'e tıklayın.
  • Uygulamanıza Yüz Tanıma API'sini bağlamak için, oluşturmakta olduğu kaynakta yer alan anahtara ve uç noktaya ihtiyacınız vardır. Hızlı başlangıçta anahtarınızı ve uç noktanızı aşağıdaki koda yapıştırabilirsiniz.
  • Hizmeti denemek ve daha sonra üretim için ücretli bir katmana yükseltmek üzere ücretsiz fiyatlandırma katmanını ( F0 ) kullanabilirsiniz.
• Bir anahtar ve uç nokta elde ettikten sonra anahtar ve uç nokta için sırasıyla ve adlı ortam FACE_SUBSCRIPTION_KEY değişkenleri FACE_ENDPOINT oluşturun.

Ayarlama

Go proje dizini oluşturma

Konsol penceresinde (cmd, PowerShell, Terminal, Bash) Go projeniz için adlı yeni bir çalışma alanı oluşturun my-app ve bu çalışma alanına gidin.

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

Çalışma alanınız üç klasör içerir:

• src - Bu dizin kaynak kodu ve paketleri içerir. komutuyla yüklenmiş tüm go get paketler bu klasörde yer atılır.
• pkg - Bu dizin derlenmiş Go paket nesnelerini içerir. Bu dosyaların hepsi bir .a uzantıya sahip.
• bin - Bu dizin, dosyasını çalıştırarak oluşturulan ikili yürütülebilir dosyaları go install içerir.

Go için istemci kitaplığını yükleme

Ardından Go için istemci kitaplığını yükleyin:

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

veya dep kullanıyorsanız, kendi repo içinde çalıştırın:

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

Go uygulaması oluşturma

Ardından, adlı src dizininde bir dosya sample-app.go oluşturun:

cd src
touch sample-app.go

Tercih sample-app.go ettiğiniz IDE'de veya metin düzenleyicisinde açın. Ardından paket adını ekleyin ve aşağıdaki kitaplıkları içeri aktarın:

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

Ardından, farklı Yüz Hizmeti işlemlerini yapmak için kod eklemeye başlayacaktır.

Nesne modeli

Aşağıdaki sınıflar ve arabirimler, Yüz Hizmeti Go istemci kitaplığının bazı önemli özelliklerini işlemektedir.

Kod örnekleri

Bu kod örnekleri, Go için Yüz Hizmeti istemci kitaplığını kullanarak temel görevlerin nasıl tamamlanacaklarını gösterir:

• İstemcinin kimliğini doğrulama
• Yüzleri algılama ve analiz etme
• Bir yüzü tanımlama
• Yüzleri doğrulama
• Benzer yüzleri bulma

İstemcinin kimliğini doğrulama

Bir ana işlev oluşturun ve uç noktanız ve anahtarınız ile bir istemci örneği oluşturmak için bu işleve aşağıdaki kodu ekleyin. Anahtarınız ile bir CognitiveServicesAuthorizer nesnesi oluşturur ve bir Client nesnesi oluşturmak için bunu uç noktanız ile birlikte kullanırsiniz. Bu kod, istemci nesnelerinin oluşturulması için gereken bir bağlam nesnesi de örneği oluşturur. Ayrıca bu hızlı başlangıçtaki örnek görüntülerden bazılarının bulunduğu uzak bir konum tanımlar.

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

Yüzleri algılama ve analiz etme

Yüz Algılama, Yüz Analizi ve Kimlik Doğrulaması'nın ilk adımı olarak gereklidir. Bu bölümde, ek yüz özniteliği verilerini nasıl geri getiryebilirsiniz? Yüzleri yalnızca yüz tanımlama veya doğrulama için algılamak için sonraki bölümlere atlayabilirsiniz.

Aşağıdaki kodu main yönteminize ekleyin. Bu kod, uzak bir örnek görüntüyü tanımlar ve görüntüden hangi yüz özelliklerinin ayıklandırılamayacaklarını belirtir. Ayrıca algılanan yüzlerden veri ayıklamak için hangi AI modelinin kullanacağız? Bu seçenekler hakkında bilgi için bkz. Tanıma modeli belirtme. Son olarak DetectWithURL yöntemi, görüntüde yüz algılama işlemi yapar ve sonuçları program belleğine kaydeder.

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

Algılanan yüz verilerini görüntüleme

Sonraki kod bloğu DetectedFace nesneleri dizisinde ilk öğeyi alır ve özniteliklerini konsola yazdırır. Birden çok yüz içeren bir görüntü kullandıysanız, bunun yerine dizide bir kez daha deneyin.

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

Bir yüzü tanımlama

Identify işlemi bir kişinin (veya birden çok kişinin) görüntüsünü alır ve görüntüde her yüzün kimliğini (yüz tanıma araması) bulmak için arama alır. Algılanan her yüzü, yüz özellikleri bilinen farklı Kişi nesnelerinden bir veritabanı olan PersonGroup ile karşılaştırıldığında.

Kişi görüntülerini al

Bu senaryoyu adım adım takip etmek için aşağıdaki görüntüleri projenizin kök dizinine kaydetmeniz gerekir: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

Bu görüntü grubu, üç farklı kişiyi karşılık gelen üç tek yüzli görüntü kümesi içerir. Kod üç PersonGroup Kişi nesnesi tanımlar ve bunları , ve ile başlayarak görüntü woman man dosyalarıyla child ilişkilendirilecek.

PersonGroup oluşturma

Görüntülerinizi indirdikten sonra aşağıdaki kodu ana yönteminizin en altına ekleyin. Bu kod bir PersonGroupClient nesnesinin kimliğini doğrular ve ardından bunu kullanarak yeni bir PersonGroup tanımlar.

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

PersonGroup Kişilerini Oluşturma

Sonraki kod bloğu bir PersonGroupPersonClient kimliğini doğrular ve üç yeni PersonGroup Kişi nesnesi tanımlamak için bu kodu kullanır. Bu nesnelerin her biri, görüntü kümesinde tek bir kişiyi temsil eder.

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

Kişiler'e yüz atama

Aşağıdaki kod, görüntüleri ön eklerine göre sıralar, yüzleri algılar ve yüzleri görüntü dosyası adına göre ilgili PersonGroup Person nesnesine atar.

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

PersonGroup'ları eğitin

Yüzleri atadıktan sonra PersonGroup'ları, Kişi nesnelerinin her biri ile ilişkili görsel özellikleri tanımlayacak şekilde eğitebilirsiniz. Aşağıdaki kod, zaman uyumsuz train yöntemini çağırarak sonucu yoklar ve durumu konsola yazdırır.

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

Test görüntüsü al

Aşağıdaki kod, projenizin kökünde görüntü vetest-image-person-group.jpgprogram belleğine yükler. Bu görüntüyü PersonGroup oluşturmak için kullanılan görüntülerle aynı repoda bulabilirsiniz: 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) }

Test görüntüsünde kaynak yüzleri algılama

Sonraki kod bloğu, tüm yüzleri almak ve bunları bir diziye kaydetmek için test görüntüsü üzerinde normal yüz algılaması yapar.

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

Kaynak görüntüden yüzleri tanımlama

Identify yöntemi, algılanan yüz dizisini alır ve bunları verilen PersonGroup ile karşılaştırıldığında (önceki bölümde tanımlanmış ve eğitilmiş). Algılanan bir yüzü gruptaki bir Kişi ile eşleyemediyse sonucu kaydeder.

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

Bu kod daha sonra ayrıntılı eşleşme sonuçlarını konsola yazdırır.

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

Yüzleri doğrulama

Doğrulama işlemi bir yüz kimliği ve başka bir yüz kimliği veya Kişi nesnesi alır ve bunların aynı kişiye ait olup olmadığını belirler. Doğrulama, Identify işlemi tarafından döndürülen yüz eşleşmesi çift denetimi için kullanılabilir.

Aşağıdaki kod, iki kaynak görüntüde yüzleri algılar ve her birini hedef görüntüden algılanan bir yüze karşı doğrular.

Test görüntülerini al

Aşağıdaki kod blokları, doğrulama işlemi için hedef ve kaynak görüntüleri işaret eden değişkenleri bildirmektedir.

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

Doğrulama için yüzleri algılama

Aşağıdaki kod, kaynak ve hedef görüntülerde yüzleri algılar ve bunları değişkenlere kaydeder.

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

Doğrulama sonuçlarını alma

Aşağıdaki kod, kaynak görüntülerin her birini hedef görüntüyle karşılaştırıldığında aynı kişiye ait olup olmadığını belirten bir ileti yazdırır.

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

Benzer yüzleri bulma

Aşağıdaki kod, tek bir algılanan yüzü (kaynak) alır ve eşleşmeleri bulmak için başka bir yüz kümesi (hedef) arar (görüntüye göre yüz araması). Bir eşleşme bulduğunda, konsola, eşlene yüzün kimliğini yazdırır.

Karşılaştırma için yüzleri algılama

İlk olarak Algıla ve analiz etme bölümünde algılanan yüze bir başvuru kaydedin. Kaynak bu yüz olur.

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

Ardından, farklı bir görüntüde yer alan bir dizi yüzü algılamak için aşağıdaki kodu girin. Bu yüzler hedef olur.

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

Eşleşmeleri bulma

Aşağıdaki kod, kaynak yüzle eşleyen tüm hedef yüzleri bulmak için FindSimilar yöntemini kullanır.

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

Eşleşmeleri yazdırma

Aşağıdaki kod, eşleşme ayrıntılarını konsola yazdırır.

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

Uygulamayı çalıştırma

yüz tanıma uygulamanızı uygulama dizininden komutuyla go run <app-name> çalıştırın.

go run sample-app.go

Kaynakları temizleme

Bilişsel Hizmetler aboneliğini temizlemek ve kaldırmak için kaynağı veya kaynak grubunu silebilirsiniz. Kaynak grubunun silinmesi, kaynak grubuyla ilişkilendirilmiş diğer tüm kaynakları da siler.

• Portal
• Azure CLI

Bu hızlı başlangıçta bir PersonGroup oluşturduysanız ve bunu silmek için Delete yöntemini çağırabilirsiniz.

Sonraki adımlar

Bu hızlı başlangıçta, temel yüz tanıma görevlerini gerçekleştirmek için Go için Yüz Tanıma istemci kitaplığını kullanmayı öğrendiniz. Ardından, farklı yüz algılama modelleri hakkında bilgi edinmek ve kullanım örneğiniz için doğru modeli belirtmeyi öğrenin.

• Yüz Tanıma hizmeti nedir?
• Bu örneğin kaynak kodu GitHub.

Hızlı başlangıç: JavaScript için yüz istemci kitaplığı

JavaScript için yüz istemci kitaplığını kullanarak yüz tanıma ile çalışmaya başlayın. Paketi yüklemek için bu adımları izleyin ve temel görevler için örnek kodu deneyin. Yüz tanıma hizmeti, görüntülerdeki insan yüzlerini algılayıp tanımayı sağlayan gelişmiş algoritmalara erişmenizi sağlar.

JavaScript için yüz istemci kitaplığını kullanarak şunları yapın:

• Yüzleri algılayın ve çözümleyin
• Yüz tanıma
• Benzer yüzeyleri bulun

Başvuru belgeleri | Kitaplık kaynak kodu | Paket (NPM) | Örnekler

Önkoşullar

• Azure aboneliği- ücretsiz olarak bir tane oluşturun
• Node.js en son sürümü
• Sorumlu AI koşullarını kabul etmek ve kaynak oluşturmak için Azure hesabınıza bir Bilişsel Hizmetler Katkıda Bulunanı rolü atanmış olması gerekir. Bu rolü hesabınıza ataması için yöneticinize başvurun.
• Azure aboneliğiniz olduktan sonra, anahtarınızı ve uç noktanızı almak için Azure portal bir yüz kaynağı oluşturun . Dağıtıldıktan sonra Kaynağa Git ' e tıklayın.
  • Uygulamanızı Yüz Tanıma API'si bağlamak için oluşturduğunuz kaynaktaki anahtar ve uç nokta gerekir. Anahtarınızı ve uç noktanızı daha sonra hızlı başlangıçta aşağıdaki koda yapıştırabilirsiniz.
  • F0Hizmeti denemek ve daha sonra üretime yönelik ücretli bir katmana yükseltmek için ücretsiz fiyatlandırma katmanını () kullanabilirsiniz.

Ayarlanıyor

Yeni bir Node.js uygulaması oluşturma

Konsol penceresinde (cmd, PowerShell veya Bash gibi), uygulamanız için yeni bir dizin oluşturun ve bu uygulamaya gidin.

mkdir myapp && cd myapp

npm initBir dosya ile bir düğüm uygulaması oluşturmak için komutunu çalıştırın package.json .

npm init

İstemci kitaplığını yükler

ms-rest-azureVe azure-cognitiveservices-face NPM paketlerini yüklerken:

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

Uygulamanızın package.json dosyası bağımlılıklarla güncelleştirilir.

Adlı bir dosya oluşturun index.js ve aşağıdaki kitaplıkları içeri aktarın:

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

Kaynağınızın Azure uç noktası ve anahtarı için değişkenler oluşturun.

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

Nesne modeli

Aşağıdaki sınıflar ve arabirimler, yüz .NET istemci kitaplığının bazı önemli özelliklerini işler:

Kod örnekleri

Aşağıdaki kod parçacıkları, .NET için yüz istemci kitaplığı ile aşağıdaki görevlerin nasıl yapılacağını göstermektedir:

• İstemcinin kimliğini doğrulama
• Yüzleri algılayın ve çözümleyin
• Yüz tanıma
• Benzer yüzeyleri bulun

İstemcinin kimliğini doğrulama

Uç noktanız ve anahtarınızla bir istemci örneği oluşturun. Anahtarınızla bir Apikeycredentials nesnesi oluşturun ve bir faceclient nesnesi oluşturmak için bunu uç noktanızla birlikte kullanın.

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

Genel değerleri ve yardımcı işlevi bildirme

Daha sonra ekleyeceğiniz birçok yüz işlemi için aşağıdaki genel değerler gereklidir.

URL, örnek görüntülerin bir klasörünü işaret eder. UUID, oluşturacağınız PersonGroup için hem ad hem de KIMLIK olarak görev yapar.

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

Aşağıdaki işlevi, PersonGroup 'un eğitiminin tamamlanmasını beklemek için kullanacaksınız.

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

Yüzleri algılayın ve çözümleyin

Yüz tanıma analizine ve kimlik doğrulamaya yönelik bir ilk adım olarak yüz algılama gerekir. Bu bölümde, ek yüz öznitelik verilerinin nasıl döndürübir gösterilmektedir. Yüz tanıma veya doğrulama için yalnızca yüzleri algılamak istiyorsanız sonraki bölümlere atlayın.

Algılanan yüz nesneleri Al

Yüzeyleri algılamak için yeni bir yöntem oluşturun. DetectFaceExtractYöntemi, VERILEN URL 'nin üç görüntüsünü işler ve program belleğindeki algılayıcısı olan nesnelerin bir listesini oluşturur. Faceattributetype değerlerinin listesi hangi özelliklerin ayıklanacağını belirtir.

DetectFaceExtractYöntemi ardından, algılanan her bir yüzey için öznitelik verilerini ayrıştırır ve yazdırır. Her öznitelik, özgün yüz algılama API çağrısında ( Faceattributetype listesinde) ayrı olarak belirtilmelidir. Aşağıdaki kod her özniteliği işler, ancak büyük olasılıkla yalnızca bir veya birkaç tane kullanmanız gerekir.

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

Yüz tanıma

Tanımla işlemi, bir kişinin (veya birden çok kişinin) bir görüntüsünü alır ve görüntüde her yüz ile ilişkili depolanan kişi nesnesini bulur (yüz tanıma arama). Algılanan her yüzü, yüz özellikleri bilinen farklı kişi nesnelerinin bir veritabanı olan bir persongroupile karşılaştırır. Bu işlemi tanımlamak için önce bir Persongroupoluşturmanız ve eğitmeniz gerekir.

Kişilik grubuna yüz ekleme

Persongroup'a yüzler eklemek için aşağıdaki işlevi oluşturun.

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

PersonGroup eğitimi için bekleyin

Persongroup 'un eğitime son vermesini beklemek için aşağıdaki yardımcı işlevi oluşturun.

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

Bir PersonGroup oluşturma

Aşağıdaki kod:

• Bir Persongroup oluşturur
• AddFacesToPersonGroup Daha önce tanımladığınız ' ı çağırarak personbuna yüz ekler.
• Persono grubunu TRAIN.
• Persongroup'taki yüzeyleri tanımlar.

Bu Persongroup ve ilişkili kişi nesneleri artık Verify, tanımla veya Gruplandır işlemlerinde kullanılmak üzere hazırdır.

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

Benzer yüzleri bulma

Aşağıdaki kod, tek bir algılanan yüzü (kaynak) alır ve eşleşmeleri bulmak için başka bir yüz kümesi (hedef) arar (görüntüye göre yüz araması). Bir eşleşme bulduğunda, konsola, eşlene yüzün kimliğini yazdırır.

Karşılaştırma için yüzleri algılama

İlk olarak ikinci bir yüz algılama yöntemi tanımlayın. Görüntüleri karşılaştıramadan önce görüntülerde yüzleri algılamalı ve bu algılama yöntemi karşılaştırma işlemleri için en iyi duruma getirilmiştir. Yukarıdaki bölümde olduğu gibi ayrıntılı yüz özniteliklerini ayıklamaz ve farklı bir tanıma modeli kullanır.

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

Eşleşmeleri bulma

Aşağıdaki yöntem, bir dizi hedef görüntüde ve tek bir kaynak görüntüde yüzleri algılar. Ardından bunları karşılar ve kaynak görüntüye benzer tüm hedef görüntüleri bulur. Son olarak, eşleşme ayrıntılarını konsola yazdırır.

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

Ana

Son olarak, işlevini main oluşturun ve çağırarak.

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

Uygulamayı çalıştırma

Hızlı başlangıç dosyanız node üzerinde komutunu kullanarak uygulamayı çalıştırın.

node index.js

Kaynakları temizleme

Bilişsel Hizmetler aboneliğini temizlemek ve kaldırmak için kaynağı veya kaynak grubunu silebilirsiniz. Kaynak grubunun silinmesi, kaynak grubuyla ilişkilendirilmiş diğer tüm kaynakları da siler.

• Portal
• Azure CLI

Sonraki adımlar

Bu hızlı başlangıçta, temel yüz tanıma görevlerini gerçekleştirmek için JavaScript için Yüz Tanıma istemci kitaplığını kullanmayı öğrendiniz. Ardından, farklı yüz algılama modelleri hakkında bilgi edinmek ve kullanım örneğiniz için doğru modeli belirtmeyi öğrenin.

• Yüz Tanıma hizmeti nedir?
• Bu örneğin kaynak kodu GitHub.

Python için yüz istemci kitaplığını kullanarak yüz tanıma ile çalışmaya başlayın. Paketi yüklemek için bu adımları izleyin ve temel görevler için örnek kodu deneyin. Yüz tanıma hizmeti, görüntülerdeki insan yüzlerini algılayıp tanımayı sağlayan gelişmiş algoritmalara erişmenizi sağlar.

Python için yüz istemci kitaplığını kullanarak şunları yapın:

• Yüzleri algılayın ve çözümleyin
• Yüz tanıma
• Yüzeyleri doğrula
• Benzer yüzeyleri bulun

Başvuru belgeleri | Kitaplık kaynak kodu | Paket (PiPy) | Örnekler

Önkoşullar

• Azure aboneliği- ücretsiz olarak bir tane oluşturun
• Python 3.x
  • Python yüklemeniz PIP'yi içermelidir. Komut satırında komutunu çalıştırarak PIP 'nin yüklenip yüklenmediğini kontrol edebilirsiniz pip --version . Python 'un en son sürümünü yükleyerek PIP 'yi alın.
• Sorumlu AI koşullarını kabul etmek ve kaynak oluşturmak için Azure hesabınıza bir Bilişsel Hizmetler Katkıda Bulunanı rolü atanmış olması gerekir. Bu rolü hesabınıza ataması için yöneticinize başvurun.
• Azure aboneliğiniz olduktan sonra, Azure Portal anahtar ve uç noktanıza ulaşmak için bir yüz kaynağı oluşturun. Dağıtıldıktan sonra Kaynağa Git ' e tıklayın.
  • Uygulamanızı Yüz Tanıma API'si bağlamak için oluşturduğunuz kaynaktaki anahtar ve uç nokta gerekir. Anahtarınızı ve uç noktanızı daha sonra hızlı başlangıçta aşağıdaki koda yapıştırabilirsiniz.
  • F0Hizmeti denemek ve daha sonra üretime yönelik ücretli bir katmana yükseltmek için ücretsiz fiyatlandırma katmanını () kullanabilirsiniz.

Ayarlanıyor

İstemci kitaplığını yükler

Python yükledikten sonra, ile istemci kitaplığını yükleyebilirsiniz:

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

Yeni Python uygulaması oluşturma

Örneğin, yeni bir Python betiği oluşturun — QuickStart-File.py. Ardından bunu tercih ettiğiniz düzenleyicide veya IDE 'de açın ve aşağıdaki kitaplıkları içeri aktarın.

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

Daha sonra, kaynağınızın Azure uç noktası ve anahtarı için değişkenler oluşturun.

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

Nesne modeli

Aşağıdaki sınıflar ve arabirimler, yüz Python istemci kitaplığının önemli özelliklerinden bazılarını işler.

Kod örnekleri

Bu kod parçacıkları, Python için yüz istemci kitaplığıyla aşağıdaki görevlerin nasıl yapılacağını gösterir:

• İstemcinin kimliğini doğrulama
• Yüzleri algılayın ve çözümleyin
• Yüz tanıma
• Yüzeyleri doğrula
• Benzer yüzeyleri bulun

İstemcinin kimliğini doğrulama

Uç noktanız ve anahtarınızla bir istemci örneği oluşturun. Anahtarınızla bir Biliveservicescredentials nesnesi oluşturun ve bir faceclient nesnesi oluşturmak için bunu uç noktanızla birlikte kullanın.

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

Yüzleri algılayın ve çözümleyin

Yüz Analizi ve kimlik doğrulaması için yüz algılama gereklidir. Bu bölümde, ek yüz öznitelik verilerinin nasıl döndürübir gösterilmektedir. Yüz tanıma veya doğrulama için yalnızca yüzleri algılamak istiyorsanız sonraki bölümlere atlayın.

Aşağıdaki kod, uzak görüntüde bir yüz algılar. Algılanan yüz KIMLIĞINI konsola yazdırır ve ayrıca program belleğine depolar. Daha sonra, birden çok kişiye sahip bir görüntüdeki yüzeyleri algılar ve kimliklerini konsola yazdırır. Detect_with_url yöntemindeki parametreleri değiştirerek, her bir detectedface nesnesiyle farklı bilgiler döndürebilirsiniz.

# 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

Görüntü ve çerçeve yüzeyleri

Aşağıdaki kod, görüntüye verilen görüntünün çıktısını verir ve DetectedFace. faceRectangle özelliğini kullanarak yüzlerin etrafında dikdörtgenler çizer.

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

Yüz tanıma

Tanımlama işlemi, bir kişinin (veya birden çok kişinin) bir görüntüsünü alır ve görüntüdeki her bir yüzün kimliğini bulmak için (yüz tanıma arama) arar. Algılanan her yüzü, yüz özellikleri bilinen farklı kişi nesnelerinin bir veritabanı olan bir persongroup ile karşılaştırır.

Bir PersonGroup oluşturma

Aşağıdaki kod, üç farklı kişi nesnesi Ile bir persongroup oluşturur. Her kişiyi örnek bir görüntü kümesiyle ilişkilendirir ve sonra her kişiyi tanıyabilecek.

Bu senaryoda ilerlemek için aşağıdaki görüntüleri projenizin kök dizinine kaydetmeniz gerekir: https://github.com/Azure-Samples/cognitive-services-sample-data-files/tree/master/Face/images .

Bu görüntü grubu üç farklı kişiye karşılık gelen üç yüz görüntüsü kümesini içerir. Kod, üç kişi nesnesini tanımlar ve bunları, ve ile başlayan resim dosyalarıyla ilişkilendirir woman man child .

Görüntülerinizi ayarladıktan sonra, oluşturduğunuz Persongroup nesnesi için betiğinizin en üstünde bir etiket tanımlayın.

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

Ardından, betiğinizin en altına aşağıdaki kodu ekleyin. Bu kod, bir Persongroup ve üç kişi nesnesi oluşturur.

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

Kişilere yüz atama

Aşağıdaki kod, görüntülerinizi ön ekine göre sıralar, yüzeyleri algılar ve her bir kişi nesnesine yüzeyleri atar.

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

PersonGroup 'ı eğitme

Yüzleri atadıktan sonra, kişi nesnelerinin her biriyle ilişkili görsel özelliklerini tanımlayabilmesi Için persongroup 'u eğitmeniz gerekir. Aşağıdaki kod, zaman uyumsuz eğitme yöntemini çağırır ve sonucu, durumu konsola yazdırarak tarar.

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

Test görüntüsü al

Aşağıdaki kod, projenizin kökünde bir görüntütest-image-person-group.jpgve görüntüde yüzleri algılar. PersonGroup yönetimi için kullanılan görüntülerle bu görüntüyü bulabilirsiniz: 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)

Tanımlanan yüz kimliklerini çıkışa

belirleme yöntemi, algılanan yüzlerden bir dizi alır ve bunları PersonGroup ile karşılaştırıldığında. Algılanan bir yüzü Kişi ile eşleyemediyse sonucu kaydeder. Bu kod, ayrıntılı eşleşme sonuçlarını konsola yazdırır.

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

Yüzleri doğrulama

Doğrulama işlemi bir yüz kimliği ve başka bir yüz kimliği veya Kişi nesnesi alır ve bunların aynı kişiye ait olup olmadığını belirler. Doğrulama, Identify işlemi tarafından döndürülen yüz eşleşmesi çift denetimi için kullanılabilir.

Aşağıdaki kod, iki kaynak görüntüde yüzleri algılar ve ardından bunları hedef görüntüden algılanan bir yüze karşı doğrular.

Test görüntülerini al

Aşağıdaki kod blokları, doğrulama işlemi için kaynak ve hedef görüntüleri işaret eden değişkenleri bildirmektedir.

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

Doğrulama için yüzleri algılama

Aşağıdaki kod, kaynak ve hedef görüntülerde yüzleri algılar ve bunları değişkenlere kaydeder.

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

Doğrulama sonuçlarını alma

Aşağıdaki kod, kaynak görüntülerin her birini hedef görüntüyle karşılaştırıldığında aynı kişiye ait olup olmadığını belirten bir ileti yazdırır.

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

Benzer yüzleri bulma

Aşağıdaki kod, tek bir algılanan yüzü (kaynak) alır ve eşleşmeleri bulmak için başka bir yüz kümesi (hedef) arar (görüntüye göre yüz araması). Bir eşleşme bulduğunda, konsola, eşlene yüzün kimliğini yazdırır.

Eşleşmeleri bulma

İlk olarak, tek bir yüze başvuru kaydetmek için yukarıdakibölümdekikodu çalıştırın ( Yüzleri algılama ve analiz etme). Ardından aşağıdaki kodu çalıştırarak bir grup görüntüsünde yer alan çeşitli yüzlere başvurular elde etmek için bu kodu çalıştırın.

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

Ardından gruptaki ilk yüzün örneklerini bulmak için aşağıdaki kod bloğuna ekleyin. Bu davranışı find_similar öğrenmek için find_similar yöntemine bakın.

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

Eşleşmeleri yazdırma

Eşleşme ayrıntılarını konsola yazdırmak için aşağıdaki kodu kullanın.

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

Uygulamayı çalıştırma

yüz tanıma uygulamanızı uygulama dizininden komutuyla python çalıştırın.

python quickstart-file.py

Kaynakları temizleme

Bilişsel Hizmetler aboneliğini temizlemek ve kaldırmak için kaynağı veya kaynak grubunu silebilirsiniz. Kaynak grubunun silinmesi, kaynak grubuyla ilişkilendirilmiş diğer tüm kaynakları da siler.

• Portal
• Azure CLI

Bu hızlı başlangıçta bir PersonGroup oluşturduysanız ve bunu silmek için betiğinize aşağıdaki kodu çalıştırın:

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

Sonraki adımlar

Bu hızlı başlangıçta, temel yüz tanıma görevlerini gerçekleştirmek üzere Python için Yüz Tanıma istemci kitaplığını kullanmayı öğrendiniz. Ardından, farklı yüz algılama modelleri hakkında bilgi edinmek ve kullanım örneğiniz için doğru modeli belirtmeyi öğrenin.

• Yüz Tanıma hizmeti nedir?
• Bu örneğin kaynak kodu GitHub.

Yüz tanıma REST API kullanarak yüz tanıma çalışmaya başlama. Yüz tanıma hizmeti, görüntülerdeki insan yüzlerini algılayıp tanımayı sağlayan gelişmiş algoritmalara erişmenizi sağlar.

Yüz REST API şu şekilde kullanın:

• Yüzleri algılayın ve çözümleyin
• Benzer yüzeyleri bulun

Önkoşullar

• Azure aboneliği- ücretsiz olarak bir tane oluşturun
• Sorumlu AI koşullarını kabul etmek ve kaynak oluşturmak için Azure hesabınıza bir Bilişsel Hizmetler Katkıda Bulunanı rolü atanmış olması gerekir. Bu rolü hesabınıza ataması için yöneticinize başvurun.
• Azure aboneliğiniz olduktan sonra, Azure Portal anahtar ve uç noktanıza ulaşmak için bir yüz kaynağı oluşturun. Dağıtıldıktan sonra Kaynağa Git ' e tıklayın.
  • Uygulamanızı Yüz Tanıma API'si bağlamak için oluşturduğunuz kaynaktaki anahtar ve uç nokta gerekir. Anahtarınızı ve uç noktanızı daha sonra hızlı başlangıçta aşağıdaki koda yapıştırabilirsiniz.
  • F0Hizmeti denemek ve daha sonra üretime yönelik ücretli bir katmana yükseltmek için ücretsiz fiyatlandırma katmanını () kullanabilirsiniz.
• PowerShell sürüm 6.0 +veya benzer bir komut satırı uygulaması.

Yüzleri algılayın ve çözümleyin

Yüz Tanıma API'si çağırmak ve bir görüntüden yüz öznitelik verileri almak için aşağıdaki gibi bir komut kullanacaksınız. İlk olarak, kodu bir metin düzenleyicisine kopyalayın, — çalıştırmadan önce komutun belirli kısımlarında değişiklik yapmanız gerekir.

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

Aşağıdaki değişiklikleri yapın:

1. Ocp-Apim-Subscription-KeyGeçerli yüz abonelik anahtarınıza atayın.
2. Sorgu URL 'sinin ilk kısmını, abonelik anahtarınıza karşılık gelen uç noktayla eşleşecek şekilde değiştirin.

   Not

   1 Temmuz 2019 ' den sonra oluşturulan yeni kaynaklar özel alt etki alanı adları kullanır. Daha fazla bilgi ve bölgesel uç noktaların tamamen listesi için bkz. bilişsel Hizmetler Için özel alt etki alanı adları.

3. İsteğe bağlı olarak, isteğin gövdesindeki URL 'YI farklı bir görüntüye işaret etmek üzere değiştirin.

Değişikliklerinizi yaptıktan sonra, bir komut istemi açın ve yeni komutu girin.

Sonuçları inceleme

Konsol penceresinde JSON verileri olarak görünen yüz bilgilerini görmeniz gerekir. Örnek:

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

Yüz özniteliklerini Al

Yüz özniteliklerini ayıklamak için, algılama API 'sini yeniden çağırın, ancak detectionModel olarak ayarlayın detection_01 . returnFaceAttributesSorgu parametresini de ekleyin. Komut artık aşağıdaki gibi görünmelidir. Daha önce olduğu gibi, yüz abonelik anahtarınızı ve uç noktayı ekleyin.

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

Sonuçları inceleme

Döndürülen yüz bilgileri artık yüz öznitelikleri içeriyor. Örnek:

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

Benzer yüzleri bulma

Bu işlem, algılanan tek bir yüzeyi (kaynak) alır ve diğer yüzlerin (hedef) bir kümesini arar (yüz görüntüye göre arama). Bir eşleşme bulduğunda, eşleşen yüzün KIMLIĞINI konsola yazdırır.

Karşılaştırılacak Yüzleri Algıla

İlk olarak, bunları karşılaştırabilmeniz için görüntülerde yüzeyleri tespit etmeniz gerekir. Algıla ve çözümle bölümünde yaptığınız gibi bu komutu çalıştırın. Bu algılama yöntemi, karşılaştırma işlemleri için iyileştirilmiştir. Yukarıdaki bölümde olduğu gibi ayrıntılı yüz özniteliklerini ayıklamaz ve farklı bir algılama modeli kullanır.

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

"faceId"JSON yanıtında değeri bulun ve geçici bir konuma kaydedin. Daha sonra, bu diğer resim URL 'Leri için yukarıdaki komutu yeniden çağırın ve yüz kimliklerini de kaydedin. Bu kimlikleri, benzer bir yüzü bulacağınız yüzlerin hedef grubu olarak kullanacaksınız.

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

Son olarak, eşleştirme için kullanacağınız tek kaynak yüzünü tespit edin ve KIMLIĞINI kaydedin. Bu KIMLIĞI diğerlerinden ayrı tutun.

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

Eşleşmeleri bul

Aşağıdaki komutu bir metin düzenleyicisine kopyalayın.

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

Ardından aşağıdaki değişiklikleri yapın:

1. Ocp-Apim-Subscription-KeyGeçerli yüz abonelik anahtarınıza atayın.
2. Sorgu URL 'sinin ilk kısmını, abonelik anahtarınıza karşılık gelen uç noktayla eşleşecek şekilde değiştirin.

Değer için aşağıdaki JSON içeriğini kullanın body :

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

1. İçin kaynak yüz KIMLIĞINI kullanın "faceId" .
2. Diğer yüz kimliklerini dizide terim olarak yapıştırın "faceIds" .

Sonuçları inceleme

Sorgu yüzlerinizle eşleşen yüzlerin kimliklerini listeleyen bir JSON yanıtı alacaksınız.

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

Kaynakları temizleme

Bilişsel hizmetler aboneliğini temizlemek ve kaldırmak istiyorsanız, kaynağı veya kaynak grubunu silebilirsiniz. Kaynak grubunun silinmesi, onunla ilişkili diğer tüm kaynakları da siler.

• Portal
• Azure CLI

Sonraki adımlar

Bu hızlı başlangıçta, temel yüz tanıma görevlerini yapmak için yüz REST API nasıl kullanacağınızı öğrendiniz. Daha sonra, farklı yüz algılama modelleri hakkında bilgi edinin ve kullanım örneği için doğru modeli nasıl belirteceğinizi öğrenin.

• Yüz Tanıma hizmeti nedir?