Generativ dataintelligens

AI

Forbedre nøyaktigheten av Amazon Rekognition Face Search med brukervektorer | Amazon Web Services

Republisert av Platon
Republisert av Platon

Dato:

Visninger: 0

I ulike bransjer, som finansielle tjenester, telekommunikasjon og helsetjenester, bruker kunder en digital identitetsprosess, som vanligvis involverer flere trinn for å verifisere sluttbrukere under online onboarding eller step-up autentisering. Et eksempel på ett trinn som kan brukes er ansiktssøk, som kan bidra til å avgjøre om ansiktet til en ny sluttbruker samsvarer med de som er knyttet til en eksisterende konto.

Å bygge et nøyaktig ansiktssøksystem innebærer flere trinn. Systemet må kunne oppdage menneskelige ansikter i bilder, trekke ut ansiktene til vektorrepresentasjoner, lagre ansiktsvektorer i en database og sammenligne nye ansikter mot eksisterende oppføringer. Amazon-anerkjennelse gjør dette enkelt ved å gi deg forhåndstrente modeller som påkalles via enkle API-kall.

Amazon Rekognition lar deg oppnå svært høy ansiktssøknøyaktighet med ett enkelt ansiktsbilde. I noen tilfeller kan du bruke flere bilder av samme persons ansikt for å lage brukervektorer og forbedre nøyaktigheten ytterligere. Dette er spesielt nyttig når bilder har variasjoner i lyssetting, positurer og utseende.

I dette innlegget viser vi hvordan du bruker Amazon Rekognition Face Search API-er med brukervektorer for å øke likhetspoengene for sanne treff og redusere likhetspoengsummen for ekte ikke-treff.

Vi sammenligner resultatene av å utføre ansiktsmatching med og uten brukervektorer.

Amazon Rekognition ansiktsmatching

Amazon Rekognition face matching gjør det mulig å måle likheten mellom en ansiktsvektor hentet fra ett bilde med en ansiktsvektor hentet fra et annet bilde. Et par ansiktsbilder sies å være en ekte match hvis begge bildene inneholder ansiktet til samme person, og en ekte ikke-match ellers. Amazon Rekognition returnerer en poengsum for likheten mellom kilde- og målansiktene. Minste likhetspoeng er 0, noe som betyr svært liten likhet, og maksimum er 100.

For å sammenligne et kildeansikt med en samling av målansikter (1:N-matching), lar Amazon Rekognition deg lage et samlingsobjekt og fylle det med ansikter fra bilder ved hjelp av API-kall.

Når du legger til et ansikt i en samling, lagrer ikke Amazon Rekognition selve bildet av ansiktet, men snarere ansiktsvektoren, en matematisk representasjon av ansiktet. Med SearchFaces API, kan du sammenligne et kildeansikt med en eller flere samlinger av målansikter.

I juni 2023, AWS lanserte brukervektorer, en ny funksjon som forbedrer ansiktssøkets nøyaktighet betydelig ved å bruke flere ansiktsbilder av en bruker. Nå kan du lage brukervektorer, som samler flere ansiktsvektorer av samme bruker. Brukervektorer tilbyr høyere ansiktssøknøyaktighet med mer robuste avbildninger, fordi de inneholder varierende grader av belysning, skarphet, positur, utseende og mer. Dette forbedrer nøyaktigheten sammenlignet med søk mot individuelle ansiktsvektorer.

I de følgende avsnittene skisserer vi prosessen med å bruke Amazon Rekognition-brukervektorer. Vi veileder deg gjennom å lage en samling, lagre ansiktsvektorer i den samlingen, aggregere disse ansiktsvektorene til brukervektorer, og deretter sammenligne resultatene av søk mot de individuelle ansiktsvektorene og brukervektorene.

Løsningsoversikt

For denne løsningen bruker vi en Amazon Rekognition-samling av brukere, hver med tilhørende indekserte ansiktsvektorer fra en rekke forskjellige bilder av ansikter for hver bruker.

La oss se på arbeidsflyten for å bygge en samling med brukere og ansikter:

  1. Lag en Amazon Rekognition-samling.
  2. For hver bruker oppretter du en bruker i samlingen.
  3. For hvert bilde av brukeren legger du til ansiktet i samlingen (IndexFaces, som returnerer ansikts-ID som tilsvarer hver ansiktsvektor).
  4. Knytt alle indekserte ansikts-ID-er til brukeren (dette er nødvendig for brukervektorer).

Deretter vil vi sammenligne følgende arbeidsflyter:

Søker med et nytt gitt inngangsbilde mot individuelle ansiktsvektorer i samlingen vår:

  1. Få alle ansikter fra et bilde (Oppdag ansikter).
  2. For hvert ansikt, sammenligne med individuelle ansikter i samlingen vår (SearchFacesByImage).

Søker med et nytt gitt inngangsbilde mot brukervektorer i samlingen vår:

  1. Få alle ansikter fra et bilde (Oppdag ansikter).
  2. For hvert ansikt, sammenlign med brukervektoren (SearchUsersByImage).

La oss nå beskrive løsningen i detalj.

Forutsetninger

Legg til følgende policy til din AWS identitets- og tilgangsadministrasjon (IAM) bruker eller rolle. Retningslinjene gir deg tillatelse til de relevante Amazon Rekognition APIene og gir tilgang til en Amazon enkel lagringstjeneste (Amazon S3) bøtte for å lagre bildene:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "RekognitionPermissions",
            "Effect": "Allow",
            "Action": [
                "rekognition:CreateCollection",
                "rekognition:DeleteCollection",
                "rekognition:CreateUser",
                "rekognition:IndexFaces",
                "rekognition:DetectFaces",
                "rekognition:AssociateFaces",
                "rekognition:SearchUsersByImage",
                "rekognition:SearchFacesByImage"
            ],
            "Resource": "*"
        },
        {
            "Sid": "S3BucketPermissions",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::<replace_with_your_bucket>/*",
                "arn:aws:s3:::<replace_with_your_bucket>"
            ]
        }
    ]
}

Lag en Amazon Rekognition-samling og legg til brukere og ansikter

Først lager vi en S3-bøtte for å lagre brukernes bilder. Vi organiserer bøtta ved å lage en mappe for hver bruker som inneholder deres personlige bilder. Vår bilder mappe ser ut som følgende struktur:

── images
│   ├── photo.jpeg
│   ├── Swami
│   │   ├── Swami1.jpeg
│   │   └── Swami2.jpeg
│   └── Werner
│       ├── Werner1.jpeg
│       ├── Werner2.jpeg
│       └── Werner3.jpeg

Vår S3-bøtte har en katalog for hver bruker som lagrer bildene deres. Det er for tiden to mapper, og hver inneholder flere bilder. Du kan legge til flere mapper for brukerne, som hver inneholder ett eller flere bilder som skal indekseres.

Deretter lager vi vår Amazon Rekognition-samling. Vi har levert helpers.py, som inneholder forskjellige metoder som vi bruker:

  • opprette_samling – Opprett en ny samling
  • delete_collection – Slett en samling
  • Opprett bruker – Opprett en ny bruker i en samling
  • add_faces_to_collection – Legg til ansikter i samlingen
  • assosierte_ansikter – Tilknytt face_ids til en bruker i en samling
  • get_subdirs – Få alle underkataloger under S3-prefikset
  • get_filer – Få alle filer under S3-prefikset

Følgende er en eksempelmetode for å lage en Amazon Rekognition-samling:

import boto3
session = boto3.Session()
client = session.client('rekognition')

def create_collection(collection_id):
    try:
        # Create a collection
        print('Creating collection:' + collection_id)
        response = client.create_collection(CollectionId=collection_id)
        print('Collection ARN: ' + response['CollectionArn'])
        print('Status code: ' + str(response['StatusCode']))
        print('Done...')
    except client.exceptions.ResourceAlreadyExistsException:
        print('Resource already exits...')

Opprett samlingen med følgende kode:

import helpers
collection_id = "faces-collection"
helpers.create_collection(collection_id)

La oss deretter legge til ansiktsvektorene i samlingen vår og samle dem til brukervektorer.

For hver bruker i S3-katalogen oppretter vi en brukervektor i samlingen. Deretter indekserer vi ansiktsbildene for hver bruker i samlingen som individuelle ansiktsvektorer, som genererer ansikts-IDer. Til slutt knytter vi ansikts-ID-ene til den aktuelle brukervektoren.

Dette skaper to typer vektorer i samlingen vår:

  • Individuelle ansiktsvektorer
  • Brukervektorer, som er bygget basert på ansiktsvektor-IDene som er levert ved bruk av metoden associate_faces

Se følgende kode:

bucket = '<replace_with_your_bucket>'
prefix = 'images/'

# Get all the users directories from s3 containing the images
folder_list = helpers.get_subdirs(bucket, prefix)
print(f"Found users folders: {folder_list}")
print()

for user_id in folder_list:
    face_ids = []
    helpers.create_user(collection_id, user_id)
    # Get all files per user under the s3 user directory
    images = helpers.get_files(bucket, prefix + user_id + "/")
    print (f"Found images={images} for {user_id}")
    for image in images:
        face_id = helpers.add_faces_to_collection(bucket, image, collection_id)
        face_ids.append(face_id)
    helpers.associate_faces(collection_id, user_id, face_ids)
    print()

Vi bruker følgende metoder:

  • get_subdirs – Returnerer en liste over alle brukernes kataloger. I vårt eksempel er verdien [Swami,Werner].
  • get_filer – Returnerer alle bildefilene under S3-prefikset for brukeren.
  • face_ids – Dette er en liste som inneholder alle ansikts-ID-ene som tilhører en bruker. Vi bruker denne listen når vi ringer til AssociateFaces API.

Som forklart tidligere kan du legge til flere brukere ved å legge til mapper for dem (mappen dikterer bruker-IDen) og legge til bildene dine i den mappen (ingen bestilling er nødvendig for filene).

Nå som miljøet vårt er satt opp og vi har både individuelle ansiktsvektorer og brukervektorer, la oss sammenligne søkekvaliteten vår med hver av dem. For å gjøre det bruker vi et nytt bilde med flere personer og prøver å matche ansiktene deres mot samlingen vår, først mot de individuelle ansiktsvektorene og deretter mot brukervektorene.

Ansiktssøk av bilde mot en samling individuelle ansiktsvektorer

For å søke mot våre individuelle ansiktsvektorer bruker vi Amazon Rekognition SearchFacesByImage API. Denne funksjonen bruker et kildeansiktsbilde for å søke mot individuelle ansiktsvektorer i samlingen vår og returnerer ansikter som samsvarer med vår definerte likhetspoengterskel.

Et viktig hensyn er at SearchFacesByImage API vil kun fungere på det største ansiktet som er oppdaget i bildet. Hvis det er flere ansikter, må du beskjære hvert enkelt ansikt og sende det separat til metoden for identifikasjon.

For å trekke ut ansiktsdetaljer fra et bilde (som deres plassering på bildet), bruker vi Amazon Rekognition Oppdag ansikter API.

Følgende oppdage_ansikter_i_bilde metoden oppdager ansikter i et bilde. For hvert ansikt utfører den følgende handlinger:

  • Skriv ut plasseringen av avgrensningsboksen
  • Beskjær ansiktet fra bildet og sjekk om et slikt ansikt finnes i samlingen og skriv ut brukeren eller "Ukjent"
  • Skriv ut likhetspoengsummen

Eksempelet Python-koden bruker Pute bibliotek for å utføre bildemanipulasjoner (som utskrift, tegning og beskjæring).

Vi bruker en likhetspoengterskel på 99 %, som er en vanlig innstilling for brukstilfeller for identitetsbekreftelse.

Kjør følgende kode:

import detect_users
from PIL import Image

# The image we would like to match faces against our collection.
file_key= "images/photo.jpeg"

img = detect_users.detect_faces_in_image(
    bucket, 
    file_key, 
    collection_id, 
    threshold=99
)
img.show() # or in Jupyter use display(img)

file_key er S3-objektnøkkelen vi ønsker å matche mot samlingen vår. Vi har levert et eksempelbilde (photo.jpeg) under bildemappen.

Følgende bilde viser resultatene våre.

Ved å bruke en terskel på 99 % ble bare én person identifisert. Dr. Werner Vogels ble flagget som ukjent. Hvis vi kjører den samme koden med en lavere terskel på 90 (sett terskel=90), får vi følgende resultater.

Nå ser vi at Dr. Werner Vogels ansikt har en likhetsscore på 96.86 %. La oss deretter sjekke om vi kan få likhetspoengene over vår definerte terskel ved å bruke brukervektorer.

Ansiktssøk av bilde mot en samling av brukervektorer

For å søke mot våre brukervektorer bruker vi Amazon Rekognition SearchUsersByImage API. Denne funksjonen bruker et kildeansiktsbilde for å søke mot brukervektorer i samlingen vår og returnerer brukere som samsvarer med vår definerte likhetspoengterskel.

Det samme hensynet er relevant her – den SearchUsersByImage API vil kun fungere på det største ansiktet som er oppdaget i bildet. Hvis det er flere ansikter til stede, må du beskjære hvert enkelt ansikt og sende det separat til metoden for identifikasjon.

For å trekke ut ansiktsdetaljer fra et bilde (som deres plassering på bildet), bruker vi Amazon Rekognition Oppdag ansikter API.

Følgende oppdage_brukere_i_bilde metoden oppdager ansikter i et bilde. For hvert ansikt utfører den følgende handlinger:

  • Skriv ut plasseringen av avgrensningsboksen
  • Beskjær ansiktet fra bildet og sjekk om et slikt brukeransikt finnes i samlingen vår og skriv ut brukeren eller "Ukjent"
  • Skriv ut likhetspoengsummen

Se følgende kode:

import boto3
import io
import math
from PIL import Image, ImageDraw, ImageFont

def detect_users_in_image(bucket, key, collection_id, threshold=80):

    session = boto3.Session()
    client = session.client('rekognition')

    # Load image from S3 bucket
    s3_connection = boto3.resource('s3')
    s3_object = s3_connection.Object(bucket, key)
    s3_response = s3_object.get()

    stream = io.BytesIO(s3_response['Body'].read())
    image = Image.open(stream)

    # Call DetectFaces to find faces in image
    response = client.detect_faces(
        Image={'S3Object': {'Bucket': bucket, 'Name': key}},
        Attributes=['ALL']
    )

    imgWidth, imgHeight = image.size
    draw = ImageDraw.Draw(image)

    # Calculate and display bounding boxes for each detected face
    for faceDetail in response['FaceDetails']:
        print('The detected face is between ' + str(faceDetail['AgeRange']['Low'])
              + ' and ' + str(faceDetail['AgeRange']['High']) + ' years old')

        box = faceDetail['BoundingBox']
        left = imgWidth * box['Left']
        top = imgHeight * box['Top']
        width = imgWidth * box['Width']
        height = imgHeight * box['Height']

        print('Left: ' + '{0:.0f}'.format(left))
        print('Top: ' + '{0:.0f}'.format(top))
        print('Face Width: ' + "{0:.0f}".format(width))
        print('Face Height: ' + "{0:.0f}".format(height))

        points = (
            (left, top),
            (left + width, top),
            (left + width, top + height),
            (left, top + height),
            (left, top)
        )

        # Crop the face box and convert it to byte array
        face = image.crop((left, top, left + width, top + height))
        imgByteArr = image_to_byte_array(face, image.format)

        # Search for a user in our collection using the cropped image
        user_response = client.search_users_by_image(
            CollectionId=collection_id,
            Image={'Bytes': imgByteArr},
            UserMatchThreshold=threshold
        )
        # print (user_response)

        # Extract user id and the similarity from the response
        if (user_response['UserMatches']):
            similarity = user_response['UserMatches'][0]['Similarity']
            similarity = (math.trunc(similarity * 100) / 100) if isinstance(similarity, float) else similarity
            user_id = user_response['UserMatches'][0]['User']['UserId']
            print(f"User {user_id} was found, similarity of {similarity}%")
            print("")
        else:
            user_id = "Unknown"
            similarity = 0

        draw.line(points, fill='#00d400', width=4)
        font = ImageFont.load_default(size=25)
        draw.text((left, top - 30), user_id, fill='#00d400', font=font)
        if similarity > 0:
            draw.text((left, top + 1), str(similarity), fill='#00d400', font=font)

    return image

Funksjonen returnerer et endret bilde med resultatene som kan lagres på Amazon S3 eller skrives ut. Funksjonen sender også ut statistikk om estimert alder på ansiktene til terminalen.

Kjør følgende kode:

import detect_users
from PIL import Image

# The image we would like to match faces against our collection.
file_key= "images/photo.jpeg"

img = detect_users.detect_users_in_image(
    bucket, 
    file_key, 
    collection_id, 
    threshold=99
)
img.show() # or in Jupyter use display(img)

Følgende bilde viser resultatene våre.

Brukerne som finnes i samlingen vår ble identifisert korrekt med høy likhet (over 99%).

Vi var i stand til å øke likhetspoengene ved å bruke tre ansiktsvektorer per brukervektor. Etter hvert som vi øker antallet ansiktsvektorer som brukes, forventer vi at likhetspoengsummen for sanne kamper også vil øke. Du kan bruke opptil 100 ansiktsvektorer per brukervektor.

En ende-til-ende eksempelkode finner du i GitHub repository. Den inkluderer en detaljert Jupyter notisbok som du kan løpe på Amazon SageMaker Studio (eller andre alternativer).

Rydd opp

For å slette samlingen, bruk følgende kode:

helpers.delete_collection(collection_id)

konklusjonen

I dette innlegget presenterte vi hvordan du bruker Amazon Rekognition-brukervektorer for å implementere ansiktssøk mot en samling av brukernes ansikter. Vi demonstrerte hvordan vi kan forbedre nøyaktigheten av ansiktssøk ved å bruke flere ansiktsbilder per bruker og sammenlignet det med individuelle ansiktsvektorer. I tillegg beskrev vi hvordan du kan bruke de forskjellige Amazon Rekognition APIene for å oppdage ansikter. Den medfølgende eksempelkoden fungerer som et solid grunnlag for å konstruere et funksjonelt ansiktssøkesystem.

For mer informasjon om Amazon Rekognition-brukervektorer, se Søker etter ansikter i en samling. Hvis du er ny på Amazon Rekognition, kan du bruke vår Free Tier, som varer i 12 måneder og inkluderer behandling av 5,000 bilder per måned og lagring av 1,000 brukervektorobjekter per måned.

Om forfatterne

Arik Porat er en Senior Startups Solutions Architect hos Amazon Web Services. Han jobber med startups for å hjelpe dem med å bygge og designe sine løsninger i skyen, og brenner for maskinlæring og containerbaserte løsninger. På fritiden liker Arik å spille sjakk og dataspill.

Eliran Efron er en Startups Solutions Architect hos Amazon Web Services. Eliran er en data- og dataentusiast, og hjelper startups med å designe systemarkitekturene sine. På fritiden liker Eliran å bygge og kjøre biler i Touring-løp og bygge IoT-enheter.

spot_img

Siste etterretning

spot_img

Copyright @ 2024 Plato Technologies Inc.

Chat med oss

Hei der! Hvordan kan jeg hjelpe deg?