Metrics til evaluering af en identitetsbekræftelsesløsning

Globalt er der sket et accelereret skift mod friktionsfri digitale brugeroplevelser. Uanset om det drejer sig om at registrere sig på et websted, handle online eller blot logge ind på din bankkonto, forsøger organisationer aktivt at reducere den friktion, som deres kunder oplever, samtidig med at de forbedrer deres sikkerhed, overholdelse og forebyggelse af bedrageri. Skiftet mod friktionsfri brugeroplevelser har givet anledning til ansigtsbaserede biometriske identitetsverifikationsløsninger, der har til formål at besvare spørgsmålet "Hvordan verificerer man en person i den digitale verden?"

Der er to vigtige fordele ved ansigtsbiometri, når det kommer til spørgsmål om identifikation og autentificering. For det første er det en bekvem teknologi for brugerne: der er ingen grund til at huske en adgangskode, håndtere multifaktorudfordringer, klikke på bekræftelseslinks eller løse CAPTCHA-gåder. For det andet opnås et højt sikkerhedsniveau: identifikation og autentificering på basis af ansigtsbiometri er sikker og mindre modtagelig for svindel og angreb.

I dette indlæg dykker vi ned i de to primære brugstilfælde af identitetsbekræftelse: onboarding og autentificering. Derefter dykker vi ned i de to nøglemetrikker, der bruges til at evaluere et biometrisk systems nøjagtighed: den falske matchrate (også kendt som falsk acceptrate) og falsk ikke-matchrate (også kendt som falsk afvisningsrate). Disse to mål er meget brugt af organisationer til at evaluere nøjagtigheden og fejlfrekvensen af ​​biometriske systemer. Til sidst diskuterer vi en ramme og bedste praksis for at udføre en evaluering af en identitetsbekræftelsestjeneste.

Der henvises til den medfølgende Jupyter notesbog der gennemgår alle trinene nævnt i dette indlæg.

Use cases: Onboarding og Authentication

Der er to primære use cases for biometriske løsninger: bruger onboarding (ofte omtalt som verifikation) og autentificering (ofte omtalt som identifikation). Onboarding indebærer en-til-en-matchning af ansigter mellem to billeder, for eksempel at sammenligne en selfie med et betroet identifikationsdokument som et kørekort eller pas. Autentificering indebærer på den anden side en-til-mange-søgning af et ansigt mod en gemt samling af ansigter, for eksempel søgning i en samling af medarbejderansigter for at se, om en medarbejder har autoriseret adgang til en bestemt etage i en bygning.

Nøjagtigheden af ​​onboarding- og autentificeringsbrugssager måles ved de falske positive og falske negative fejl, som den biometriske løsning kan lave. En lighedsscore (spænder fra 0 %, der betyder ingen match til 100 %, hvilket betyder et perfekt match) bruges til at træffe afgørelsen om et match eller en ikke-match-afgørelse. En falsk positiv opstår, når løsningen anser billeder af to forskellige individer for at være den samme person. En falsk negativ betyder på den anden side, at løsningen anså to billeder af den samme person for at være forskellige.

Onboarding: En-til-en-verifikation

Biometrisk-baserede onboarding-processer både forenkler og sikrer processen. Vigtigst af alt sætter det organisationen og kunden op til en næsten friktionsfri onboarding-oplevelse. For at gøre dette skal brugerne blot præsentere et billede af en form for pålideligt identifikationsdokument, der indeholder brugerens ansigt (såsom kørekort eller pas) samt tage et selfie-billede under onboarding-processen. Når systemet har disse to billeder, sammenligner det blot ansigterne i de to billeder. Når ligheden er større end en specificeret tærskel, så har du et match; ellers har du et ikke-match. Følgende diagram skitserer processen.

Overvej eksemplet med Julie, en ny bruger, der åbner en digital bankkonto. Løsningen får hende til at tage et billede af sit kørekort (trin 2) og tage en selfie (trin 3). Efter at systemet har tjekket kvaliteten af ​​billederne (trin 4), sammenligner det ansigtet på selfien med ansigtet på kørekortet (en-til-en-matchning), og der produceres en lighedsscore (trin 5). Hvis lighedsscoren er mindre end den krævede lighedstærskel, afvises Julies onboarding-forsøg. Dette er, hvad vi kalder en falsk ikke-match eller falsk afvisning: Løsningen anså to billeder af den samme person for at være forskellige. På den anden side, hvis lighedsscoren var større end den krævede lighed, så betragter løsningen de to billeder som den samme person eller et match.

Autentificering: En-til-mange-identifikation

Fra at gå ind i en bygning, til at tjekke ind i en kiosk, til at bede en bruger om en selfie for at bekræfte deres identitet, er denne type nul-til-lav-friktion autentificering via ansigtsgenkendelse blevet almindelig for mange organisationer. I stedet for at udføre billed-til-billede-matchning, tager denne godkendelsesbrug et enkelt billede og sammenligner det med en søgbar samling af billeder for et potentielt match. I et typisk tilfælde af autentificering bliver brugeren bedt om at tage en selfie, som derefter sammenlignes med de ansigter, der er gemt i samlingen. Resultatet af søgningen giver nul, et eller flere potentielle matches med tilsvarende lighedsscore og eksterne identifikatorer. Hvis der ikke returneres noget match, er brugeren ikke autentificeret; men forudsat at søgningen returnerer et eller flere matches, træffer systemet godkendelsesbeslutningen baseret på lighedsresultaterne og eksterne identifikatorer. Hvis lighedsscoren overstiger den påkrævede lighedstærskel, og den eksterne identifikator matcher den forventede identifikator, bliver brugeren autentificeret (matchet). Følgende diagram skitserer et eksempel på en ansigtsbaseret biometrisk godkendelsesproces.

Overvej eksemplet med Jose, en chauffør for levering af gig-økonomi. Leveringstjenesten autentificerer leveringschauffører ved at bede chaufføren om at tage en selfie, før en levering påbegyndes ved hjælp af virksomhedens mobilapplikation. Et problem, som udbydere af koncert-økonomier står over for, er jobdeling; i det væsentlige deler to eller flere brugere den samme konto for at spille systemet. For at bekæmpe dette bruger mange leveringstjenester et kamera i bilen til at tage billeder (trin 2) af chaufføren på tilfældige tidspunkter under en levering (for at sikre, at leveringschaufføren er den autoriserede chauffør). I dette tilfælde tager Jose ikke kun en selfie i starten af ​​sin levering, men et kamera i bilen tager billeder af ham under leveringen. Systemet udfører kvalitetstjek (trin 3) og søger (trin 4) i samlingen af ​​registrerede chauffører for at verificere chaufførens identitet. Hvis en anden driver opdages, så kan gig-economy leveringstjenesten undersøge nærmere.

En falsk match (falsk positiv) opstår, når løsningen betragtede to eller flere billeder af forskellige mennesker for at være den samme person. I vores tilfælde, antag, at i stedet for den autoriserede chauffør, lader Jose sin bror Miguel tage en af ​​hans leverancer for ham. Hvis løsningen forkert matcher Miguels selfie til billederne af Jose, så opstår der et falsk match (falsk positiv).

For at bekæmpe potentialet ved falske matches anbefaler vi, at samlingerne indeholder flere billeder af hvert emne. Det er almindelig praksis at indeksere pålidelige identifikationsdokumenter, der indeholder et ansigt, en selfie på tidspunktet for onboarding og selfies fra de seneste adskillige identifikationstjek. Indeksering af flere billeder af et emne giver mulighed for at aggregere lighedsscorerne på tværs af returnerede ansigter og derved forbedre nøjagtigheden af ​​identifikationen. Derudover bruges eksterne identifikatorer til at begrænse risikoen for en falsk accept. Et eksempel på en forretningsregel kan se sådan ud:

HVIS samlet lighedsscore >= påkrævet lighedstærskel OG ekstern identifikator == forventet identifikator SÅ godkendes

Vigtige biometriske nøjagtighedsmål

I et biometrisk system er vi interesserede i den falske match-rate (FMR) og den falske ikke-match-rate (FNMR) baseret på lighedsresultaterne fra ansigtssammenligninger og søgninger. Uanset om det er en onboarding eller godkendelsesbrug, beslutter biometriske systemer at acceptere eller afvise matcher af en brugers ansigt baseret på lighedsscore for to eller flere billeder. Som ethvert beslutningssystem vil der være fejl, hvor systemet fejlagtigt accepterer eller afviser et forsøg på onboarding eller autentificering. Som en del af evalueringen af ​​din identitetsbekræftelsesløsning skal du evaluere systemet ved forskellige lighedstærskler for at minimere falske match og falske ikke-match rater, samt sammenligne disse fejl med omkostningerne ved at lave forkerte afvisninger og accepter. Vi bruger FMR og FNMR som vores to nøglemålinger til at evaluere ansigtsbiometriske systemer.

Falsk non-match rate

Når identitetsbekræftelsessystemet ikke kan identificere eller autorisere en ægte bruger korrekt, opstår der en falsk ikke-match, også kendt som en falsk negativ. Falsk non-match rate (FNMR) er et mål for, hvor tilbøjeligt systemet er til forkert at identificere eller godkende en ægte bruger.

FNMR udtrykkes som en procentdel af tilfælde, hvor der foretages et onboarding- eller autentificeringsforsøg, hvor brugerens ansigt er forkert afvist (en falsk negativ), fordi lighedsscoren er under den foreskrevne tærskel.

En sand positiv (TP) er, når løsningen anser to eller flere billeder af den samme person for at være ens. Det vil sige, at ligheden af ​​sammenligningen eller søgningen er over den påkrævede lighedstærskel.

En falsk negativ (FN) er, når løsningen anser to eller flere billeder af den samme person for at være forskellige. Det vil sige, at ligheden af ​​sammenligningen eller søgningen er under den påkrævede lighedstærskel.

Formlen for FNMR er:

FNMR = Falsk Negativ Count / (True Positive Count + False Negative Count)

Antag for eksempel, at vi har 10,000 ægte godkendelsesforsøg, men 100 afvises, fordi deres lighed med referencebilledet eller samlingen falder under den angivne lighedstærskel. Her har vi 9,900 sande positive og 100 falske negative, derfor er vores FNMR 1.0 %

FNMR = 100 / (9900 + 100) eller 1.0 %

Falsk matchrate

Når et identitetsbekræftelsessystem forkert identificerer eller autoriserer en uautoriseret bruger som ægte, opstår der et falsk match, også kendt som en falsk positiv. False match rate (FMR) er et mål for, hvor tilbøjeligt systemet er til forkert at identificere eller autorisere en uautoriseret bruger. Det måles ved antallet af falske positive genkendelser eller godkendelser divideret med det samlede antal identifikationsforsøg.

En falsk positiv opstår, når løsningen betragter to eller flere billeder af forskellige mennesker for at være den samme person. Det vil sige, at lighedsscoren for sammenligningen eller søgningen er over den påkrævede lighedstærskel. Grundlæggende identificerer eller autoriserer systemet forkert en bruger, når det skulle have afvist deres identifikation eller autentificeringsforsøg.

Formlen for FMR er:

FMR = Falsk Positiv Antal / (Total Forsøg)

Antag for eksempel, at vi har 100,000 godkendelsesforsøg, men 100 falske brugere er forkert godkendt, fordi deres lighed med referencebilledet eller samlingen falder over den angivne lighedstærskel. Her har vi 100 falske positive, derfor er vores FMR 0.01%

FMR = 100 / (100,000) eller 0.01 %

Rate for falske match vs. Rate for falsk ikke-match

Falsk matchrate og falsk non-match rate er i modstrid med hinanden. Når lighedstærsklen stiger, falder potentialet for et falsk match, mens potentialet for et falsk ikke-match stiger. En anden måde at tænke denne afvejning på er, at når lighedstærsklen stiger, bliver løsningen mere restriktiv, hvilket gør færre matcher med lav lighed. For eksempel er det almindeligt, at brugssager, der involverer offentlig sikkerhed og sikkerhed, sætter en tærskel for matchlighed ret høj (99 og derover). Alternativt kan en organisation vælge en mindre restriktiv lighedstærskel (90 og derover), hvor virkningen af ​​friktion for brugeren er vigtigere. Følgende diagram illustrerer disse afvejninger. Udfordringen for organisationer er at finde en tærskel, der minimerer både FMR og FNMR baseret på dine organisations- og applikationskrav.

Valg af en lighedstærskel afhænger af forretningsapplikationen. Antag for eksempel, at du vil begrænse kundefriktion under onboarding (en mindre restriktiv lighedstærskel, som vist i den følgende figur til venstre). Her har du måske en lavere påkrævet lighedstærskel, og du er villig til at acceptere risikoen for onboarding af brugere, hvor tilliden til matchen mellem deres selfie og kørekort er lavere. Antag derimod, at du vil sikre, at kun autoriserede brugere kommer ind i en applikation. Her opererer du muligvis ved en ret restriktiv lighedstærskel (som vist i figuren til højre).

Trin til beregning af falske match og ikke-match rater

Der er flere måder at beregne disse to metrics på. Det følgende er en relativt enkel tilgang til at opdele trinene i at samle ægte billedpar, skabe en bedragerparring (billeder, der ikke burde matche), og til sidst bruge en sonde til at sløjfe over de forventede matchende og ikke-matchede billedpar, og fange resulterende lighed. Trinene er som følger:

1. Saml et ægte prøvebilledsæt. Vi anbefaler at starte med et sæt billedpar og tildele en ekstern identifikator, som bruges til at foretage en officiel kampafgørelse. Parret består af følgende billeder:
   1. Kildebillede – Dit betroede kildebillede, for eksempel et kørekort.
   2. Målbillede – Dit selfie eller billede, du skal sammenligne med.
2. Saml et billedsæt af bedrager-matches. Disse er par af billeder, hvor kilden og målet ikke stemmer overens. Dette bruges til at vurdere FMR (sandsynligheden for, at systemet forkert matcher to forskellige brugeres ansigter). Du kan oprette et bedragerisk billedsæt ved hjælp af billedparrene ved at oprette et kartesisk produkt af billederne og derefter filtrere og prøve resultatet.
3. Undersøg de ægte og bedrageriske match-sæt ved at gå over billedparrene, sammenligne kilde- og bedragermålet og fange den resulterende lighed.
4. Beregn FMR og FNMR ved at beregne de falske positive og falske negative ved forskellige minimale lighedstærskler.

Du kan vurdere omkostningerne ved FMR og FNMR ved forskellige lighedstærskler i forhold til din ansøgnings behov.

Trin 1: Saml ægte billedparprøver

At vælge et repræsentativt udsnit af billedpar, der skal evalueres, er afgørende, når man evaluerer en identitetsbekræftelsestjeneste. Det første trin er at identificere et ægte sæt billedpar. Disse er kendte kilde- og målbilleder af en bruger. Den ægte billedparring bruges til at vurdere FNMR, i det væsentlige sandsynligheden for, at systemet ikke matcher to ansigter af den samme person. Et af de første spørgsmål, der ofte stilles, er "Hvor mange billedpar er nødvendige?" Svaret er, at det afhænger af din use case, men den generelle vejledning er følgende:

• Mellem 100-1,000 billedpar giver et mål for gennemførlighed
• Op til 10,000 billedpar er stort nok til at måle variabilitet mellem billeder
• Mere end 10,000 billedpar giver et mål for driftskvalitet og generaliserbarhed

Mere data er altid bedre; brug dog som udgangspunkt mindst 1,000 billedpar. Det er dog ikke ualmindeligt at bruge mere end 10,000 billedpar for at nulstille en acceptabel FNMR eller FMR for et givet forretningsproblem.

Det følgende er et eksempel på billedpar-tilknytningsfil. Vi bruger billedpar-mapping-filen til at drive resten af ​​evalueringsprocessen.

Trin 2: Generer et bedragerbilledepar sæt

Nu hvor du har en fil med ægte billedpar, kan du oprette et kartesisk produkt af mål- og kildebilleder, hvor de eksterne identifikatorer ikke fungerer. Dette producerer kilde-til-mål-par, der ikke burde matche. Denne parring bruges til at vurdere FMR, i det væsentlige sandsynligheden for, at systemet vil matche en brugers ansigt med en anden brugers ansigt.

Trin 3: Undersøg de ægte og falske billedparsæt

Ved hjælp af et driverprogram anvender vi Amazon-anerkendelse Sammenlign Faces API over billedparrene og fange ligheden. Du kan også fange yderligere oplysninger som positur, kvalitet og andre resultater af sammenligningen. Lighedsscorerne bruges til at beregne antallet af falske match og ikke-match i det følgende trin.

I det følgende kodestykke anvender vi CompareFaces API på alle billedparrene og udfylder alle lighedsscorerne i en tabel:

obj = s3.get_object(Bucket= bucket_name , Key = csv_file)

df = pd.read_csv(io.BytesIO(obj['Body'].read()), encoding='utf8')
def compare_faces(source_file, target_file, threshold = 0):
    response=rekognition.compare_faces(SimilarityThreshold=threshold,
                                        SourceImage={'S3Object': {
                                                    'Bucket': bucket_name,
                                                    'Name':source_file}},
                                        TargetImage={'S3Object': {
                                                    'Bucket': bucket_name,
                                                    'Name':target_file}})
df_similarity = df.copy()
df_similarity["SIMILARITY"] = None
for index, row in df.iterrows():
    source_file = dataset_folder + row["SOURCE"]
    target_file = dataset_folder + row["TARGET"]
    response_score = compare_faces(source_file, target_file)
    df_similarity._set_value(index,"SIMILARITY", response_score)
    df_similarity.head()

Kodestykket giver følgende output.

Fordelingsanalyse af lighedsscore ved test er et udgangspunkt for at forstå lighedsscoren efter billedpar. Følgende kodestykke og outputdiagram viser et simpelt eksempel på fordelingen af ​​lighedsscore efter testsæt samt resulterende beskrivende statistik:

sns.boxplot(data=df_similarity,
            x=df_similarity["SIMILARITY"],
            y=df_similarity["TEST"]).set(xlabel='Similarity Score',
            ylabel=None,
            title = "Similarity Score Distribution")
plt.show()

df_descriptive_stats = pd.DataFrame(columns=['test','count', 'min' , 'max', 'mean', 'median', 'std'])

tests = ["Genuine", "Imposter"]

for test in tests:
    count = df_similarity['SIMILARITY'].loc[df_similarity['TEST'] == test].count()
    mean = df_similarity['SIMILARITY'].loc[df_similarity['TEST'] == test].mean()
    max_ = df_similarity['SIMILARITY'].loc[df_similarity['TEST'] == test].max()
    min_ = df_similarity['SIMILARITY'].loc[df_similarity['TEST'] == test].min()
    median = df_similarity['SIMILARITY'].loc[df_similarity['TEST'] == test].median()
    std = df_similarity['SIMILARITY'].loc[df_similarity['TEST'] == test].std()

    new_row = {'test': test,
                'count': count,
                'min': min_,
                'max': max_,
                'mean': mean,
                'median':median,
                'std': std}
    df_descriptive_stats = df_descriptive_stats.append(new_row,
    ignore_index=True)

df_descriptive_stats

I dette eksempel kan vi se, at middel- og medianligheden for ægte ansigtspar var 91.7 og 99.1, hvorimod for bedragerparrene var henholdsvis 2.8 og 0.8. Som forventet viser dette de høje lighedsscorer for ægte billedpar og lave lighedsscores for bedrageriske billedpar.

Trin 4: Beregn FMR og FNMR ved forskellige lighedstærskelniveauer

I dette trin beregner vi de falske match- og ikke-match-rater ved forskellige tærskler for lighed. For at gøre dette går vi simpelthen gennem lighedstærskler (for eksempel 90-100). Ved hver valgt lighedstærskel beregner vi vores forvirringsmatrix, der indeholder sande positive, sande negative, falske positive og falske negative tællinger, som bruges til at beregne FMR og FNMR ved hver valgt lighed.

For at gøre dette opretter vi en funktion, der returnerer de falske positive og negative tællinger og går gennem en række lighedsscore (90-100):

similarity_thresholds = [80,85,90,95,96,97,98,99]

# create output df
df_cols = ['Similarity Threshold', 'TN' , 'FN', 'TP', 'FP', 'FNMR (%)', 'FMR (%)']
comparison_df = pd.DataFrame(columns=df_cols)

# create columns for y_actual and y_pred
df_analysis = df_similarity.copy()
df_analysis["y_actual"] = None
df_analysis["y_pred"] = None

for threshold in similarity_thresholds:
    # Create y_pred and y_actual columns, 1 == match, 0 == no match
    for index, row in df_similarity.iterrows():
        # set y_pred
        if row["SIMILARITY"] >= threshold:
            df_analysis._set_value(index,"y_pred", 1)
        else:
            df_analysis._set_value(index,"y_pred", 0)

        # set y_actual
        if row["TEST"] == "Genuine":
            df_analysis._set_value(index,"y_actual", 1)
        else:
            df_analysis._set_value(index,"y_actual", 0)

    tn, fp, fn, tp = confusion_matrix(df_analysis['y_actual'].tolist(),
                                      df_analysis['y_pred'].tolist()).ravel()
    FNMR = fn / (tp + fn)
    FMR = fp / (tn+fp+fn+tp)

    new_row = {'Similarity Threshold': threshold,
                'TN': tn,
                'FN': fn,
                'TP': tp,
                'FP': fp,
                'FNMR (%)':FNMR,
                'FMR (%)': FMR}
    comparison_df = comparison_df.append(new_row,ignore_index=True)

comparison_df

Følgende tabel viser resultaterne af tællingerne ved hver lighedstærskel.

Hvordan påvirker lighedstærsklen frekvensen for falsk ikke-match?

Antag, at vi har 1,000 ægte brugeronboarding-forsøg, og vi afviser 10 af disse forsøg baseret på en påkrævet minimumslighed på 95 % for at blive betragtet som et match. Her afviser vi 10 ægte onboarding-forsøg (falske negativer), fordi deres lighed falder under den specificerede minimumskrævede lighedstærskel. I dette tilfælde er vores FNMR 1.0%.

FNMR = Falsk Negativ Count / (True Positive Count + False Negative Count)

FNMR = 10 / (990 + 10) eller 1.0 %

Antag derimod, at i stedet for at have 1,000 ægte brugere ombord, har vi 990 ægte brugere og 10 bedragere (falsk positiv). Antag, at vi ved en minimumslighed på 95 % accepterer alle 1,000 brugere som ægte. Her ville vi have en 1% FMR.

FMR = Falsk Positiv Antal / (Total Forsøg)

FMR = 10 / (1,000) eller 1.0 %

Vurdering af omkostninger ved FMR og FNMR ved onboarding

I et tilfælde med onboarding er omkostningerne ved et falsk ikke-match (en afvisning) generelt forbundet med yderligere brugerfriktion eller tab af en registrering. Antag for eksempel i vores banktilfælde, at Julie præsenterer to billeder af sig selv, men bliver forkert afvist på tidspunktet for onboarding, fordi ligheden mellem de to billeder falder under den valgte lighed (en falsk ikke-match). Den finansielle institution kan risikere at miste Julie som en potentiel kunde, eller det kan forårsage Julie yderligere friktion ved at kræve, at hun udfører trin for at bevise sin identitet.

Antag omvendt, at de to billeder af Julie er af forskellige mennesker, og at Julies onboarding burde være blevet afvist. I det tilfælde, hvor Julie er forkert accepteret (et falsk match), er omkostningerne og risikoen for pengeinstituttet en helt anden. Der kan være regulatoriske problemer, risiko for svindel og andre risici forbundet med finansielle transaktioner.

Ansvarlig brug

Kunstig intelligens (AI) anvendt gennem machine learning (ML) vil være en af ​​de mest transformerende teknologier i vores generation, der tackler nogle af menneskehedens mest udfordrende problemer, øger den menneskelige ydeevne og maksimerer produktiviteten. Ansvarlig brug af disse teknologier er nøglen til at fremme fortsat innovation. AWS er ​​forpligtet til at udvikle retfærdige og nøjagtige AI- og ML-tjenester og give dig de værktøjer og den nødvendige vejledning til at bygge AI- og ML-applikationer ansvarligt.

Når du adopterer og øger din brug af AI og ML, tilbyder AWS adskillige ressourcer baseret på vores erfaring til at hjælpe dig med ansvarlig udvikling og brug af AI og ML:

Bedste praksis og almindelige fejl at undgå

I dette afsnit diskuterer vi følgende bedste praksis:

• Brug en stor nok prøve af billeder
• Undgå open source og syntetiske ansigtsdatasæt
• Undgå manuel og syntetisk billedmanipulation
• Tjek billedkvaliteten på evalueringstidspunktet og over tid
• Overvåg FMR og FNMR over tid
• Brug et menneske i løkken gennemgang
• Hold dig opdateret med Amazon Rekognition

Brug en stor nok prøve af billeder

Brug et stort nok, men rimeligt udsnit af billeder. Hvad er en rimelig stikprøvestørrelse? Det afhænger af forretningsproblemet. Hvis du er arbejdsgiver og har 10,000 ansatte, som du vil godkende, så er det nok rimeligt at bruge alle 10,000 billeder. Antag dog, at du er en organisation med millioner af kunder, som du vil have med. I dette tilfælde er det sandsynligvis tilstrækkeligt at tage et repræsentativt udsnit af kunder såsom 5,000-20,000. Her er lidt vejledning om prøvestørrelsen:

• En prøvestørrelse på 100 – 1,000 billedpar beviser gennemførlighed
• En prøvestørrelse på 1,000 – 10,000 billedpar er nyttige til at måle variabilitet mellem billeder
• En prøvestørrelse på 10,000 – 1 million billedpar giver et mål for driftskvalitet og generaliserbarhed

Nøglen med at prøve billedpar er at sikre, at prøven giver tilstrækkelig variabilitet på tværs af populationen af ​​ansigter i din applikation. Du kan udvide din prøveudtagning og test yderligere til at omfatte demografiske oplysninger som hudfarve, køn og alder.

Undgå open source og syntetiske ansigtsdatasæt

Der er snesevis af kurerede open source-ansigtsbillededatasæt såvel som forbløffende realistiske syntetiske ansigtssæt, der ofte bruges i forskning og til at studere gennemførlighed. Udfordringen er, at disse datasæt generelt ikke er nyttige for 99 % af de virkelige brugssager, simpelthen fordi de ikke er repræsentative for kameraerne, ansigterne og kvaliteten af ​​de billeder, din applikation sandsynligvis vil støde på i naturen. Selvom de er nyttige til applikationsudvikling, generaliserer nøjagtighedsmålene for disse billedsæt ikke til, hvad du vil støde på i din egen applikation. I stedet anbefaler vi at starte med et repræsentativt udsnit af rigtige billeder fra din løsning, selvom prøvebilledparrene er små (under 1,000).

Undgå manuel og syntetisk billedmanipulation

Der er ofte kantsager, som folk er interesserede i at forstå. Ting som billedoptagelseskvalitet eller sløring af specifikke ansigtstræk er altid af interesse. For eksempel bliver vi ofte spurgt om, hvilken indflydelse alder og billedkvalitet har på ansigtsgenkendelse. Du kan blot syntetisk ælde et ansigt eller manipulere billedet for at få motivet til at virke ældre, eller manipulere billedkvaliteten, men dette oversættes ikke godt til den virkelige verden af ​​billeders aldring. I stedet er vores anbefaling at samle et repræsentativt udsnit af real-world edge cases, du er interesseret i at teste.

Tjek billedkvaliteten på evalueringstidspunktet og over tid

Kamera- og applikationsteknologi ændrer sig ret hurtigt over tid. Som en bedste praksis anbefaler vi at overvåge billedkvaliteten over tid. Fra størrelsen af ​​de ansigter, der er fanget (ved hjælp af afgrænsningsrammer), til lysstyrken og skarpheden af ​​et billede, til posituren af ​​et ansigt, såvel som potentielle sløringer (hatte, solbriller, skæg osv.), alle disse billeder og ansigtstræk ændrer sig over tid.

Overvåg FNMR og FMR over tid

Der sker ændringer, uanset om det er billederne, applikationen eller lighedstærsklerne, der bruges i applikationen. Det er vigtigt med jævne mellemrum at overvåge antallet af falske matcher og ikke-matches over tid. Ændringer i satserne (selv subtile ændringer) kan ofte pege på upstream-udfordringer med applikationen eller hvordan applikationen bruges. Ændringer af lighedstærskler og forretningsregler, der bruges til at træffe accept eller afvisning af beslutninger, kan have stor indflydelse på brugeroplevelsen for onboarding og godkendelse.

Brug et menneske i løkken gennemgang

Identitetsverifikationssystemer træffer automatiske beslutninger om at matche og ikke-matche baseret på lighedstærskler og forretningsregler. Udover lovgivningsmæssige og interne compliancekrav er en vigtig proces i ethvert automatiseret beslutningssystem at bruge menneskelige bedømmere som en del af den løbende overvågning af beslutningsprocessen. Menneskelig tilsyn med disse automatiserede beslutningssystemer giver validering og løbende forbedringer samt gennemsigtighed i den automatiserede beslutningsproces.

Hold dig opdateret med Amazon Rekognition

Amazon Recognition faces-modellen opdateres med jævne mellemrum (normalt årligt) og er i øjeblikket på version 6. Denne opdaterede version medførte vigtige forbedringer af nøjagtighed og indeksering. Det er vigtigt at holde sig ajour med nye modelversioner og forstå, hvordan du bruger disse nye versioner i din identitetsbekræftelsesapplikation. Når nye versioner af Amazon Rekognition-ansigtsmodellen lanceres, er det god praksis at køre din identitetsbekræftelsesevalueringsproces igen og bestemme eventuelle potentielle påvirkninger (positive og negative) på dine falske og ikke-match-rater.

Konklusion

Dette indlæg diskuterer de nøgleelementer, der er nødvendige for at evaluere ydeevneaspektet af din identitetsbekræftelsesløsning med hensyn til forskellige nøjagtighedsmålinger. Nøjagtighed er dog kun en af ​​de mange dimensioner, som du skal vurdere, når du vælger en bestemt indholdsmodereringstjeneste. Det er afgørende, at du inkluderer andre parametre, såsom tjenestens samlede funktionssæt, brugervenlighed, eksisterende integrationer, privatliv og sikkerhed, tilpasningsmuligheder, skalerbarhedsimplikationer, kundeservice og priser.

For at lære mere om identitetsbekræftelse i Amazon Rekognition, besøg Identitetsbekræftelse ved hjælp af Amazon Rekognition.

Om forfatterne

Mike Ames er en dataforsker, der er blevet specialist i identitetsverifikationsløsninger, med stor erfaring med udvikling af maskinlæring og AI-løsninger for at beskytte organisationer mod svindel, spild og misbrug. I hans fritid kan du finde ham på vandring, mountainbike eller lege freebee med hans hund Max.

Amit Gupta er senior AI Services Solutions Architect hos AWS. Han brænder for at give kunderne veldesignede maskinlæringsløsninger i stor skala.

Zuhayr Raghib er AI Services Solutions Architect hos AWS. Med speciale i anvendt AI/ML brænder han for at gøre det muligt for kunder at bruge skyen til at innovere hurtigere og transformere deres virksomheder.

Marcel Pividal er en Sr. AI Services Solutions Architect i World-Wide Specialist Organisation. Marcel har mere end 20 års erfaring med at løse forretningsproblemer gennem teknologi for fintechs, betalingsudbydere, pharma og offentlige myndigheder. Hans nuværende fokusområder er risikostyring, bedrageriforebyggelse og identitetsbekræftelse.