Hinzufügen von Gesichtern zu einer PersonGroup

Artikel
09/04/2024

Achtung

Der Zugriff auf den Gesichtserkennungsdienst ist auf der Grundlage von Berechtigungs- und Nutzungskriterien begrenzt, um unsere Prinzipien für verantwortungsvolle KI zu unterstützen. Der Gesichtserkennungsdienst ist nur für von Microsoft verwaltete Kunden und Partner verfügbar. Verwenden Sie das Aufnahmeformular für die Gesichtserkennung, um sich für den Zugriff zu bewerben. Weitere Informationen finden Sie auf der Seite Eingeschränkter Zugriff auf die Gesichtserkennung.

Diese Anleitung veranschaulicht das Hinzufügen einer großen Anzahl von Personen und Gesichtern zu einer PersonGroup. Dieselbe Strategie gilt auch für LargePersonGroup-, FaceList- und LargeFaceList-Objekte. Dieses Beispiel ist in C# geschrieben.

Initialisierung

Der folgende Code deklariert mehrere Variablen und implementiert eine Hilfsfunktion zum Planen der Anforderungen für das Hinzufügen von Gesichtern:

PersonCount ist die Gesamtzahl an Personen.
CallLimitPerSecond ist die maximale Anzahl an Aufrufen pro Sekunde gemäß der Abonnementebene.
_timeStampQueue ist eine Warteschlange zum Aufzeichnen der Zeitstempel der Anforderung.
await WaitCallLimitPerSecondAsync() wartet, bis die nächste Anforderung gesendet werden kann.

const int PersonCount = 10000;
const int CallLimitPerSecond = 10;
static Queue<DateTime> _timeStampQueue = new Queue<DateTime>(CallLimitPerSecond);

static async Task WaitCallLimitPerSecondAsync()
{
    Monitor.Enter(_timeStampQueue);
    try
    {
        if (_timeStampQueue.Count >= CallLimitPerSecond)
        {
            TimeSpan timeInterval = DateTime.UtcNow - _timeStampQueue.Peek();
            if (timeInterval < TimeSpan.FromSeconds(1))
            {
                await Task.Delay(TimeSpan.FromSeconds(1) - timeInterval);
            }
            _timeStampQueue.Dequeue();
        }
        _timeStampQueue.Enqueue(DateTime.UtcNow);
    }
    finally
    {
        Monitor.Exit(_timeStampQueue);
    }
}

Erstellen von „PersonGroup“

Mit diesem Code wird eine PersonGroup namens "MyPersonGroup" erstellt, um die Personen zu speichern. Die Anforderungszeit wird in _timeStampQueue in die Warteschlange eingereiht, um die gesamte Validierung sicherzustellen.

const string personGroupId = "mypersongroupid";
const string personGroupName = "MyPersonGroup";
_timeStampQueue.Enqueue(DateTime.UtcNow);
using (var content = new ByteArrayContent(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new Dictionary<string, object> { ["name"] = personGroupName, ["recognitionModel"] = "recognition_04" }))))
{
    content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
    await httpClient.PutAsync($"{ENDPOINT}/face/v1.0/persongroups/{personGroupId}", content);
}

Erstellen von Personen für die PersonGroup

Dieser Code erstellt Personen gleichzeitig und verwendet await WaitCallLimitPerSecondAsync(), um eine Überschreitung des Anrufratenlimits zu vermeiden.

string?[] persons = new string?[PersonCount];
Parallel.For(0, PersonCount, async i =>
{
    await WaitCallLimitPerSecondAsync();

    string personName = $"PersonName#{i}";
    using (var content = new ByteArrayContent(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new Dictionary<string, object> { ["name"] = personName }))))
    {
        content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
        using (var response = await httpClient.PostAsync($"{ENDPOINT}/face/v1.0/persongroups/{personGroupId}/persons", content))
        {
            string contentString = await response.Content.ReadAsStringAsync();
            persons[i] = (string?)(JsonConvert.DeserializeObject<Dictionary<string, object>>(contentString)?["personId"]);
        }
    }
});

Hinzufügen von Gesichtern zu Personen

Die für unterschiedliche Personen hinzugefügten Gesichter werden gleichzeitig verarbeitet. Gesichter, die für eine bestimmte Person hinzugefügt werden, werden nacheinander verarbeitet. await WaitCallLimitPerSecondAsync() wird erneut aufgerufen, um sicherzustellen, dass sich die Häufigkeit der Anforderungen innerhalb der Beschränkungen bewegt.

Parallel.For(0, PersonCount, async i =>
{
    string personImageDir = @"/path/to/person/i/images";

    foreach (string imagePath in Directory.GetFiles(personImageDir, "*.jpg"))
    {
        await WaitCallLimitPerSecondAsync();

        using (Stream stream = File.OpenRead(imagePath))
        {
            using (var content = new StreamContent(stream))
            {
                content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
                await httpClient.PostAsync($"{ENDPOINT}/face/v1.0/persongroups/{personGroupId}/persons/{persons[i]}/persistedfaces?detectionModel=detection_03", content);
            }
        }
    }
});

Zusammenfassung

In dieser Anleitung haben Sie erfahren, wie eine PersonGroup mit einer großen Anzahl an Personen und Gesichtern erstellt wird. Einige Hinweise:

Diese Strategie gilt auch für FaceList und LargePersonGroup.
Das Hinzufügen oder Löschen von Gesichtern in unterschiedlichen FaceLists oder von Personen in LargePersonGroups kann gleichzeitig verarbeitet werden.
Das Hinzufügen oder Löschen von Gesichtern in einer bestimmten FaceList oder von Personen in einer LargePersonGroup erfolgt nacheinander.

Nächste Schritte

Als Nächstes erfahren Sie, welche weiteren Möglichkeiten die erweiterte Datenstruktur PersonDirectory für Ihre Gesichtsdaten bietet.

Verwenden der PersonDirectory-Struktur (Vorschau)

Freigeben über