Implementera snabbt spoofing-säker ansiktsigenkänning utan molnanslutning

Ansiktsigenkänning har fått bred acceptans för att låsa upp smarta telefoner, men olika försök att tillämpa denna teknik bredare inom andra områden har inte slagit väl ut trots dess effektivitet och användarvänlighet. Utöver de tekniska utmaningarna med att implementera tillförlitliga, billiga maskininlärningslösningar, måste utvecklare hantera användares oro kring tillförlitligheten och integriteten hos konventionella ansiktsigenkänningsmetoder som är beroende av molnuppkopplingar och som är sårbara för identitetsförfalskningar (spoofing).

I denna artikel diskuterar vi svårigheterna med säker autentisering och presenterar sedan en hårdvaru- och programvarulösning från NXP Semiconductors som tar upp frågorna. Sedan visas hur utvecklare utan tidigare erfarenhet av maskininlärningsmetoder kan använda lösningen för att snabbt implementera spoofing-säker ansiktsigenkänning offline i en smart produkt.

Utmaningen med säker autentisering för smarta produkter

För att hantera en växande oro över säkerheten för smarta produkter har utvecklare haft få hållbara alternativ för tillförlitlig autentisering av användare som letar efter snabb men säker upplåsning. Traditionella metoder bygger på multifaktorautentisering som vilar på någon kombination av de klassiska tre autentiseringsfaktorerna: ”Något du vet”, exempelvis ett lösenord; ”något du har”, exempelvis en fysisk nyckel eller ett nyckelkort och ”något du är”, vilket vanligtvis är en biometrisk faktor som ett fingeravtryck eller iris. Med detta tillvägagångssätt kan ett starkt autentiserat dörrlås kräva att användaren anger ett lösenord, ett nyckelkort och också lämnar sitt fingeravtryck för att låsa upp dörren. I praktiken är sådana stränga krav besvärande eller för opraktiska för konsumenter som ofta och enkelt behöver autentisera sig själva med en smartphone eller annan apparat som används ofta.

Ansiktsigenkänning har avsevärt förenklat autentiseringen för smarttelefonanvändare, men smarta telefoner har vissa fördelar som kanske inte är tillgängliga på alla enheter. Förutom den avsevärda processorkraften som finns i moderna smarta telefoner, är ständig uppkoppling ett grundläggande krav för att leverera det sofistikerade utbudet av tjänster som rutinmässigt förväntas av sina användare.

Men i många produkter som kräver säker autentisering erbjuder den underliggande tekniska plattformen ofta mer blygsamma datorresurser och mer begränsad uppkoppling. Ansiktsigenkänningstjänster från de ledande leverantörerna av molntjänster flyttar processorbelastningen till molnet, men behovet av robust uppkoppling för att säkerställa minimal svarsfördröjning kan ställa krav som ligger utanför plattformens funktioner. Minst lika angelägna för användarna är de integritetsfrågor som uppstår när deras bilder överförs i offentliga nätverk för behandling och eventuellt lagring i molnet.

Med hjälp av NXP Semiconductors i.MX RT106F-processorer och tillhörande programvara, kan utvecklare nu implementera ansiktsigenkänning offline som direkt hanterar dessa problem.

Hårdvara och programvara för spoofingsäker ansiktsigenkänning offline

Som en del i NXP:s familj av i.MX RT1060 Crossover-microcontrollers, är i.MX RT106F-serien speciellt utformad för att stödja enkel integrering av ansiktsigenkänning offline i smart hemelektronik, konsumentapparater, säkerhetsprodukter och industriell utrustning. Processorerna, som bygger på en Arm® Cortex®-M7-processorkärna, körs med 528 MHz för den industriella versionen MIMXRT106FCVL5B eller 600 MHz för processorer av kommersiell kvalitet, t.ex.MIMXRT106FDVL6A ochMIMXRT106FDVL6B.

Förutom att stödja ett brett spektrum av externa minnesgränssnitt, inkluderar i.MX RT106F-processorer 1 Mb RAM med 512 Kb konfigurerat som RAM för allmänt bruk och 512 Kb som kan konfigureras antingen som RAM för allmänt bruk eller som Tightly Coupled Memory för instruktioner (I-TCM) eller data (D-TCM). Utöver on-chip-effekthantering erbjuder dessa processorer en stor mängd integrerade funktioner för grafik, säkerhet, systemkontroll och både analoga och digitala gränssnitt som vanligtvis behövs för att stödja konsumentprodukter, industriella användargränssnitt (HMI) och motorstyrningar ( Figur 1).

Figur 1: NXP Semiconductors i.MX RT106F-processorer kombinerar en komplett uppsättning funktionsblock som behövs för att stödja ansiktsigenkänning för konsument-, industri- och säkerhetsprodukter. (Bildkälla: NXP)

Även om de liknar andra i.MX RT1060-familjemedlemmar, har i.MX RT106F-processorer en körtidslicens medpackad för NXP:s Oasis Lite-program för ansiktsigenkänning. Oasis Lite-runtime-miljön är utformad för snabb inferensförmåga på denna klass av processorer och klarar ansiktsdetektering, igenkänning och t.o.m. viss känsloklassificering med hjälp av NN-inferensmodeller som körs på en inferensmotor och MiniCV - en avskalad version av open source-maskinsynsbiblioteket OpenCV. Inferensmotorn bygger på ett NXP NN-bibliotek och Arm-biblioteket Cortex Microcontroller System Interface Standard NN (CMSIS-NN) (Figur 2).

Figur 2: NXP Oasis Lite runtime-biblioteket innehåller en Oasis Lite-kärna som använder MiniCV och en NXP-inferensmotor byggd på neurala nätverksbibliotek från NXP och Arm. (Bildkälla: NXP)

Inferensmodellerna finns på i.MX RT106F-plattformen, så ansiktsdetektering och -igenkänning utförs lokalt, till skillnad från andra lösningar som är beroende av molnbaserade resurser för att köra maskininlärningsalgoritmerna. Tack vare denna ansiktsigenkänningsfunktion offline, kan utvecklare av smarta produkter säkerställa privat, säker autentisering trots låg bandbredd eller oregelbunden internetuppkoppling. Dessutom sker autentisering snabbt med denna hårdvaru- och mjukvarukombination; det tar mindre än 800 ms för processorn att vakna upp från lågeffekt-standby till genomförd ansiktsigenkänning.

Om det används med i.MX RT106F-processorn förenklar Oasis Lite körtidsimplementeringen av ansiktsigenkänning offline för smarta produkter, men processorn och körtidsmiljön är naturligtvis bara en del av en nödvändig systemlösning. Tillsammans med en mer komplett uppsättning systemkomponenter kräver en effektiv autentiseringslösning avbildningskapacitet som kan mildra en typ av säkerhetshot som kallas presentationsattacker. Dessa attacker försöker förfalska autentisering av ansiktsigenkänning med hjälp av foton. För utvecklare som snabbt vill distribuera ansiktsbaserad autentisering i sina egna produkter, erbjuder NXP:s utvecklingssats SLN-VIZNAS-IOT och tillhörande programvara en användningsklar plattform för utvärdering, prototypframtagning och utveckling av spoofingsäker ansiktsigenkänning offline.

Komplett, säker systemlösning för ansiktsigenkänning

Som med de flesta avancerade processorer behöver i.MX RT106F-processorn bara några få extra komponenter för att kunna erbjuda en effektiv processningsplattform. NXP:s SLN-VIZNAS-IOT-sats kompletterar systemet genom att integrera i.MX RT106F med fler enheter för att erbjuda en komplett hårdvaruplattform (Figur 3).

Figur 3: NXP SLN-VIZNAS-IOT-satsen innehåller en ansluten modul som ger en robust ansluten systemplattform som behövs för att köra autentiseringsprogramvara. (Bildkälla: NXP)

Satsens anslutna modulkort kombinerar en NXP MIMXRT106FDVL6A i.MX RT106F-processor, ett NXP A71CH-säkerhetselement och två anslutningsmöjligheter - NXPMKW41Z512VHT4 Kinetis KW41Z Bluetooth Low Energy (BLE) system-on-chip (SoC) och Murata Electronics Wi-Fi/Bluetooth-modul LBEE5KL1DX-883.

För att komplettera processorns integrerade minne bidrar den anslutna modulen med Winbond Electronics W9825G6JB 256 Mbit SDRAM, Integrated Silicon Solutions (ISSI) IS26KL256S-DABLI00 256 Mbit NOR-Flash och ISSI:s IS25LP256D 256 Mbit Quad Serial Peripheral Interface (SPI)-enhet.

Slutligen bidrar modulen även med en Torex Semiconductor XCL214B333DR buck-omvandlare för att komplettera i.MX RT106F-processorns interna energihanteringsfunktioner för de tillkommande enheterna på det anslutna modulkortet.

Den anslutna modulen är i sin tur monterad på ett maskinsynsapplikationskort som kombinerar en passiv infraröd sensor (IRA-S210ST01) från Murata Electronics, rörelsesensor, batteriladdare, ljudsupport, lysdioder, knappar och gränssnittskontakter (Figur 4).

Figur 4: I NXP SLN-VIZNAS-IOT-satsen är den anslutna modulen (vänster) ansluten till maskinsynsapplikationskortet för att erbjuda hårdvarufundamentet för ansiktsigenkänning. (Bildkälla: NXP)

Utöver denna systemplattform behöver ett system för ansiktsigenkänning så klart en lämplig kamerasensor för att registrera en bild av användarens ansikte. Som nämnts tidigare gör emellertid risken för presentationsattacker att ytterligare avbildningsfunktioner krävs.

Att riskminska presentationsattacker

Forskare har i flera år utforskat olika PAD-metoder (presentation attack detection) som är utformade för att mildra försök att använda sekundära fingeravtryck eller bilder av ett ansikte för att lura biometriskt baserade autentiseringssystem. Även om dess detaljer ligger långt utanför denna artikel fokus, använder PAD-metoder i allmänhet djupanalys av kvaliteten och egenskaperna hos den biometriska data som fångas in som en del av processen, samt metoder för att detektera "levandeheten" - att avgöra om den biometriska datan har kommit från en levande person. Bakom många av dessa olika metoder spelar djupa neurala nätverk-modeller en viktig roll, inte bara för ansiktsigenkänning utan också för att identifiera försök att lura systemet. Det bildsystem som används för att fånga användarens ansikte kan dock ge ytterligare stöd för detektering av levandehet.

I NXP:s SLN-VIZNAS-IOT-sats ingår kameramoduler som innehåller ett par ON Semiconductor MT9M114-bildsensorer. Här är en kamera utrustad med ett RGB-filter och den andra kameran är utrustad med ett IR-filter. RGB-kameran, som är ansluten via kameragränssnitt till maskinsynsapplikationskortet, genererar en normal bild i synligt ljus medan IR-kameran tar en bild som blir annorlunda för en levande person jämfört med en bild av en bild av personen. SLN-VIZNAS-IOT-satsen använder ansiktsigenkänning offline tillsammans med sin interna ansiktsigenkänning och ger spoofing-säker ansiktsigenkänning offline i ett format på ca 30 x 40 mm (Figur 5).

Figur 5: NXP SLN-VIZNAS-IOT hårdvarusats integrerar ett dubbelt kamerasystem för att detektera "levandehet" (överst) och ett maskinsynsapplikationskort (nederst) med en ansluten modul för att ge en användningsklar lösning för ansiktsigenkänning offline med spoofing-säker funktion. (Bildkälla: NXP)

Komma igång med SLN-VIZNAS-IOT-satsen

NXP SLN-VIZNAS-IOT-satsen levereras färdig att användas med inbyggda ansiktsigenkänningsmodeller. En utvecklare kan koppla in en USB-kabel och trycka på en knapp på enheten för att utföra en enkel manuell ansiktsregistrering med den förinstallerade “elock”-appen och den medföljande mobilappen (Figur 6, vänster). Efter registrering kommer mobilappen att visa meddelandet Welcome home och en upplåst symbol när satsen autentiserar det registrerade ansiktet (Figur 6, höger).

Figur 6: NXP SLN-VIZNAS-IOT hårdvarusats fungerar direkt från lådan och använder en medföljande app för att registrera ett ansikte (vänster) och känna igen registrerade ansikten (höger). (Bildkälla: NXP)

Ansiktsigenkänningsmjukvaran Oasis Lite processar modeller från sin databas med upp till 3000 RGB-ansikten med en igenkänningsnoggrannhet på 99,6 % och upp till 100 IR-ansikten med en spoofing-säkerhet på 96,5 %. Som tidigare nämnts behöver NXP:s hård- och mjukvarulösning mindre än en sekund för att utföra ansiktsdetektering, bildjustering, kvalitetskontroll, "livs"-detektering och igenkänning över ett intervall på 0,2 till 1,0 m. I själva verket stöder systemet en även annan “ljus”-inferensmodell som kan utföra samma sekvens på mindre än 0,5 s men stöder en mindre maximal databasstorlek på 1000 RGB-ansikten och 50 IR-ansikten.

Bygga anpassade ansiktsigenkänningsapplikationer

NXP SLN-VIZNAS-IOT-satsen, om den används direkt ur lådan, gör det möjligt för utvecklare att snabbt utvärdera, prototypbygga och utveckla ansiktsigenkänningsapplikationer. Om ni skapar egna hårdvarulösningar fungerar satsen som en komplett referenskonstruktion med kompletta scheman och en detaljerad materiallista (BOM). För mjukvaruutveckling kan programmerare använda den integrerade utvecklingsmiljön NXP MCUXpresso med FreeRTOS-baserade support- och konfigurationsverktyg. För denna applikation kan utvecklare helt enkelt använda NXP:s MCUXpresso SDK Builder online för att konfigurera sin mjukvaruutvecklingsmiljö med NXP:s VIZNAS SDK, som inkluderar NXP Oasis Lite maskininlärningsmotor för maskinsyn (Figur 7).

Figur 7: NXP erbjuder en omfattande programvarumiljö som kör NXP Oasis Lites körtidsbibliotek och verktygsmellanprogramvara på FreeRTOS. (Bildkälla: NXP)

Programvarupaketet innehåller fullständig källkod för driftsmiljön samt den tidigare nämnda appen elock. NXP tillhandahåller inte källkod för sin egen Oasis Lite-motor eller för modellerna. Istället arbetar utvecklare med Oasis Lites körtidsbibliotek med hjälp av det API:et som ingår, vilket innehåller en uppsättning intuitiva funktionsanrop för att utföra åtgärder som stöds. Dessutom använder utvecklare en given uppsättning C-definer och -strukturer för att specificera olika parametrar som bildstorlek, minnestilldelning, återanrop och aktiverade funktioner som används av systemet när Oasis Lite-körtidsmiljön startas (Kodexempel 1).

Kopiera
typedef struct {
    //max input image height, width and channel, min_face: minimum face can be detected
    int height;
    int width;
  
    //only valid for RGB images; for IR image, always GREY888 format
    OASISLTImageFormat_t img_format;
    OASISLTImageType_t img_type;
  
    //min_face should not smaller than 40
    int min_face;
  
    /*memory pool pointer, this memory pool should only be used by OASIS LIB*/
    char* mem_pool;
  
    /*memory pool size*/
    int size;
  
    /*output parameter,indicate authenticated or not*/
    int auth;
  
    /*callback functions provided by caller*/
    InfCallbacks_t cbs;
  
    /*what functions should be enabled in OASIS LIB*/
    uint8_t enable_flags;
  
    /*only valid when OASIS_ENABLE_EMO is activated*/
    OASISLTEmoMode_t emo_mode;
  
    /*false accept rate*/
    OASISLTFar_t false_accept_rate;
  
    /*model class */
    OASISLTModelClass_t mod_class;
  
} OASISLTInitPara_t;

Kodexempel 1: Utvecklare kan ändra programexekveringsparametrar genom att ändra innehållet i strukturer som den som visas här för Oasis Lites körtidsinitialisering. (Kodkälla: NXP)

Elock-applikationskoden visar de viktigaste konstruktionsmönstren för att starta Oasis som en arbetsuppgift som körs under FreeRTOS, initierar miljön och går in i sitt normala exekveringsläge. I exekveringssteget arbetar körtidsmiljön på varje ruta av en bild och utför de angivna återanropsfunktionerna associerade med varje händelse definierad i miljön (Kodexempel 2).

Kopiera
typedef enum {
    /*indicate the start of face detection, user can update frame data if it is needed.
     * all parameter in callback parameter is invalid.*/
    OASISLT_EVT_DET_START,
  
    /*The end of face detection.
     *if a face is found, pfaceBox(OASISLTCbPara_t) indicated the rect(left,top,right,bottom point value)
     *info and landmark value of the face.
     *if no face is found,pfaceBox is NULL, following event will not be triggered for current frame.
     *other parameter in callback parameter is invalid */
    OASISLT_EVT_DET_COMPLETE,
  
    /*Face quality check is done before face recognition*/
    OASISLT_EVT_QUALITY_CHK_START,
    OASISLT_EVT_QUALITY_CHK_COMPLETE,
  
    /*Start of face recognition*/
    OASISLT_EVT_REC_START,
  
    /*The end of face recognition.
     * when face feature in current frame is gotten, GetRegisteredFaces callback will be called to get all
     * faces feature registered and OASIS lib will try to search this face in registered faces, if this face
     * is matched, a valid face ID will be set in callback parameter faceID and corresponding simularity(indicate
     * how confidence for the match) also will be set.
     * if no face match, a invalid(INVALID_FACE_ID) will be set.*/
    OASISLT_EVT_REC_COMPLETE,
  
    /*start of emotion recognition*/
    OASISLT_EVT_EMO_REC_START,
  
    /*End of emotion recognition, emoID indicate which emotion current face is.*/
    OASISLT_EVT_EMO_REC_COMPLETE,
  
    /*if user set a registration flag in a call of OASISLT_run and a face is detected, this two events will be notified
     * for auto registration mode, only new face(not recognized) is added(call AddNewFace callback function)
     * for manu registration mode, face will be added forcely.
     * for both cases, face ID of new added face will be set in callback function */
    OASISLT_EVT_REG_START,
    /*when registration start, for each valid frame is handled,this event will be triggered and indicate
     * registration process is going forward a little.
     * */
    OASISLT_EVT_REG_IN_PROGRESS,
    OASISLT_EVT_REG_COMPLETE,
    OASISLT_EVT_NUM
  
} OASISLTEvt_t;

Kodexempel 2: Oasis Lite-körtiden känner igen en serie händelser som dokumenterats som en uppräknad mängd i Oasis Lite-körtidens huvudfil. (Kodkälla: NXP)

Exempelapplikationen kan ge utvecklare stegvisa felsökningsmeddelanden som beskriver resultaten förknippade med varje händelse som behandlas av händelsehanteraren (EvtHandler). Exempelvis: efter att kvalitetskontrollen är klar (OASISLT_EVT_QUALITY_CHK_COMPLETE), skriver systemet ut felsökningsmeddelanden som beskriver resultatet, och efter att ansiktsigenkänningen har slutförts (OASISLT_EVT_REC_COMPLETE), hämtar systemet användar-id och -namn från sin databas för igenkända ansikten och skriver ut den informationen (Kodexempel 3).

Kopiera
static void EvtHandler(ImageFrame_t *frames[], OASISLTEvt_t evt, OASISLTCbPara_t *para, void *user_data)
{
[code redacted for simplification]
        case OASISLT_EVT_QUALITY_CHK_COMPLETE:
        {
            UsbShell_Printf("[OASIS]:quality chk res:%d\r\n", para->qualityResult);
  
            pQMsg->msg.info.irLive  = para->reserved[5];
            pQMsg->msg.info.front   = para->reserved[1];
            pQMsg->msg.info.blur    = para->reserved[3];
            pQMsg->msg.info.rgbLive = para->reserved[8];
  
            if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_OK_WITHOUT_GLASSES ||
                para->qualityResult == OASIS_QUALITY_RESULT_FACE_OK_WITH_GLASSES)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:ok!\r\n");
            }
            else if (OASIS_QUALITY_RESULT_FACE_SIDE_FACE == para->qualityResult)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:side face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_TOO_SMALL)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:Small Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_BLUR)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: Blurry Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FAIL_LIVENESS_IR)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: IR Fake Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FAIL_LIVENESS_RGB)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: RGB Fake Face!\r\n");
            }
        }
        break;
[code redacted for simplification]
        case OASISLT_EVT_REC_COMPLETE:
        {
            int diff;
            unsigned id                     = para->faceID;
            OASISLTRecognizeRes_t recResult = para->recResult;
  
            timeState->rec_comp = Time_Now();
            pQMsg->msg.info.rt  = timeState->rec_start - timeState->rec_comp;
            face_info.rt        = pQMsg->msg.info.rt;
#ifdef SHOW_FPS
            /*pit timer unit is us*/
            timeState->rec_fps++;
            diff = abs(timeState->rec_fps_start - timeState->rec_comp);
            if (diff > 1000000 / PIT_TIMER_UNIT)
            {
                // update fps
                pQMsg->msg.info.recognize_fps = timeState->rec_fps * 1000.0f / diff;
                timeState->rec_fps            = 0;
                timeState->rec_fps_start      = timeState->rec_comp;
            }
#endif
            memset(pQMsg->msg.info.name, 0x0, sizeof(pQMsg->msg.info.name));
  
            if (recResult == OASIS_REC_RESULT_KNOWN_FACE)
            {
                std::string name;
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face id:%d\r\n", id);
                DB_GetName(id, name);
                memcpy(pQMsg->msg.info.name, name.c_str(), name.size());
                face_info.recognize = true;
                face_info.name      = std::string(name);
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face id:%d name:%s\r\n", id, pQMsg->msg.info.name);
            }
            else
            {
                // face is not recognized, do nothing
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face unrecognized\r\n");
                face_info.recognize = false;
            }
  
            VIZN_RecognizeEvent(gApiHandle, face_info);
        }
        break;

Kodexempel 3: Som visas i detta utdrag från ett applikationsexempel i NXP-mjukvarudistributionen behandlar en händelsehanterare händelser som påträffats under ansiktsigenkänningssekvensen. (Kodkälla: NXP)

Förutom att den stödjer processningskraven för ansiktsigenkänning, är NXP SLN-VIZNAS-IOT-programvaran utformad för att skydda driftsmiljön. För att säkerställa körtidssäkerheten är systemet utformat för att verifiera integriteten och äktheten för varje signerad bild som laddas in i systemet med hjälp av ett certifikat som är lagrat i SLN-VIZNAS-IOT-satsens filsystem. Eftersom denna verifieringssekvens börjar med en betrodd startladdare lagrad i ROM, ger denna process en tillförlitlig kedja för att köra applikationsfirmware. Eftersom kodsignering och -verifiering kan bromsa utvecklingen, är denna verifieringsprocess designad för att förbikopplas under programvaruutveckling och felsökning. SLN-VIZNAS-IOT-satsen levereras faktiskt förladdad med signerade bilder, men kodsignaturverifieringen är inte aktiverad som standard. Utvecklare kan enkelt ställa in inställningar för att aktivera fullständig kodsignaturverifiering för produktionsversioner.

Tillsammans med körtidsmiljön och den tillhörande exempelapplikationskoden erbjuder NXP Android-mobilappar med fullständig Java-källkod. En app, VIZNAS FaceRec Manager, ger ett enkelt gränssnitt för att registrera ansikten och hantera användare. En annan app, VIZNAS Companion, låter användare förse satsen med Wi-Fi-referenser med en befintlig Wi-Fi- eller BLE-anslutning.

Slutsats

Ansiktsigenkänning erbjuder ett effektivt tillvägagångssätt för att autentisera upplåsning av smarta produkter, men att implementera det har vanligtvis krävt lokal hög processorprestanda eller en stabil uppkoppling med hög bandbredd för snabba svar. Det har också varit ett mål för spoofing-attacker och det finns en oro för användarintegriteten.

Som vi visat erbjuder en specialiserad processor och mjukvarubibliotek från NXP Semiconductors ett alternativt tillvägagångssätt som exakt kan utföra ansiktsigenkänning offline på mindre än en sekund utan molnuppkoppling, samtidigt som spoofingförsök kan förhindras.