Beregninger for å evaluere en identitetsbekreftelsesløsning

Globalt har det vært et akselerert skifte mot friksjonsfrie digitale brukeropplevelser. Enten det er å registrere seg på et nettsted, foreta transaksjoner på nettet eller bare logge inn på bankkontoen din, prøver organisasjoner aktivt å redusere friksjonen kundene opplever, samtidig som de forbedrer sikkerheten, etterlevelsen og forebyggende tiltak for svindel. Skiftet mot friksjonsfrie brukeropplevelser har gitt opphav til ansiktsbaserte biometriske identitetsverifiseringsløsninger rettet mot å svare på spørsmålet "Hvordan verifiserer du en person i den digitale verden?"

Det er to viktige fordeler med ansiktsbiometri når det gjelder spørsmål om identifikasjon og autentisering. For det første er det en praktisk teknologi for brukere: det er ikke nødvendig å huske et passord, håndtere multifaktorutfordringer, klikke på verifiseringslenker eller løse CAPTCHA-oppgaver. For det andre oppnås et høyt sikkerhetsnivå: identifikasjon og autentisering på grunnlag av ansiktsbiometri er sikker og mindre utsatt for svindel og angrep.

I dette innlegget dykker vi inn i de to primære brukstilfellene for identitetsbekreftelse: onboarding og autentisering. Deretter dykker vi ned i de to nøkkelberegningene som brukes til å evaluere et biometrisk systems nøyaktighet: falsk samsvarsrate (også kjent som falsk akseptfrekvens) og falsk ikke-samsvarsrate (også kjent som falsk avvisningsrate). Disse to målene er mye brukt av organisasjoner for å evaluere nøyaktigheten og feilraten til biometriske systemer. Til slutt diskuterer vi et rammeverk og beste praksis for å utføre en evaluering av en identitetsverifiseringstjeneste.

Se vedlagte Jupyter notisbok som går gjennom alle trinnene nevnt i dette innlegget.

Brukstilfeller: Onboarding og autentisering

Det er to primære brukstilfeller for biometriske løsninger: brukeronboarding (ofte referert til som verifisering) og autentisering (ofte referert til som identifikasjon). Onboarding innebærer en-til-en-matching av ansikter mellom to bilder, for eksempel å sammenligne en selfie med et pålitelig identifikasjonsdokument som et førerkort eller pass. Autentisering, derimot, innebærer en-til-mange-søk av et ansikt mot en lagret samling av ansikter, for eksempel søk i en samling av ansattes ansikter for å se om en ansatt er autorisert tilgang til en bestemt etasje i en bygning.

Nøyaktighetsytelsen til brukstilfeller for onboarding og autentisering måles ved de falske positive og falske negative feilene som den biometriske løsningen kan gjøre. En likhetspoeng (som strekker seg fra 0 % som betyr ingen match til 100 % som betyr en perfekt match) brukes til å avgjøre en kamp eller en ikke-match-avgjørelse. En falsk positiv oppstår når løsningen anser bilder av to forskjellige individer for å være samme person. En falsk negativ betyr derimot at løsningen anså to bilder av samme person som forskjellige.

Onboarding: En-til-en-verifisering

Biometrisk-baserte onboarding-prosesser både forenkler og sikrer prosessen. Viktigst av alt, det setter organisasjonen og kunden klar for en nesten friksjonsfri onboard-opplevelse. For å gjøre dette må brukere ganske enkelt presentere et bilde av en form for pålitelig identifikasjonsdokument som inneholder brukerens ansikt (som førerkort eller pass), samt ta et selfie-bilde under påstigningsprosessen. Etter at systemet har disse to bildene, sammenligner det ganske enkelt ansiktene i de to bildene. Når likheten er større enn en spesifisert terskel, så har du en match; ellers har du en ikke-match. Følgende diagram skisserer prosessen.

Tenk på eksemplet med Julie, en ny bruker som åpner en digital bankkonto. Løsningen ber henne ta et bilde av førerkortet (trinn 2) og ta en selfie (trinn 3). Etter at systemet har kontrollert kvaliteten på bildene (trinn 4), sammenligner det ansiktet i selfien med ansiktet på førerkortet (en-til-en-matching) og en likhetspoeng (trinn 5) produseres. Hvis likhetspoengsummen er mindre enn den nødvendige likhetsterskelen, avvises påstigningsforsøket til Julie. Dette er det vi kaller en falsk ikke-match eller falsk avvisning: løsningen anså to bilder av samme person som forskjellige. På den annen side, hvis likhetspoengene var større enn den nødvendige likheten, anser løsningen de to bildene for å være den samme personen eller en match.

Autentisering: En-til-mange-identifikasjon

Fra å gå inn i en bygning, til å sjekke inn i en kiosk, til å be en bruker om en selfie for å bekrefte identiteten sin, denne typen null-til-lav-friksjon autentisering via ansiktsgjenkjenning har blitt vanlig for mange organisasjoner. I stedet for å utføre bilde-til-bilde-samsvar, tar denne brukssaken for autentisering ett enkelt bilde og sammenligner det med en søkbar samling bilder for en potensiell match. I et typisk autentiseringstilfelle blir brukeren bedt om å ta en selfie, som deretter sammenlignes med ansiktene som er lagret i samlingen. Resultatet av søket gir null, ett eller flere potensielle treff med tilsvarende likhetspoeng og eksterne identifikatorer. Hvis ingen treff returneres, blir ikke brukeren autentisert; men forutsatt at søket returnerer ett eller flere treff, tar systemet autentiseringsbeslutningen basert på likhetspoeng og eksterne identifikatorer. Hvis likhetspoengsummen overskrider den nødvendige likhetsterskelen og den eksterne identifikatoren samsvarer med den forventede identifikatoren, blir brukeren autentisert (matchet). Følgende diagram skisserer et eksempel på ansiktsbasert biometrisk autentiseringsprosess.

Tenk på eksemplet med Jose, en leveringssjåfør med gig-økonomi. Leveringstjenesten autentiserer leveringssjåfører ved å be sjåføren ta en selfie før du starter en levering ved å bruke selskapets mobilapplikasjon. Et problem som leverandører av gig-økonomi står overfor er jobbdeling; i hovedsak deler to eller flere brukere samme konto for å spille systemet. For å bekjempe dette bruker mange leveringstjenester et kamera i bilen for å ta bilder (trinn 2) av sjåføren på tilfeldige tidspunkter under en levering (for å sikre at leveringssjåføren er den autoriserte sjåføren). I dette tilfellet tar Jose ikke bare en selfie i starten av leveringen, men et kamera i bilen tar bilder av ham under leveringen. Systemet utfører kvalitetskontroller (trinn 3) og søker (trinn 4) i samlingen av registrerte sjåfører for å bekrefte identiteten til sjåføren. Hvis en annen driver oppdages, kan leveringstjenesten for gig-økonomi undersøke nærmere.

En falsk match (falsk positiv) oppstår når løsningen anså to eller flere bilder av forskjellige personer for å være samme person. I vårt tilfelle, anta at i stedet for den autoriserte sjåføren, lar Jose broren Miguel ta en av leveransene hans for ham. Hvis løsningen feil matcher Miguels selfie med bildene av Jose, oppstår en falsk match (falsk positiv).

For å bekjempe potensialet til falske treff, anbefaler vi at samlingene inneholder flere bilder av hvert emne. Det er vanlig praksis å indeksere pålitelige identifikasjonsdokumenter som inneholder et ansikt, en selfie ved ombordstigning og selfier fra de siste identifikasjonskontrollene. Å indeksere flere bilder av et motiv gir muligheten til å samle likhetspoeng på tvers av ansikter som returneres, og dermed forbedre nøyaktigheten til identifiseringen. I tillegg brukes eksterne identifikatorer for å begrense risikoen for en falsk aksept. Et eksempel på forretningsregel kan se omtrent slik ut:

HVIS samlet likhetspoeng >= nødvendig likhetsterskel OG ekstern identifikator == forventet identifikator SÅ autentiser

Viktige biometriske nøyaktighetsmål

I et biometrisk system er vi interessert i falsk matchrate (FMR) og falsk ikke-match rate (FNMR) basert på likhetspoeng fra ansiktssammenligninger og søk. Enten det er en onboarding- eller autentiseringsbruk, bestemmer biometriske systemer seg for å godta eller avvise treff på en brukers ansikt basert på likhetspoengsummen til to eller flere bilder. Som ethvert beslutningssystem vil det være feil der systemet feilaktig godtar eller avviser et forsøk på onboarding eller autentisering. Som en del av evalueringen av identitetsbekreftelsesløsningen din, må du evaluere systemet ved ulike likhetsterskler for å minimere falske samsvar og falske ikke-samsvarsrater, samt sammenligne disse feilene med kostnadene ved å gjøre feilaktige avvisninger og aksepter. Vi bruker FMR og FNMR som våre to nøkkelberegninger for å evaluere ansikts biometriske systemer.

Falsk ikke-match rate

Når identitetsbekreftelsessystemet ikke klarer å identifisere eller autorisere en ekte bruker på riktig måte, oppstår en falsk ikke-match, også kjent som en falsk negativ. False non-match rate (FNMR) er et mål på hvor utsatt systemet er for å feilaktig identifisere eller autorisere en ekte bruker.

FNMR uttrykkes som en prosentandel av tilfeller der et onboarding- eller autentiseringsforsøk er gjort, der brukerens ansikt er feilaktig avvist (en falsk negativ) fordi likhetspoengsummen er under den foreskrevne terskelen.

En sann positiv (TP) er når løsningen vurderer at to eller flere bilder av samme person er like. Det vil si at likheten til sammenligningen eller søket er over den nødvendige likhetsterskelen.

En falsk negativ (FN) er når løsningen vurderer to eller flere bilder av samme person som forskjellige. Det vil si at likheten til sammenligningen eller søket er under den nødvendige likhetsterskelen.

Formelen for FNMR er:

FNMR = Antall falske negative / (True Positive Count + False Negative Count)

Anta for eksempel at vi har 10,000 100 ekte autentiseringsforsøk, men 9,900 blir nektet fordi deres likhet med referansebildet eller samlingen faller under den angitte likhetsterskelen. Her har vi 100 1.0 sanne positive og XNUMX falske negative, derfor er vår FNMR XNUMX %

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

Falsk matchrate

Når et identitetsbekreftelsessystem feilaktig identifiserer eller autoriserer en uautorisert bruker som ekte, oppstår et falskt samsvar, også kjent som en falsk positiv. False match rate (FMR) er et mål på hvor utsatt systemet er for å feilaktig identifisere eller autorisere en uautorisert bruker. Det måles ved antall falske positive gjenkjennelser eller autentiseringer delt på det totale antallet identifikasjonsforsøk.

En falsk positiv oppstår når løsningen vurderer at to eller flere bilder av forskjellige mennesker er samme person. Det vil si at likhetspoengsummen for sammenligningen eller søket er over den nødvendige likhetsterskelen. I hovedsak identifiserer eller autoriserer systemet feil en bruker når det burde ha avvist identifikasjons- eller autentiseringsforsøket.

Formelen for FMR er:

FMR = antall falske positive / (totalt antall forsøk)

Anta for eksempel at vi har 100,000 100 autentiseringsforsøk, men 100 falske brukere er feilautorisert fordi deres likhet med referansebildet eller samlingen faller over den angitte likhetsterskelen. Her har vi 0.01 falske positive, derfor er vår FMR XNUMX %

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

Frekvens for falske samsvar kontra falske ikke-samsvar

Falsk matchrate og falsk ikke-matchrate er i strid med hverandre. Etter hvert som likhetsterskelen øker, reduseres potensialet for en falsk match, mens potensialet for en falsk ikke-match øker. En annen måte å tenke på denne avveiningen på er at når likhetsterskelen øker, blir løsningen mer restriktiv, noe som gir færre treff med lav likhet. For eksempel er det vanlig at brukstilfeller som involverer offentlig sikkerhet og sikkerhet setter en terskel for samsvarslikhet ganske høy (99 og høyere). Alternativt kan en organisasjon velge en mindre restriktiv likhetsterskel (90 og høyere), der virkningen av friksjon for brukeren er viktigere. Følgende diagram illustrerer disse avveiningene. Utfordringen for organisasjoner er å finne en terskel som minimerer både FMR og FNMR basert på dine organisasjons- og applikasjonskrav.

Valg av likhetsterskel avhenger av forretningsapplikasjonen. Anta for eksempel at du vil begrense kundefriksjonen under onboarding (en mindre restriktiv likhetsterskel, som vist i følgende figur til venstre). Her har du kanskje en lavere nødvendig likhetsterskel, og er villig til å akseptere risikoen ved å gå ombord på brukere der tilliten til matchen mellom selfien og førerkortet er lavere. Anta derimot at du vil sikre at bare autoriserte brukere kommer inn i en applikasjon. Her kan du operere ved en ganske restriktiv likhetsterskel (som vist i figuren til høyre).

Trinn for å beregne falske samsvar og ikke-match priser

Det er flere måter å beregne disse to beregningene på. Følgende er en relativt enkel tilnærming for å dele trinnene inn i å samle ekte bildepar, lage en bedragerparing (bilder som ikke skal samsvare), og til slutt bruke en sonde til å sløyfe over de forventede og ikke-matchede bildeparene, og fange resulterende likhet. Trinnene er som følger:

1. Samle et ekte prøvebildesett. Vi anbefaler å starte med et sett med bildepar og tilordne en ekstern identifikator, som brukes til å foreta en offisiell kampavgjørelse. Paret består av følgende bilder:
   1. Kildebilde – Ditt klarerte kildebilde, for eksempel et førerkort.
   2. Målbilde – Selfien eller bildet du skal sammenligne med.
2. Samle et bildesett med bedragere. Dette er bildepar der kilden og målet ikke stemmer overens. Dette brukes til å vurdere FMR (sannsynligheten for at systemet feilaktig samsvarer med ansiktene til to forskjellige brukere). Du kan lage et bedragerbildesett ved å bruke bildeparene ved å lage et kartesisk produkt av bildene og deretter filtrere og prøve ut resultatet.
3. Undersøk de ekte og bedragerske matchsettene ved å gå over bildeparene, sammenligne kilden og bedragermålet og fange den resulterende likheten.
4. Beregn FMR og FNMR ved å beregne falske positive og falske negative ved forskjellige minimumslikhetsterskler.

Du kan vurdere kostnadene for FMR og FNMR ved ulike likhetsterskler i forhold til søknadens behov.

Trinn 1: Samle ekte bildeparprøver

Å velge et representativt utvalg av bildepar som skal evalueres, er avgjørende når man skal evaluere en identitetsbekreftelsestjeneste. Det første trinnet er å identifisere et ekte sett med bildepar. Dette er kjente kilde- og målbilder av en bruker. Den ekte bildeparingen brukes til å vurdere FNMR, i hovedsak sannsynligheten for at systemet ikke vil matche to ansikter til samme person. Et av de første spørsmålene som ofte stilles er "Hvor mange bildepar er nødvendige?" Svaret er at det avhenger av din brukssituasjon, men den generelle veiledningen er følgende:

• Mellom 100–1,000 bildepar gir et mål på gjennomførbarhet
• Opptil 10,000 XNUMX bildepar er stort nok til å måle variasjon mellom bilder
• Mer enn 10,000 XNUMX bildepar gir et mål på driftskvalitet og generaliserbarhet

Mer data er alltid bedre; som et utgangspunkt, bruk imidlertid minst 1,000 bildepar. Det er imidlertid ikke uvanlig å bruke mer enn 10,000 XNUMX bildepar for å nullstille en akseptabel FNMR eller FMR for et gitt forretningsproblem.

Følgende er et eksempel på bildepar-tilordningsfil. Vi bruker kartfilen for bildepar til å drive resten av evalueringsprosessen.

Trinn 2: Generer et bedragerbildepar sett

Nå som du har en fil med ekte bildepar, kan du lage et kartesisk produkt av mål- og kildebilder der de eksterne identifikatorene ikke fungerer. Dette produserer kilde-til-mål-par som ikke bør samsvare. Denne sammenkoblingen brukes til å vurdere FMR, i hovedsak sannsynligheten for at systemet vil matche ansiktet til en bruker med ansiktet til en annen bruker.

Trinn 3: Undersøk de ekte og falske bildeparsettene

Ved å bruke et driverprogram bruker vi Amazon-anerkjennelse Sammenlign Faces API over bildeparene og fange likheten. Du kan også fange opp tilleggsinformasjon som positur, kvalitet og andre resultater av sammenligningen. Likhetsskårene brukes til å beregne falske og ikke-match-rater i det følgende trinnet.

I den følgende kodebiten bruker vi CompareFaces API på alle bildeparene og fyller ut alle likhetspoengene i en tabell:

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

Kodebiten gir følgende utdata.

Distribusjonsanalyse av likhetspoeng ved tester er et utgangspunkt for å forstå likhetspoeng etter bildepar. Følgende kodebit og utdatadiagram viser et enkelt eksempel på fordelingen av likhetspoeng etter testsett samt resulterende beskrivende statistikk:

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 eksemplet kan vi se at gjennomsnittlig og median likhet for ekte ansiktspar var 91.7 og 99.1, mens for bedragerparene var henholdsvis 2.8 og 0.8. Som forventet viser dette de høye likhetsskårene for ekte bildepar og lave likhetsskårer for bedrageriske bildepar.

Trinn 4: Beregn FMR og FNMR ved forskjellige likhetsterskelnivåer

I dette trinnet beregner vi falske samsvar og ikke-match-rater ved forskjellige terskeler for likhet. For å gjøre dette går vi ganske enkelt gjennom likhetsterskler (for eksempel 90–100). Ved hver valgt likhetsterskel beregner vi forvirringsmatrisen vår som inneholder sanne positive, sanne negative, falske positive og falske negative tellinger, som brukes til å beregne FMR og FNMR ved hver valgt likhet.

For å gjøre dette lager vi en funksjon som returnerer de falske positive og negative tellingene, og går gjennom en rekke likhetsskårer (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 tabell viser resultatene av tellingene ved hver likhetsterskel.

Hvordan påvirker likhetsterskelen falsk ikke-samsvarsfrekvens?

Anta at vi har 1,000 ekte brukerforsøk på ombordstigning, og vi avviser 10 av disse forsøkene basert på en påkrevd minimumslikhet på 95 % for å bli betraktet som en match. Her avviser vi 10 ekte ombordstigningsforsøk (falske negative) fordi likheten deres faller under den spesifiserte minimumskravet for likhetsterskel. I dette tilfellet er vår FNMR 1.0 %.

FNMR = Antall falske negative / (True Positive Count + False Negative Count)

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

Tenk deg derimot, i stedet for å ha 1,000 ekte brukere ombord, har vi 990 ekte brukere og 10 bedragere (falsk positiv). Ved en minimumslikhet på 95 %, anta at vi aksepterer alle 1,000 brukere som ekte. Her ville vi ha 1 % FMR.

FMR = antall falske positive / (totalt antall forsøk)

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

Vurdere kostnader ved FMR og FNMR ved onboarding

I en onboarding-brukstilfelle er kostnaden for en falsk ikke-match (en avvisning) vanligvis forbundet med ytterligere brukerfriksjon eller tap av en registrering. Anta for eksempel at Julie presenterer to bilder av seg selv, men blir feilaktig avvist ved innføring fordi likheten mellom de to bildene faller under den valgte likheten (en falsk ikke-match). Finansinstitusjonen kan risikere å miste Julie som potensiell kunde, eller det kan forårsake Julie ytterligere friksjon ved å kreve at hun utfører skritt for å bevise identiteten sin.

Omvendt, anta at de to bildene av Julie er av forskjellige mennesker og at Julies ombordstigning burde vært avvist. I tilfellet hvor Julie blir feilaktig akseptert (en falsk match), er kostnaden og risikoen for finansinstitusjonen ganske annerledes. Det kan være regulatoriske problemer, risiko for svindel og andre risikoer forbundet med finansielle transaksjoner.

Ansvarlig bruk

Kunstig intelligens (AI) brukt gjennom maskinlæring (ML) vil være en av de mest transformerende teknologiene i vår generasjon, som takler noen av menneskehetens mest utfordrende problemer, øker menneskelig ytelse og maksimerer produktiviteten. Ansvarlig bruk av disse teknologiene er nøkkelen til å fremme fortsatt innovasjon. AWS er ​​forpliktet til å utvikle rettferdige og nøyaktige AI- og ML-tjenester og gi deg verktøyene og veiledningen som trengs for å bygge AI- og ML-applikasjoner på en ansvarlig måte.

Når du tar i bruk og øker bruken av AI og ML, tilbyr AWS flere ressurser basert på vår erfaring for å hjelpe deg med ansvarlig utvikling og bruk av AI og ML:

Beste praksis og vanlige feil å unngå

I denne delen diskuterer vi følgende beste fremgangsmåter:

• Bruk et stort nok utvalg av bilder
• Unngå åpen kildekode og syntetiske ansiktsdatasett
• Unngå manuell og syntetisk bildemanipulering
• Sjekk bildekvaliteten på tidspunktet for evaluering og over tid
• Overvåk FMR og FNMR over tid
• Bruk et menneske i loop gjennomgang
• Hold deg oppdatert med Amazon Rekognition

Bruk et stort nok utvalg av bilder

Bruk et stort nok, men rimelig utvalg av bilder. Hva er en rimelig prøvestørrelse? Det avhenger av forretningsproblemet. Hvis du er arbeidsgiver og har 10,000 10,000 ansatte som du vil autentisere, er det sannsynligvis rimelig å bruke alle 5,000 20,000 bildene. Men anta at du er en organisasjon med millioner av kunder som du vil ha med. I dette tilfellet er det sannsynligvis tilstrekkelig å ta et representativt utvalg av kunder som XNUMX XNUMX–XNUMX XNUMX. Her er noen veiledning om prøvestørrelsen:

• En prøvestørrelse på 100 – 1,000 bildepar beviser gjennomførbarhet
• En prøvestørrelse på 1,000 – 10,000 XNUMX bildepar er nyttig for å måle variasjon mellom bilder
• En prøvestørrelse på 10,000 – 1 million bildepar gir et mål på driftskvalitet og generaliserbarhet

Nøkkelen med å prøve bildepar er å sikre at prøven gir nok variasjon på tvers av populasjonen av ansikter i applikasjonen din. Du kan utvide samplingen og testingen ytterligere til å inkludere demografisk informasjon som hudtone, kjønn og alder.

Unngå åpen kildekode og syntetiske ansiktsdatasett

Det er dusinvis av kuraterte åpen kildekode-ansiktsbildedatasett så vel som forbløffende realistiske syntetiske ansiktssett som ofte brukes i forskning og for å studere gjennomførbarhet. Utfordringen er at disse datasettene vanligvis ikke er nyttige for 99 % av brukstilfellene i den virkelige verden, rett og slett fordi de ikke er representative for kameraene, ansiktene og kvaliteten på bildene applikasjonen din sannsynligvis vil møte i naturen. Selv om de er nyttige for applikasjonsutvikling, generaliserer ikke nøyaktighetsmålene til disse bildesettene til det du vil møte i din egen applikasjon. I stedet anbefaler vi å starte med et representativt utvalg av ekte bilder fra løsningen din, selv om prøvebildeparene er små (under 1,000).

Unngå manuell og syntetisk bildemanipulering

Det er ofte kantsaker som folk er interessert i å forstå. Ting som bildekvalitet eller tilsløring av spesifikke ansiktstrekk er alltid av interesse. For eksempel får vi ofte spørsmål om hvordan alder og bildekvalitet påvirker ansiktsgjenkjenning. Du kan ganske enkelt syntetisk elde et ansikt eller manipulere bildet for å få motivet til å virke eldre, eller manipulere bildekvaliteten, men dette oversettes ikke godt til aldring av bilder i den virkelige verden. I stedet er vår anbefaling å samle et representativt utvalg av virkelige edge-saker du er interessert i å teste.

Sjekk bildekvaliteten på tidspunktet for evaluering og over tid

Kamera- og applikasjonsteknologi endrer seg ganske raskt over tid. Som en beste praksis anbefaler vi å overvåke bildekvaliteten over tid. Fra størrelsen på ansikter som er tatt (ved bruk av avgrensningsbokser), til lysstyrken og skarpheten til et bilde, til posituren til et ansikt, samt potensielle forvirringer (hatter, solbriller, skjegg og så videre), alle disse bildene og ansiktstrekk endres over tid.

Overvåk FNMR og FMR over tid

Endringer skjer, enten det er bildene, applikasjonen eller likhetsterskelene som brukes i applikasjonen. Det er viktig med jevne mellomrom å overvåke falske og ikke-match-rater over tid. Endringer i satsene (selv subtile endringer) kan ofte peke på oppstrømsutfordringer med applikasjonen eller hvordan applikasjonen brukes. Endringer i likhetsterskler og forretningsregler som brukes til å ta beslutninger om å akseptere eller avvise, kan ha stor innvirkning på brukeropplevelsene for onboarding og autentisering.

Bruk et menneske i loop gjennomgang

Identitetsverifiseringssystemer tar automatiske beslutninger om å matche og ikke-matche basert på likhetsterskler og forretningsregler. I tillegg til regulatoriske og interne samsvarskrav, er en viktig prosess i ethvert automatisert beslutningssystem å bruke menneskelige kontrollører som en del av den løpende overvåkingen av beslutningsprosessen. Menneskelig tilsyn med disse automatiserte beslutningssystemene gir validering og kontinuerlig forbedring samt åpenhet i den automatiserte beslutningsprosessen.

Hold deg oppdatert med Amazon Rekognition

Amazon Recognition faces-modellen oppdateres med jevne mellomrom (vanligvis årlig), og er for tiden på versjon 6. Denne oppdaterte versjonen gjorde viktige forbedringer for nøyaktighet og indeksering. Det er viktig å holde seg oppdatert med nye modellversjoner og forstå hvordan du bruker disse nye versjonene i applikasjonen for identitetsbekreftelse. Når nye versjoner av Amazon Rekognition-ansiktsmodellen lanseres, er det god praksis å kjøre evalueringsprosessen for identitetsbekreftelse på nytt og bestemme eventuelle potensielle konsekvenser (positive og negative) for falske samsvar og ikke-match-rater.

konklusjonen

Dette innlegget diskuterer nøkkelelementene som trengs for å evaluere ytelsesaspektet til identitetsbekreftelsesløsningen din i form av ulike nøyaktighetsmålinger. Nøyaktighet er imidlertid bare én av de mange dimensjonene du må vurdere når du velger en bestemt innholdsmodereringstjeneste. Det er avgjørende at du inkluderer andre parametere, for eksempel tjenestens totale funksjonssett, brukervennlighet, eksisterende integrasjoner, personvern og sikkerhet, tilpasningsalternativer, skalerbarhetsimplikasjoner, kundeservice og priser.

For å lære mer om identitetsbekreftelse i Amazon Rekognition, besøk Identitetsbekreftelse ved hjelp av Amazon Rekognition.

Om forfatterne

Mike Ames er en dataforsker som har blitt spesialist på identitetsverifiseringsløsninger, med lang erfaring med utvikling av maskinlæring og AI-løsninger for å beskytte organisasjoner mot svindel, sløsing og misbruk. På fritiden kan du finne ham på fotturer, terrengsykling eller leke freebee med hunden hans Max.

Amit Gupta er senior AI Services Solutions Architect hos AWS. Han er lidenskapelig opptatt av å gjøre det mulig for kunder med velutviklede maskinlæringsløsninger i stor skala.

Zuhayr Raghib er AI Services Solutions Architect hos AWS. Han spesialiserer seg på anvendt AI/ML, og brenner for å gjøre det mulig for kunder å bruke skyen til å innovere raskere og transformere virksomhetene sine.

Marcel Pividal er en Sr. AI Services Solutions Architect i den verdensomspennende spesialistorganisasjonen. Marcel har mer enn 20 års erfaring med å løse forretningsproblemer gjennom teknologi for fintechs, betalingsleverandører, farma og offentlige etater. Hans nåværende fokusområder er risikostyring, svindelforebygging og identitetsverifisering.