Skálázás több regisztrált felhasználó kezeléséhez

Figyelemfelhívás

A Face Service hozzáférése a jogosultsági és használati feltételek alapján korlátozott a felelős AI-alapelvek támogatása érdekében. A Face service csak a Microsoft által felügyelt ügyfelek és partnerek számára érhető el. A Hozzáférés igényléséhez használja a Face Recognition beviteli űrlapot . További információt a Face korlátozott hozzáférésű oldalán talál.

Ez az útmutató bemutatja, hogyan skálázhat fel a meglévő PersonGroup- és FaceList-objektumokról a LargePersonGroup és a LargeFaceList objektumokra. A PersonGroups legfeljebb 1000 személyt tarthat az ingyenes szinten, 10 000 személyt pedig a fizetős szinten, míg a LargePersonGroups akár egymillió személyt is tarthat a fizetős szinten.

Fontos

Az új fejlesztéshez a PersonDirectory újabb adatstruktúrája ajánlott. Akár 75 millió identitást is tartalmazhat, és nem igényel manuális betanítást. További információkért tekintse meg a PersonDirectory útmutatót.

Ez az útmutató bemutatja a migrálási folyamatot. Alapszintű ismeretet feltételez a PersonGroup és a FaceList objektumokról, a Betanítási műveletről és az arcfelismerési funkciókról. Ha többet szeretne megtudni ezekről a témákról, tekintse meg az arcfelismerési fogalmi útmutatót.

A LargePersonGroup és a LargeFaceList együttes elnevezése nagy léptékű műveletek. A LargePersonGroup legfeljebb 1 millió személyt tartalmazhat, egyenként legfeljebb 248 arccal. A LargeFaceList legfeljebb 1 millió arcot tartalmazhat. A nagy léptékű műveletek hasonlóak a hagyományos PersonGrouphoz és FaceListhez , de az új architektúra miatt van némi különbség.

A minták C# nyelven vannak megírva az Azure AI Face ügyfélkódtár használatával.

Feljegyzés

Az Azonosítás és a FindSimilar arckeresési teljesítményének nagy léptékű engedélyezéséhez betanítási műveletet vezet be a LargeFaceList és a LargePersonGroup előfeldolgozásához. A betanítási idő másodperctől körülbelül fél óráig változhat a tényleges kapacitástól függően. A betanítási időszak alatt lehetőség van az Azonosítás és a FindSimilar elvégzésére, ha korábban sikeres betanítást hajtottak végre. A hátránya az, hogy az új hozzáadott személyek és arcok csak akkor jelennek meg az eredményben, ha a nagy méretű képzésre való áttelepítés utáni új folyamat be nem fejeződik.

1. lépés: Az ügyfélobjektum inicializálása

A Face-ügyfélkódtár használatakor a kulcs és az előfizetés végpontja a FaceClient osztály konstruktorán keresztül lesz átadva. A Face-ügyfélobjektumok létrehozásával kapcsolatos útmutatásért tekintse meg a rövid útmutatót .

2. lépés: Kódmigrálás

Ez a szakasz arra összpontosít, hogyan migrálhatja a PersonGroup vagy a FaceList implementációt a LargePersonGroupba vagy a LargeFaceListbe. Bár a LargePersonGroup vagy a LargeFaceList a tervezés és a belső implementáció szempontjából eltér a PersonGroup-tól vagy a FaceList-től, az API-felületek hasonlóak a visszamenőleges kompatibilitáshoz.

Az adatmigrálás nem támogatott. Ehelyett újra létre kell hoznia a LargePersonGroup vagy a LargeFaceList fájlt .

PersonGroup migrálása LargePersonGroup-ba

A PersonGroup-ból a LargePersonGroupba való migrálás egyszerű. Pontosan ugyanazokkal a csoportszintű műveletekkel rendelkeznek.

PersonGroup vagy személyhez kapcsolódó implementáció esetén csak az API-útvonalakat vagy az SDK-osztályt/modult kell a LargePersonGroup és a LargePersonGroupperson verzióra módosítani.

Adja hozzá a PersonGroup összes arcát és személyét az új LargePersonGrouphoz. További információ: Arcok hozzáadása.

FaceList migrálása LargeFaceList-listára

FaceList API-k	LargeFaceList API-k
Létrehozás	Létrehozás
Törlés	Törlés
Beolvasás	Lekérés
Lista	Lista
Frissítés	Frissítés
-	Betanítás
-	Betanítási állapot lekérdezése

Az előző táblázat a FaceList és a LargeFaceList listaszintű műveleteinek összehasonlítása. Ahogy látható, a LargeFaceList új műveleteket, betanítási és betanítási állapotot tartalmaz a FaceList-hez képest. A LargeFaceList betanítása a FindSimilar művelet előfeltétele. A FaceList használatához nincs szükség betanításra. A következő kódrészlet egy segédfüggvény, amely megvárja a LargeFaceList betanítását:

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

Korábban a FaceList és a FindSimilar tipikus használata a következőhöz hasonlóan nézett ki:

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

A LargeFaceListre való migráláskor a következő lesz:

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

Ahogy korábban is láthattuk, az adatkezelés és a FindSimilar rész szinte megegyezik. Az egyetlen kivétel az, hogy a FindSimilar működése előtt egy friss előfeldolgozási vonatműveletnek be kell fejeződnie a LargeFaceListben.

3. lépés: Javaslatok betanítása

Bár a Betanítási művelet felgyorsítja a FindSimilar és az Azonosítás használatát, a betanítási idő elszenvedődik, különösen nagy léptékű betanítás esetén. A különböző méretekben becsült betanítási idő az alábbi táblázatban található.

Arcok vagy személyek méretezése	Becsült betanítási idő
1000	1-2 mp
10,000.	5-10 másodperc
100 000	1-2 perc
1,000,000	10-30 perc

A nagy léptékű funkció jobb kihasználása érdekében az alábbi stratégiákat javasoljuk.

3a. lépés: Az időintervallum testreszabása

Ahogy az látható TrainLargeFaceList(), ezredmásodpercben van egy időintervallum, amely késlelteti a végtelen betanítási állapot-ellenőrzési folyamatot. A több arcot tartalmazó LargeFaceList esetén a nagyobb időközök csökkentik a hívásszámot és a költségeket. Szabja testre az időintervallumot a LargeFaceList várt kapacitásának megfelelően.

Ugyanez a stratégia a LargePersonGroupra is vonatkozik. Ha például egy 1 millió fős LargePersonGroupot tanít be, timeIntervalInMilliseconds az 60 000 lehet, ami 1 perces időköz.

3b. lépés: Kis léptékű puffer

A LargePersonGroupban vagy a LargeFaceListben lévő személyek vagy arcok csak a betanítása után kereshetők. Dinamikus forgatókönyv esetén a rendszer folyamatosan új személyeket vagy arcokat ad hozzá, és azonnal kereshetőnek kell lennie, de a betanítás a kívántnál tovább tarthat.

A probléma megoldásához használjon egy extra kis méretű LargePersonGroup vagy LargeFaceList puffert csak az újonnan hozzáadott bejegyzésekhez. A puffer betanítása a kisebb méret miatt rövidebb időt vesz igénybe. Az ideiglenes puffer azonnali keresési funkciójának működnie kell. Használja ezt a puffert a Master LargePersonGroup vagy a LargeFaceList betanításával kombinálva, ha a fő betanítást ritkán futtatja. Ilyenek például az éjszaka közepén és naponta.

Példa munkafolyamat:

1. Hozzon létre egy master LargePersonGroup vagy LargeFaceList nevű mestergyűjteményt. Hozzon létre egy Puffer LargePersonGroup vagy LargeFaceList nevű puffergyűjteményt. A puffergyűjtemény csak újonnan hozzáadott személyek vagy arcok számára készült.
2. Adjon hozzá új személyeket vagy arcokat a főgyűjteményhez és a puffergyűjteményhez is.
3. Az újonnan hozzáadott bejegyzések érvénybe léptetéséhez csak rövid időintervallummal tanítsa be a puffergyűjteményt.
4. Hívásazonosítás vagy FindSimilar a főgyűjtemény és a puffergyűjtemény ellen. Egyesítse az eredményeket.
5. Ha a puffergyűjtés mérete küszöbértékre vagy rendszer üresjárati időpontra nő, hozzon létre egy új puffergyűjteményt. Indítsa el a Betanítás műveletet a főgyűjteményen.
6. Törölje a régi puffergyűjteményt, miután a Betanítási művelet befejeződött a főgyűjteményen.

3c. lépés: Önálló betanítás

Ha viszonylag hosszú késés elfogadható, nem szükséges közvetlenül az új adatok hozzáadása után aktiválni a betanítási műveletet. Ehelyett a betanítási művelet felosztható a fő logikából, és rendszeresen aktiválható. Ez a stratégia elfogadható késésű dinamikus forgatókönyvekhez alkalmas. Statikus forgatókönyvekre is alkalmazható a vonatok gyakoriságának további csökkentése érdekében.

Tegyük fel, hogy a TrainLargePersonGroup függvény hasonló.TrainLargeFaceList A LargePersonGroup önálló képzésének tipikus megvalósítása az Timer osztály System.Timers meghívásával:

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

Az adatkezeléssel és az azonosítással kapcsolatos implementációkkal kapcsolatos további információkért lásd: Arcok hozzáadása.

Összegzés

Ebben az útmutatóban megtanulta, hogyan migrálhatja a meglévő PersonGroup- vagy FaceList-kódot, nem pedig az adatokat a LargePersonGroup vagy a LargeFaceList fájlba:

• A LargePersonGroup és a LargeFaceList hasonlóan működik, mint a PersonGroup vagy a FaceList, kivéve, hogy a LargeFaceList megköveteli a betanításiműveletet.
• A nagy léptékű adathalmazok dinamikus adatfrissítéséhez használja a megfelelő betanítási stratégiát.

Következő lépések

Útmutatót követve megtudhatja, hogyan adhat hozzá arcokat a PersonGrouphoz, vagy hogyan írhat szkriptet a PersonGroup azonosítási műveletéhez.

• Arcok hozzáadása
• Face ügyféloldali kódtár – rövid útmutató