Skalowanie w celu obsługi większej liczby zarejestrowanych użytkowników
Uwaga
Dostęp do usługi rozpoznawania twarzy jest ograniczony na podstawie kryteriów kwalifikowalności i użycia w celu obsługi naszych zasad odpowiedzialnej sztucznej inteligencji. Usługa rozpoznawania twarzy jest dostępna tylko dla klientów i partnerów zarządzanych przez firmę Microsoft. Użyj formularza do wprowadzania rozpoznawania twarzy, aby ubiegać się o dostęp. Aby uzyskać więcej informacji, zobacz stronę Dostęp ograniczony do twarzy.
W tym przewodniku przedstawiono sposób skalowania w górę z istniejących obiektów PersonGroup i FaceList do obiektów LargePersonGroup i LargeFaceList, odpowiednio. OsobyGroup mogą pomieścić do 1000 osób w warstwie Bezpłatna i 10 000 w warstwie płatnej, podczas gdy grupy LargePersonGroup mogą pomieścić do miliona osób w warstwie płatnej.
Ważne
Nowsza struktura danych PersonDirectory jest zalecana do tworzenia nowych rozwiązań. Może pomieścić do 75 milionów tożsamości i nie wymaga ręcznego trenowania. Aby uzyskać więcej informacji, zobacz przewodnik PersonDirectory.
W tym przewodniku przedstawiono proces migracji. Przyjęto założenie, że podstawowa znajomość obiektów PersonGroup i FaceList , operacji Train i funkcji rozpoznawania twarzy. Aby dowiedzieć się więcej o tych tematach, zobacz przewodnik koncepcyjny dotyczący rozpoznawania twarzy.
LargePersonGroup i LargeFaceList są wspólnie określane jako operacje na dużą skalę. Grupa LargePersonGroup może zawierać maksymalnie 1 milion osób, z których każda ma maksymalnie 248 twarzy. Lista LargeFaceList może zawierać maksymalnie 1 milion twarzy. Operacje na dużą skalę są podobne do konwencjonalnych obiektów PersonGroup i FaceList, ale mają pewne różnice ze względu na nową architekturę.
Przykłady są napisane w języku C# przy użyciu biblioteki klienta rozpoznawania twarzy platformy Azure.
Uwaga
Aby włączyć wydajność wyszukiwania twarzy dla funkcji Identification i FindSimilar na dużą skalę, wprowadź operację Train w celu wstępnego przetwarzania elementów LargeFaceList i LargePersonGroup. Czas trenowania różni się od sekund do około pół godziny na podstawie rzeczywistej pojemności. W okresie treningowym możliwe jest przeprowadzenie identyfikacji i rozwiązania FindSimilar , jeśli wcześniej wykonano pomyślne szkolenie. Wadą jest to, że nowe dodane osoby i twarze nie pojawiają się w wyniku do momentu ukończenia nowego szkolenia po migracji do szkolenia na dużą skalę.
Krok 1. Inicjowanie obiektu klienta
W przypadku korzystania z biblioteki klienta rozpoznawania twarzy klucz i punkt końcowy subskrypcji są przekazywane za pośrednictwem konstruktora klasy FaceClient. Zapoznaj się z przewodnikiem Szybki start, aby uzyskać instrukcje dotyczące tworzenia obiektu klienta rozpoznawania twarzy.
Krok 2. Migracja kodu
W tej sekcji opisano sposób migrowania implementacji PersonGroup lub FaceList do kolekcji LargePersonGroup lub LargeFaceList. Mimo że funkcja LargePersonGroup lub LargeFaceList różni się od elementu PersonGroup lub FaceList w implementacji projektowej i wewnętrznej, interfejsy API są podobne do zgodności z poprzednimi wersjami.
Migracja danych nie jest obsługiwana. Zamiast tego należy ponownie utworzyć element LargePersonGroup lub LargeFaceList .
Migrowanie obiektu PersonGroup do grupy LargePersonGroup
Migracja z obiektu PersonGroup do grupy LargePersonGroup jest prosta. Współużytkują dokładnie te same operacje na poziomie grupy.
W przypadku implementacji personGroup lub powiązanej z osobą należy zmienić tylko ścieżki interfejsu API lub klasę/moduł zestawu SDK na LargePersonGroup i LargePersonGroupPerson.
Dodaj wszystkie twarze i osoby z grupy PersonGroup do nowej grupy LargePersonGroup. Aby uzyskać więcej informacji, zobacz Dodawanie twarzy.
Migrowanie listy FaceList do listy LargeFaceList
| Interfejsy API facelist | Interfejsy API largeFaceList |
|---|---|
| Utwórz | Utwórz |
| Usuń | Delete |
| Get | Get |
| List | List |
| Aktualizacja | Aktualizacja |
| - | Szkolenie |
| - | Pobieranie stanu szkolenia |
Poprzednia tabela jest porównaniem operacji na poziomie listy między FaceList i LargeFaceList. Jak pokazano, aplikacja LargeFaceList zawiera nowe operacje, Train and Get Training Status (Trenowanie i uzyskiwanie stanu trenowania) w porównaniu z aplikacją FaceList. Trenowanie elementu LargeFaceList jest warunkiem wstępnym operacji FindSimilar. Trenowanie nie jest wymagane w przypadku aplikacji FaceList. Poniższy fragment kodu jest funkcją pomocnika, która czeka na szkolenie elementu LargeFaceList:
/// <summary>
/// Helper function to train LargeFaceList and wait for finish.
/// </summary>
/// <remarks>
/// The time interval can be adjusted considering the following factors:
/// - The training time which depends on the capacity of the LargeFaceList.
/// - The acceptable latency for getting the training status.
/// - The call frequency and cost.
///
/// Estimated training time for LargeFaceList in different scale:
/// - 1,000 faces cost about 1 to 2 seconds.
/// - 10,000 faces cost about 5 to 10 seconds.
/// - 100,000 faces cost about 1 to 2 minutes.
/// - 1,000,000 faces cost about 10 to 30 minutes.
/// </remarks>
/// <param name="largeFaceListId">The Id of the LargeFaceList for training.</param>
/// <param name="timeIntervalInMilliseconds">The time interval for getting training status in milliseconds.</param>
/// <returns>A task of waiting for LargeFaceList training finish.</returns>
private static async Task TrainLargeFaceList(
string largeFaceListId,
int timeIntervalInMilliseconds = 1000)
{
// Trigger a train call.
await FaceClient.LargeTrainLargeFaceListAsync(largeFaceListId);
// Wait for training finish.
while (true)
{
Task.Delay(timeIntervalInMilliseconds).Wait();
var status = await faceClient.LargeFaceList.TrainAsync(largeFaceListId);
if (status.Status == Status.Running)
{
continue;
}
else if (status.Status == Status.Succeeded)
{
break;
}
else
{
throw new Exception("The train operation is failed!");
}
}
}
Wcześniej typowe użycie funkcji FaceList z dodanymi twarzami i aplikacją FindSimilar wyglądało następująco:
// Create a FaceList.
const string FaceListId = "myfacelistid_001";
const string FaceListName = "MyFaceListDisplayName";
const string ImageDir = @"/path/to/FaceList/images";
faceClient.FaceList.CreateAsync(FaceListId, FaceListName).Wait();
// Add Faces to the FaceList.
Parallel.ForEach(
Directory.GetFiles(ImageDir, "*.jpg"),
async imagePath =>
{
using (Stream stream = File.OpenRead(imagePath))
{
await faceClient.FaceList.AddFaceFromStreamAsync(FaceListId, stream);
}
});
// Perform FindSimilar.
const string QueryImagePath = @"/path/to/query/image";
var results = new List<SimilarPersistedFace[]>();
using (Stream stream = File.OpenRead(QueryImagePath))
{
var faces = faceClient.Face.DetectWithStreamAsync(stream).Result;
foreach (var face in faces)
{
results.Add(await faceClient.Face.FindSimilarAsync(face.FaceId, FaceListId, 20));
}
}
Podczas migracji do listy LargeFaceList staje się ona następująca:
// Create a LargeFaceList.
const string LargeFaceListId = "mylargefacelistid_001";
const string LargeFaceListName = "MyLargeFaceListDisplayName";
const string ImageDir = @"/path/to/FaceList/images";
faceClient.LargeFaceList.CreateAsync(LargeFaceListId, LargeFaceListName).Wait();
// Add Faces to the LargeFaceList.
Parallel.ForEach(
Directory.GetFiles(ImageDir, "*.jpg"),
async imagePath =>
{
using (Stream stream = File.OpenRead(imagePath))
{
await faceClient.LargeFaceList.AddFaceFromStreamAsync(LargeFaceListId, stream);
}
});
// Train() is newly added operation for LargeFaceList.
// Must call it before FindSimilarAsync() to ensure the newly added faces searchable.
await TrainLargeFaceList(LargeFaceListId);
// Perform FindSimilar.
const string QueryImagePath = @"/path/to/query/image";
var results = new List<SimilarPersistedFace[]>();
using (Stream stream = File.OpenRead(QueryImagePath))
{
var faces = faceClient.Face.DetectWithStreamAsync(stream).Result;
foreach (var face in faces)
{
results.Add(await faceClient.Face.FindSimilarAsync(face.FaceId, largeFaceListId: LargeFaceListId));
}
}
Jak pokazano wcześniej, zarządzanie danymi i część FindSimilar są prawie takie same. Jedynym wyjątkiem jest to, że nowa operacja wstępnego przetwarzania wstępnego musi zakończyć się w largeFaceList przed działaniem findSimilar .
Krok 3. Trenowanie sugestii
Chociaż operacja trenowania przyspiesza działanie FindSimilar i Identification, czas trenowania cierpi, zwłaszcza w przypadku zbliżania się do dużej skali. Szacowany czas trenowania w różnych skalach znajduje się w poniższej tabeli.
| Skalowanie twarzy lub osób | Szacowany czas trenowania |
|---|---|
| 1000 | 1–2 s |
| 10,000 | 5–10 s |
| 100 000 | 1–2 min |
| 1 000 000 | 10-30 min |
Aby lepiej wykorzystać funkcję na dużą skalę, zalecamy następujące strategie.
Krok 3a. Dostosowywanie interwału czasu
Jak pokazano w pliku TrainLargeFaceList(), istnieje interwał czasu w milisekundach, aby opóźnić nieskończony proces sprawdzania stanu trenowania. W przypadku elementu LargeFaceList z większą liczbą twarzy użycie większego interwału zmniejsza liczbę wywołań i koszty. Dostosuj przedział czasu zgodnie z oczekiwaną pojemnością listy LargeFaceList.
Ta sama strategia dotyczy również grupy LargePersonGroup. Na przykład w przypadku trenowania grupy LargePersonGroup z 1 milionami osób timeIntervalInMilliseconds może wynosić 60 000, co jest 1-minutowym interwałem.
Krok 3b. Bufor o małej skali
Osoby lub twarze w grupie LargePersonGroup lub LargeFaceList można wyszukiwać tylko po przeszkoleniu. W scenariuszu dynamicznym nowe osoby lub twarze są stale dodawane i muszą być natychmiast wyszukiwane, ale szkolenie może trwać dłużej niż jest to wymagane.
Aby rozwiązać ten problem, użyj dodatkowej klasy LargePersonGroup lub LargeFaceList jako buforu tylko dla nowo dodanych wpisów. Ten bufor zajmuje krótszy czas trenowania z powodu mniejszego rozmiaru. Natychmiastowe wyszukiwanie w tym tymczasowym buforze powinno działać. Użyj tego buforu w połączeniu ze szkoleniem w master LargePersonGroup lub LargeFaceList , uruchamiając szkolenie główne w interwale rozrzedzanym. Przykłady znajdują się w środku nocy i codziennie.
Przykładowy przepływ pracy:
- Utwórz główny obiekt LargePersonGroup lub LargeFaceList, który jest kolekcją master. Utwórz bufor LargePersonGroup lub LargeFaceList, który jest kolekcją buforów. Kolekcja buforów dotyczy tylko nowo dodanych osób lub twarzy.
- Dodaj nowe osoby lub twarze zarówno do kolekcji głównej, jak i kolekcji buforów.
- Wytrenuj tylko kolekcję buforów z krótkim interwałem czasu, aby upewnić się, że nowo dodane wpisy zostaną zastosowane.
- Wywołaj metodę Identification lub FindSimilar zarówno dla kolekcji głównej, jak i kolekcji buforów. Scal wyniki.
- Gdy rozmiar kolekcji buforów zwiększa się do progu lub w czasie bezczynności systemu, utwórz nową kolekcję buforów. Wyzwól operację Train (Trenowanie) w kolekcji master.
- Usuń starą kolekcję buforów po zakończeniu operacji Train (Trenowanie ) w kolekcji master.
Krok 3c. Trenowanie autonomiczne
Jeśli stosunkowo długie opóźnienie jest akceptowalne, nie jest konieczne wyzwolenie operacji Trenowanie bezpośrednio po dodaniu nowych danych. Zamiast tego operację Trenowanie można podzielić z główną logiką i wyzwalać regularnie. Ta strategia jest odpowiednia dla scenariuszy dynamicznych z dopuszczalnym opóźnieniem. Można go zastosować do scenariuszy statycznych, aby jeszcze bardziej zmniejszyć częstotliwość trenowania.
Załóżmy, że istnieje funkcja podobna TrainLargePersonGroup do TrainLargeFaceList. Typowa implementacja autonomicznego szkolenia w grupie LargePersonGroup przez wywołanie Timer klasy w System.Timers programie to:
private static void Main()
{
// Create a LargePersonGroup.
const string LargePersonGroupId = "mylargepersongroupid_001";
const string LargePersonGroupName = "MyLargePersonGroupDisplayName";
faceClient.LargePersonGroup.CreateAsync(LargePersonGroupId, LargePersonGroupName).Wait();
// Set up standalone training at regular intervals.
const int TimeIntervalForStatus = 1000 * 60; // 1-minute interval for getting training status.
const double TimeIntervalForTrain = 1000 * 60 * 60; // 1-hour interval for training.
var trainTimer = new Timer(TimeIntervalForTrain);
trainTimer.Elapsed += (sender, args) => TrainTimerOnElapsed(LargePersonGroupId, TimeIntervalForStatus);
trainTimer.AutoReset = true;
trainTimer.Enabled = true;
// Other operations like creating persons, adding faces, and identification, except for Train.
// ...
}
private static void TrainTimerOnElapsed(string largePersonGroupId, int timeIntervalInMilliseconds)
{
TrainLargePersonGroup(largePersonGroupId, timeIntervalInMilliseconds).Wait();
}
Aby uzyskać więcej informacji na temat zarządzania danymi i implementacji związanych z identyfikacją, zobacz Dodawanie twarzy.
Podsumowanie
W tym przewodniku przedstawiono sposób migrowania istniejącego kodu PersonGroup lub FaceList, a nie danych do kolekcji LargePersonGroup lub LargeFaceList:
- Funkcja LargePersonGroup i LargeFaceList działają podobnie do obiektu PersonGroup lub FaceList, z tą różnicą, że operacja Train jest wymagana przez largeFaceList.
- Weź odpowiednią strategię trenowania w celu dynamicznej aktualizacji danych dla zestawów danych na dużą skalę.
Następne kroki
Postępuj zgodnie z przewodnikiem z instrukcjami, aby dowiedzieć się, jak dodawać twarze do grupy PersonGroup lub pisać skrypt, aby wykonać operację Identyfikowanie w grupie PersonGroup.