Implementer hurtigt spoofing-resistent ansigtsgenkendelse uden en cloud-forbindelse

Ansigtsgenkendelse har fået bred accept for autentificering af adgang til smartphones, men forsøg på at anvende denne teknologi bredere er mangelfuld på andre områder på trods af dens effektivitet og brugervenlighed. Ud over de tekniske udfordringer ved at implementere pålidelige, billige maskinlæringsløsninger, skal udviklere tackle brugernes bekymringer omkring pålideligheden og fortroligheden af konventionelle ansigtsgenkendelsesmetoder, der afhænger af cloud-forbindelser, der er sårbare over for spoofing.

Denne artikel diskuterer vanskelighederne med sikker godkendelse, før der introduceres en hardware- og softwareløsning fra NXP Semiconductors der løser problemerne. Derefter viser det, hvordan udviklere uden forudgående erfaring med maskinlæringsmetoder kan bruge løsningen til hurtigt at implementere offline anti-spoofing ansigtsgenkendelse i et smart produkt.

Udfordringerne ved sikker godkendelse af smart-produkter

Ved at imødegå voksende bekymringer om sikkerheden af smarte produkter har udviklere fundet sig tilbage med få holdbare muligheder for pålidelig godkendelse af brugere på udkig efter hurtig, men sikker adgang. Traditionelle metoder er afhængige af multifaktor autentificeringsmetoder, der hviler på en kombination af de klassiske tre autentificeringsfaktorer: "Noget du kender", såsom et kodeord; “Noget du har”, såsom en fysisk nøgle eller et nøglekort; og ”Noget du er”, som typisk er en biometrisk faktor som f.eks. et fingeraftryk eller en iris. Ved hjælp af denne tilgang kan en stærkt godkendt dørlås muligvis kræve, at brugeren indtaster en adgangskode, bruger et nøglekort og yderligere giver et fingeraftryk for at låse døren op. I praksis er sådanne strenge krav generende eller simpelthen upraktiske for forbrugere, der ofte og let har brug for at godkende sig selv med en smartphone eller anden rutinemæssigt brugt enhed.

Brug af ansigtsgenkendelse har signifikant forenklet godkendelse for smartphone-brugere, men smartphones har nogle fordele, som muligvis ikke er tilgængelige på alle enheder. Udover den betydelige processorkraft, der er tilgængelig i avancerede smartphones, er altid tilsluttet forbindelse et grundlæggende krav for at levere det sofistikerede udvalg af tjenester, der rutinemæssigt forventes af deres brugere.

For mange produkter, der kræver sikker godkendelse, vil den underliggende driftsplatform typisk give mere beskedne computerressourcer og mere begrænset forbindelse. Ansigtsgenkendelsestjenester fra de førende cloud-tjenesteudbydere flytter behandlingsbelastningen til cloud'en. Men behovet for robust tilslutningsmuligheder for at sikre minimal reaktionstid kan muligvis stille krav, der ligger ud over platformens muligheder. Af samme eller mere bekymring for brugerne rejser deres image på tværs af offentlige netværk til behandling og potentielt lagring af det i skyen væsentlige fortrolighedsproblemer.

Brug af NXP Semiconductors' i.MX RT106F processorer og tilhørende software, kan udviklere nu implementere offline ansigtsgenkendelse, der direkte løser disse bekymringer.

Hardware og software til spoof-proof offline ansigtsgenkendelse

Et medlem af NXP i.MX RT1060 Crossover-microcontroller (MCU) -familien, NXP i.MX RT106F-serien, er specielt designet til at understøtte let integration af offline ansigtsgenkendelse i smarte hjemmeapparater, forbrugsapparater, sikkerhedsudstyr og industrielt udstyr. Baseret på en Arm® Cortex®-M7 processorkerne, processorer kører på 528 megahertz (MHz) til industriel kvalitet MIMXRT106FCVL5B, eller 600 MHz til processorer af kommerciel kvalitet som f.eks MIMXRT106FDVL6A og MIMXRT106FDVL6B .

Udover at understøtte en bred vifte af eksterne hukommelsesgrænseflader inkluderer i.MX RT106F-processorer 1 megabyte (Mbyte) on-chip random access memory (RAM) med 512 kilobyte (Kbyte) konfigureret som generel RAM og 512 Kbytes, der kan konfigureres enten som generel RAM eller som tæt koblet hukommelse (TCM) til instruktioner (I-TCM) eller data (D-TCM). Sammen med on-chip strømstyring tilbyder disse processorer et omfattende sæt integrerede funktioner til grafik, sikkerhed, systemkontrol og både analoge og digitale grænseflader, der typisk er nødvendige for at understøtte forbrugsenheder, industrielle menneskelige maskingrænseflader (HMI'er) og motorkontrol ( Figur 1).

Figur 1: NXP Semiconductors i.MX RT106F-processorer kombinerer et komplet sæt funktionelle blokke, der er nødvendige for at understøtte ansigtsgenkendelse for forbruger-, industri- og sikkerhedsprodukter. (Billedkilde: NXP)

Selvom de ligner andre i.MX RT1060-familiemedlemmer, samles i.MX RT106F-processorer i en runtime-licens til NXPs Oasis Lite-ansigtsgenkendelsessoftware. Oasis Lite runtime-miljøet er designet til at fremskynde inferens på denne klasse af processorer og udfører ansigtsgenkendelse, genkendelse og endog begrænset følelsesklassificering ved hjælp af neurale netværk (NN) inferensmodeller, der kører på en inferensmotor og MiniCV - en afskåret version af den åbne kilde OpenCV computer vision bibliotek. Inferensmotoren bygger på et NXP NN-bibliotek og Arm Cortex Microcontroller System Interface Standard NN (CMSIS-NN) -biblioteket (figur 2).

Figur 2: NXP Oasis Lite runtime-biblioteket inkluderer en Oasis Lite-kerne, der bruger MiniCV og en NXP-inferensmotor bygget på neurale netværksbiblioteker fra NXP og Arm. (Billedkilde: NXP)

Slutningsmodellerne ligger på i.MX RT106F-platformen, så ansigtsgenkendelse og -genkendelse udføres lokalt i modsætning til andre løsninger, der er afhængige af cloud-baserede ressourcer for at køre maskinlæringsalgoritmerne. Takket være denne offline ansigtsgenkendelsesfunktion kan designere af smarte produkter sikre privat, sikker godkendelse på trods af lav båndbredde eller plettet internetforbindelse. Derudover går godkendelse hurtigt med denne hardware- og softwarekombination, hvilket kræver mindre end 800 millisekunder (ms) for processoren at vågne fra standby med lav effekt og komplet ansigtsgenkendelse.

Anvendt med i.MX RT106F-processoren forenkler Oasis Lite-runtime implementeringen af offline ansigtsgenkendelse til smart-produkter, men processoren og runtime-miljøet er naturligvis kun en del af en påkrævet systemløsning. Sammen med et mere komplet sæt systemkomponenter kræver en effektiv godkendelsesløsning billedbehandlingskapacitet, der kan afbøde en type sikkerhedstrussel kaldet præsentationsangreb. Disse angreb forsøger at forfalske godkendelse af ansigtsgenkendelse ved hjælp af fotografier. For udviklere, der hurtigt ønsker at implementere ansigtsbaseret godkendelse i deres egne produkter, NXP SLN-VIZNAS-IOT udviklingskit og tilhørende software giver en klar til brug-platform til evaluering, prototyping og udvikling af offline, anti-spoofing ansigtsgenkendelse.

Komplet sikker systemløsning til ansigtsgenkendelse

Som med de fleste avancerede processorer, kræver i.MX RT106F-processor kun et par ekstra komponenter for at give en effektiv computerplatform. NXP SLN-VIZNAS-IOT-sættet fuldender designet ved at integrere i.MX RT106F med yderligere enheder for at give en komplet hardwareplatform (figur 3).

Figur 3: NXP SLN-VIZNAS-IOT-sættet inkluderer et tilsluttet modul, der giver en robust tilsluttet systemplatform, der er nødvendig for at køre godkendelsessoftware. (Billedkilde: NXP)

Sættets tilsluttede modulkort kombinerer en NXP MIMXRT106FDVL6A i.MX RT106F-processor, en NXP A71CH sikkert element og to tilslutningsmuligheder - NXP'er MKW41Z512VHT4 Kinetis KW41Z Bluetooth-lavenergi (BLE) system-on-chip (SoC) ogMurata Electronics ''LBEE5KL1DX-883 Wi-Fi/Bluetooth-modul.

For at supplere processorens on-chip-hukommelse tilføjer det tilsluttede modul Winbond Electronics ''W9825G6JB 256 megabit (Mbit) synkron dynamisk RAM (SDRAM), en Integreret siliciumopløsning. Inc. (ISSI)IS26KL256S-DABLI00 256 Mbit NOR flash og ISSI'erIS25LP256D 256 Mbit Quad Serial Peripheral Interface (SPI) enhed.

Endelig tilføjer modulet en Torex SemiconductorXCL214B333DR buck-konverter til at supplere i.MX RT106F-processorens interne strømstyringsfunktioner til de ekstra enheder på det tilsluttede modulkort.

Det tilsluttede modul monteres igen på et vision-applikationskort, der kombinerer en Murata Electronics IRA-S210ST01 passiv infrarød (PIR) sensor, bevægelsessensor, batterioplader, lydsupport, lysdioder (LED'er), knapper og interface-stik (figur 4).

Figur 4: I NXP SLN-VIZNAS-IOT-sættet er det tilsluttede modul (til venstre) fastgjort til vision-applikationskortet for at give hardwarefundamentet til ansigtsgenkendelse. (Billedkilde: NXP)

Sammen med denne systemplatform kræver et system til ansigtsgenkendelsessystem klart en passende kamerasensor til at tage et billede af brugerens ansigt. Som nævnt tidligere kræver bekymringer om præsentationsangreb imidlertid yderligere billedbehandlingsfunktioner.

Afbødende præsentationsangreb

Forskere har i årevis udforsket forskellige præsentationsangrebsmetoder (PAD), der er designet til at afbøde forsøg såsom brug af latente fingeraftryk eller billeder af et ansigt for at spoofe biometrisk baserede autentificeringssystemer. Selvom detaljerne ligger langt uden for denne artikels anvendelsesområde, bruger PAD-metoder generelt dybdeanalyse af kvaliteten og karakteristikaene for de biometriske data, der er fanget som en del af processen, såvel som "livskraft" -detekteringsmetoder designet til at afgøre, om de biometriske data blev fanget fra en levende person. Underliggende for mange af disse forskellige metoder spiller dybneurale netværk (DNN) modeller en vigtig rolle ikke kun i ansigtsgenkendelse, men også i at identificere forsøg på at falske systemet. Ikke desto mindre kan det billeddannelsessystem, der bruges til at fange brugerens ansigt, yde yderligere understøttelse af livsdetektion.

Til SLN-VIZNAS-IOT-kittet inkluderer NXP kameramoduler, der indeholder et parON Semiconductor'sMT9M114 billedsensorer. Her er det ene kamera udstyret med et rødt, grønt, blåt (RGB) filter, og det andet kamera er udstyret med et infrarødt (IR) filter. Vedhæftet via kameragrænseflader til vision-applikationskortet genererer RGB-kameraet et normalt synligt lysbillede, mens IR-kameraet tager et billede, der ville være anderledes for en levende person sammenlignet med et billede af personen. Ved hjælp af denne tilgang til detektering af livsstil sammen med dets interne ansigtsgenkendelsesfunktion giver SLN-VIZNAS-IOT-sættet offline, anti-spoofing-ansigtsgenkendelsesfunktion i en pakke, der måler ca. 30 x 40 millimeter (mm) (figur 5).

Figur 5: NXP SLN-VIZNAS-IOT-hardwarekittet integrerer et dobbelt kamerasystem til detektion af livlighed (øverst) og et visionapplikationskort (nederst) med et tilsluttet modul til at give en drop-in-løsning til offline ansigtsgenkendelse med antispoofing evne. (Billedkilde: NXP)

Kom godt i gang med SLN-VIZNAS-IOT-sættet

NXP SLN-VIZNAS-IOT-sættet leveres klar til brug med indbyggede ansigtsgenkendelsesmodeller. Udviklere tilslutter et USB-kabel og berører en knap på sættet for at udføre en simpel manuel ansigtsregistrering ved hjælp af den forudindlæste “elock” -applikation og den ledsagende mobilapp (figur 6 til venstre). Efter registrering viser mobilappen en "velkomsthjem" -meddelelse og "ulåst" -etiket, når sættet autentificerer det registrerede ansigt (figur 6, højre).

Figur 6: NXP SLN-VIZNAS-IOT-hardwarekit fungerer ud af kassen ved hjælp af en ledsagende app til at registrere et ansigt (til venstre) og genkende registrerede ansigter (til højre). (Billedkilde: NXP)

Sættets Oasis Lite ansigtsgenkendelsessoftware behandler modeller fra sin database med op til 3000 RGB-ansigter med en genkendelsesnøjagtighed på 99,6 % og op til 100 IR-ansigter med en anti-spoofing-nøjagtighed på 96,5 %. Som tidligere nævnt har NXP-hardware-/softwareløsningen brug for mindre end et sekund til at udføre ansigtsgenkendelse, billedjustering, kvalitetskontrol, detektering af levetid og genkendelse i et interval fra 0,2 til 1,0 meter (m). Faktisk understøtter systemet en alternativ “lys” inferensmodel, der er i stand til at udføre den samme sekvens på mindre end 0,5 sek., Men understøtter en mindre maksimal databasestørrelse på 1000 RGB-ansigter og 50 IR-ansigter.

Opbygning af brugerdefinerede ansigtsgenkendelsesprogrammer

Brugt som det er, giver NXP SLN-VIZNAS-IOT-sættet udviklere mulighed for hurtigt at evaluere, prototype og udvikle ansigtsgenkendelsesapplikationer. Når du opretter brugerdefinerede hardwareløsninger, fungerer sættet som et komplet referencedesign med komplette skemaer og en detaljeret stykliste (BOM). Til softwareudvikling kan programmører bruge NXP MCUXpresso integreret udviklingsmiljø (IDE) med FreeRTOS support og konfigurationsværktøjer. Til denne applikation bruger udviklere simpelthen NXP'er online MCUXpresso SDK Builder at konfigurere deres softwareudviklingsmiljø med NXPs VIZNAS SDK, som inkluderer NXP Oasis Lite maskinindlæringsvisionsmotoren (figur 7).

Figur 7: NXP leverer et omfattende softwaremiljø, der udfører NXP Oasis Lite-runtime-biblioteket og hjælpemiddelware på FreeRTOS-operativsystemet. (Billedkilde: NXP)

Softwarepakken inkluderer komplet kildekode til driftsmiljøet samt den tidligere nævnte elock-prøveapplikation. NXP leverer ikke kildekode til sin proprietære Oasis Lite-motor eller til modellerne. I stedet arbejder udviklere med Oasis Lite runtime-biblioteket ved hjælp af den medfølgende applikationsprogrammeringsgrænseflade (API), som inkluderer et sæt intuitive funktionsopkald til at udføre understøttede operationer. Derudover bruger udviklere et bestemt sæt C-definer og strukturer til at specificere forskellige parametre, herunder billedstørrelse, hukommelsesallokering, tilbagekald og aktiverede funktioner, der bruges af systemet, når Oasis Lite-runtime-miljøet startes (liste 1).

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

Liste 1: Udviklere kan ændre softwareudførelsesparametre ved at ændre indholdet af strukturer som den her vist til Oasis Lite runtime initialisering. (Kodekilde: NXP)

Elock-eksempelapplikationskoden demonstrerer de vigtigste designmønstre til at starte Oasis som en opgave, der kører under FreeRTOS, initialiserer miljøet og går ind i dets normale kørestadium. I kørselstrinnet fungerer runtime-miljøet på hver ramme i et billede og udfører de leverede tilbagekaldsfunktioner, der er knyttet til hver begivenhed, der er defineret i miljøet (Listing 2).

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

Liste 2: Oasis Lite-runtime genkender en række begivenheder, der er dokumenteret som et opregnet sæt i Oasis Lite-runtime-headerfilen. (Kodekilde: NXP)

Eksempelapplikationen kan give udviklere trin for trin fejlretningsmeddelelser, der beskriver resultaterne forbundet med hver begivenhed, der behandles af begivenhedshåndtereren (EvtHandler). Efter at kvalitetskontrollen er afsluttet (OASISLT_EVT_QUALITY_CHK_COMPLETE), udskriver systemet for eksempel fejlretningsmeddelelser, der beskriver resultatet, og efter ansigtsgenkendelse er afsluttet (OASISLT_EVT_REC_COMPLETE), trækker systemet bruger-id og navn fra sin database til genkendte ansigter og udskriver den information (Liste 3).

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

Liste 3: Som vist i dette uddrag fra en prøveapplikation i NXP-softwaredistributionen behandler en begivenhedshåndterer begivenheder, der er stødt på under ansigtsgenkendelsessekvensen. (Kodekilde: NXP)

Udover at understøtte kravene til behandling af ansigtsgenkendelse er NXP SLN-VIZNAS-IOT softwaren designet til at beskytte driftsmiljøet. For at sikre runtime-sikkerhed er systemet designet til at verificere integriteten og ægtheden af hvert signeret billede, der er indlæst i systemet ved hjælp af et certifikat, der er gemt i SLN-VIZNAS-IOT-kits filsystem. Da denne bekræftelsessekvens starter med en betroet bootloader, der er gemt i skrivebeskyttet hukommelse (ROM), giver denne proces en kæde af tillid til at køre firmware til applikationer. Da kodesignering og verifikation kan bremse udviklingen, er denne verifikationsproces designet til at blive omgået under software design og fejlretning. Faktisk kommer SLN-VIZNAS-IOT-sættet forudindlæst med signerede billeder, men bekræftelse af kodesignatur er omgået som standard. Udviklere kan nemt indstille muligheder for at aktivere fuld kodesignaturbekræftelse til produktion.

Sammen med runtime-miljøet og tilhørende eksempelapplikationskode giver NXP Android-mobilapps med fuld java-kildekode. Én app, VIZNAS FaceRec Manager, giver en enkel grænseflade til registrering af ansigter og administration af brugere. En anden app, VIZNAS Companion-appen, giver brugerne mulighed for at forsyne sættet med Wi-Fi-legitimationsoplysninger ved hjælp af en eksisterende Wi-Fi- eller BLE-forbindelse.

Konklusion

Ansigtsgenkendelse tilbyder en effektiv tilgang til autentificering af adgang til smarte produkter, men implementering har typisk krævet lokal højtydende computing eller altid tilkoblet højbåndsbredde for hurtige svar. Det har også været et mål for spoofing og er genstand for bekymringer om brugernes privatliv.

Som vist tilbyder et specialiseret processor- og softwarebibliotek fra NXP Semiconductors en alternativ tilgang, der nøjagtigt kan udføre offline ansigtsgenkendelse på mindre end et sekund uden en cloud-forbindelse, samtidig med at spoofing-forsøg mindskes.