Kjør slutninger for datasyn på store videoer med Amazon SageMaker asynkrone endepunkter

AWS-kunder bruker i økende grad datamaskinsyn (CV)-modeller på store input-nyttelaster som kan ta noen få minutters behandlingstid. For eksempel arbeider romteknologiselskaper med en strøm av høyoppløselige satellittbilder for å oppdage spesielle objekter av interesse. Tilsvarende behandler helseselskaper høyoppløselige biomedisinske bilder eller videoer som ekkokardiogrammer for å oppdage anomalier. I tillegg skanner medieselskaper bilder og videoer lastet opp av kundene deres for å sikre at de er kompatible og uten brudd på opphavsretten. Disse applikasjonene mottar utbrudd av innkommende trafikk til forskjellige tider på dagen og krever behandling i nesten sanntid med fullføringsvarsler til en lav kostnad.

Du kan bygge CV-modeller med flere dyplæringsrammer som TensorFlow, PyTorch og Apache MXNet. Disse modellene har vanligvis stor nyttelast, for eksempel bilder eller videoer. Avanserte dyplæringsmodeller for brukstilfeller som objektdeteksjon returnerer store responsnyttelaster som varierer fra titalls MB til hundrevis av MB i størrelse. I tillegg krever høyoppløselige videoer dataintensiv forbehandling før modellslutning. Behandlingstidene kan variere i størrelsesorden minutter, noe som eliminerer muligheten til å kjøre sanntidsslutning ved å sende nyttelast over en HTTP API. I stedet er det behov for å behandle input-nyttelast asynkront fra et objektlager som Amazon enkel lagringstjeneste (Amazon S3) med automatisk kø og en forhåndsdefinert samtidighetsterskel. Systemet skal kunne motta statusvarsler og eliminere unødvendige kostnader ved å rydde opp i ressurser når oppgavene er fullført.

Amazon SageMaker hjelper dataforskere og utviklere med å forberede, bygge, trene og distribuere høykvalitets maskinlæringsmodeller (ML) raskt ved å samle et bredt sett med funksjoner spesialbygd for ML. SageMaker leverer toppmoderne åpen kildekode-modellserveringscontainere for XGBoost (container, SDK), Scikit-Learn (container, SDK), PyTorch (container, SDK), TensorFlow (container, SDK) og Apache MXNet (container, SDK). SageMaker tilbyr tre alternativer for å distribuere trente ML-modeller for å generere slutninger om nye data:

• Slutning i sanntid endepunkter er egnet for arbeidsbelastninger som må behandles med krav til lav ventetid.
• Batchtransformasjon er ideell for offline spådommer på store mengder data som samles inn over en tidsperiode.
• Asynkron slutning endepunkter setter innkommende forespørsler i kø og er ideelle for arbeidsbelastninger der forespørselsstørrelsene er store (opptil 1 GB) og behandlingstiden for slutninger er i størrelsesorden minutter (opptil 15 minutter). Asynkron inferens lar deg spare kostnader ved å automatisk skalere forekomsttellingen til 0 når det ikke er noen forespørsler å behandle.

I dette innlegget viser vi deg hvordan du serverer en PyTorch CV-modell med SageMaker asynkron inferens for å behandle en burst-trafikk av videoer med store input-nyttelast lastet opp til Amazon S3. Vi demonstrerer de nye egenskapene til en intern kø med brukerdefinerte samtidighets- og fullføringsvarsler. Vi konfigurerer automatisk skalering av forekomster for å skalere ned til 0 når trafikken avtar og skalere opp igjen når forespørselskøen fylles opp. Vi bruker en g4dn-instans med en Nvidia T4 GPU og SageMaker forhåndsbygd TorchServe-beholder med et tilpasset slutningsskript for å forhåndsbehandle videoene før modellanrop, og Amazon CloudWatch beregninger for å overvåke køstørrelsen, total behandlingstid, påkallinger behandlet og mer.

Koden for dette eksemplet er tilgjengelig på GitHub.

Løsningsoversikt

Følgende diagram illustrerer løsningsarkitekturen.

Vår modell vert først på skaleringsendepunktet. Deretter laster brukeren eller en annen mekanisme opp en videofil til en S3-inngang. Brukeren påkaller endepunktet og får umiddelbart returnert et Amazon S3-utgangssted der slutningen er skrevet. Etter at slutningen er fullført, lagres resultatet i utgangs S3-bøtten, og en Amazon enkel varslingstjeneste (Amazon SNS) varsel sendes til brukeren og varsler dem om fullført suksess eller fiasko.

Bruk case-modell

For dette objektdeteksjonseksemplet bruker vi en TorchVision Maske-RCNN modell, forhåndstrent på 91 klasser, for å demonstrere slutning på en stablet 4D-video Tensor. Fordi vi oppdager objekter på stor input-nyttelast som krever forhåndsbehandling, kan den totale ventetiden være betydelig. Selv om dette ikke er ideelt for et sanntidsendepunkt, håndteres det enkelt av asynkrone endepunkter, som behandler køen og lagrer resultatene til en Amazon S3-utdataplassering.

For å være vert for denne modellen bruker vi en forhåndsbygd SageMaker PyTorch inferensbeholder som utnytter TorchServe modell serveringsstabel. SageMaker-beholdere lar deg gi ditt eget inferensskript, som gir deg fleksibilitet til å håndtere forbehandling og etterbehandling, samt diktere hvordan modellen din samhandler med dataene.

Input og output nyttelast

I dette eksemplet bruker vi en inngangsvideo på størrelse 71 MB fra her.. Inferensbehandleren til det asynkrone endepunktet forventer en mp4-video, som deles inn i 1024x1024x3 tensorer for hvert sekund med video. For å definere denne behandleren gir vi endepunktet en egendefinert inference.py manus. Skriptet gir funksjoner for modelllasting, dataserialisering og deserialisering, forhåndsbehandling og prediksjon. Innenfor handleren er vår input_fn kaller en hjelpefunksjon kjent som video2frames:

video_frames = []
cap = cv2.VideoCapture(tfile.name)
frame_index, frame_count = 0, 0 if cap.isOpened(): success = True else: success = False while success: success, frame = cap.read() if frame_index % interval == 0: print("---> Reading the %d frame:" % frame_index, success) resize_frame = cv2.resize( frame, (frame_width, frame_height), interpolation=cv2.INTER_AREA ) video_frames.append(resize_frame) frame_count += 1 frame_index += 1 cap.release()
return video_frames

Disse stablede tensorene behandles av vår Mask-RCNN-modell, som lagrer et JSON-resultat som inneholder grenseboksene, etikettene og poengsummene for oppdagede objekter. I dette eksemplet er utgangsnyttelasten 54 MB. Vi demonstrerer en rask visualisering av resultatene i følgende animasjon.

Opprett det asynkrone endepunktet

Vi skaper asynkront endepunkt på samme måte som et vertsbasert endepunkt i sanntid. Trinnene inkluderer opprettelse av en SageMaker modell, etterfulgt av endepunktkonfigurasjon og distribusjon av endepunktet. Forskjellen mellom de to typene endepunkter er at asynkron endepunktkonfigurasjon inneholder en AsyncInferenceConfig-seksjon. I denne delen spesifiserer vi Amazon S3-utdatabanen for resultatene fra endepunktspåkallelsen og inkluderer valgfritt SNS-emner for varsler om suksess og fiasko. Vi spesifiserer også maksimalt antall samtidige påkallinger per forekomst som bestemt av kunden. Se følgende kode:

AsyncInferenceConfig={ "OutputConfig": { "S3OutputPath": f"s3://{bucket}/{bucket_prefix}/output", # Optionally specify Amazon SNS topics for notifications "NotificationConfig": { "SuccessTopic": success_topic, "ErrorTopic": error_topic, } }, "ClientConfig": { "MaxConcurrentInvocationsPerInstance": 2 #increase this value upto throughput peak for best performance } }

For detaljer om API for å lage en endepunktkonfigurasjon for asynkron inferens, Opprett et asynkront inferensendepunkt.

Påkall det asynkrone endepunktet

Inndatanyttelasten i følgende kode er en video .mp4-fil lastet opp til Amazon S3:

sm_session.upload_data( input_location, bucket=sm_session.default_bucket(), key_prefix=prefix, extra_args={"ContentType": "video/mp4"})

Vi bruker Amazon S3 URI til input-nyttelastfilen for å påkalle endepunktet. Responsobjektet inneholder utdataplasseringen i Amazon S3 for å hente resultatene etter fullføring:

response = sm_runtime.invoke_endpoint_async(EndpointName=endpoint_name, InputLocation=input_1_s3_location)
output_location = response['OutputLocation'])

For detaljer om API for å påkalle et asynkront endepunkt, se Påkalle et asynkront endepunkt.

Sett påkallingsforespørslene i kø med brukerdefinert samtidighet

Det asynkrone endepunktet setter automatisk invokasjonsforespørslene i kø. Den bruker MaxConcurrentInvocationsPerInstance parameter i den foregående endepunktkonfigurasjonen for å behandle nye forespørsler fra køen etter at tidligere forespørsler er fullført. Dette er en fullstendig administrert kø med ulike overvåkingsverdier og krever ingen ytterligere konfigurasjon.

Forekomster av automatisk skalering innenfor det asynkrone endepunktet

Vi setter policyen for automatisk skalering med en minimumskapasitet på 0 og en maksimal kapasitet på fem forekomster. I motsetning til vertsbaserte endepunkter i sanntid, støtter asynkrone endepunkter skalering av forekomstene til 0, ved å sette minimumskapasiteten til 0. Med denne funksjonen kan vi skalere ned til 0 forekomster når det ikke er trafikk og betale først når nyttelastene kommer.

Vi bruker ApproximateBacklogSizePerInstance-beregningen for skaleringspolicykonfigurasjonen med et målkøetterslep på fem per forekomst for å skalere ut ytterligere. Vi setter nedkjølingsperioden for ScaleInCooldown til 120 sekunder og ScaleOutCooldown til 120 sekunder. Se følgende kode:

client = boto3.client('application-autoscaling') # Common class representing Application Auto Scaling for SageMaker amongst other services resource_id='endpoint/' + endpoint_name + '/variant/' + 'variant1' # This is the format in which application autoscaling references the endpoint response = client.register_scalable_target( ServiceNamespace='sagemaker', # ResourceId=resource_id, ScalableDimension='sagemaker:variant:DesiredInstanceCount', MinCapacity=0, MaxCapacity=5
) response = client.put_scaling_policy( PolicyName='Invocations-ScalingPolicy', ServiceNamespace='sagemaker', # The namespace of the AWS service that provides the resource. ResourceId=resource_id, # Endpoint name ScalableDimension='sagemaker:variant:DesiredInstanceCount', # SageMaker supports only Instance Count PolicyType='TargetTrackingScaling', # 'StepScaling'|'TargetTrackingScaling' TargetTrackingScalingPolicyConfiguration={ 'TargetValue': 5.0, # The target value for the metric. 'CustomizedMetricSpecification': { 'MetricName': 'ApproximateBacklogSizePerInstance', 'Namespace': 'AWS/SageMaker', 'Dimensions': [{'Name': 'EndpointName', 'Value': endpoint_name }], 'Statistic': 'Average', }, 'ScaleInCooldown': 120, # ScaleInCooldown - The amount of time, in seconds, after a scale in activity completes before another scale in activity can start. 'ScaleOutCooldown': 120 # ScaleOutCooldown - The amount of time, in seconds, after a scale out activity completes before another scale out activity can start.
# 'DisableScaleIn': True|False - indicates whether scale in by the target tracking policy is disabled.
# If the value is true, scale in is disabled and the target tracking policy won't remove capacity from the scalable resource.
}
)

For detaljer om API for automatisk skalering av et asynkront endepunkt, se Autoskaler et asynkront endepunkt.

Varsler fra det asynkrone endepunktet

Vi oppretter to separate SNS-emner for suksess og feilmeldinger for hvert resultat av endepunktanrop:

sns_client = boto3.client('sns')
response = sns_client.create_topic(Name="Async-Demo-ErrorTopic2")
error_topic = response['TopicArn']
response = sns_client.create_topic(Name="Async-Demo-SuccessTopic2")
success_topic = response['TopicArn']

De andre alternativene for varsler inkluderer periodisk kontroll av utdataene til S3-bøtten, eller bruk av S3-bøttevarsler for å utløse en AWS Lambda funksjon ved filopplasting. SNS-varsler er inkludert i endepunktkonfigurasjonsdelen som beskrevet tidligere.

For detaljer om hvordan du setter opp varsler fra et asynkront endepunkt, se Sjekk prediksjonsresultater.

Overvåk det asynkrone endepunktet

Vi overvåker det asynkrone endepunktet med innebygde ekstra CloudWatch-beregninger spesifikt for asynkron inferens. For eksempel overvåker vi kølengden i hver instans med ApproximateBacklogSizePerInstance og total kølengde med ApproximateBacklogSize. Ta i betraktning sletter SNS-emnet for å unngå flomvarslene under de følgende påkallelsene. I det følgende diagrammet kan vi se den innledende etterslepstørrelsen på grunn av plutselig trafikkutbrudd på 1,000 forespørsler, og etterslepstørrelsen per forekomst reduseres raskt ettersom endepunktet skaleres ut fra én til fem forekomster.

På samme måte overvåker vi det totale antallet vellykkede påkallinger med InvocationsProcessed og det totale antallet mislykkede påkallinger med InvocationFailures. I det følgende diagrammet kan vi se gjennomsnittlig antall videoanrop behandlet per minutt etter automatisk skalering på omtrent 18.

Vi overvåker også modellens ventetid, som inkluderer videoforbehandlingstiden og modellslutningen for partiet med videobilder ved 1 FPS. I det følgende diagrammet kan vi se modellforsinkelsen for to samtidige påkallinger er omtrent 30 sekunder.

Vi overvåker også den totale behandlingstiden fra inndata i Amazon S3 til utdata tilbake i Amazon S3 med TotalProcessingTime og tiden brukt i etterslep med TimeInBacklog-beregningen. I det følgende diagrammet kan vi se at gjennomsnittlig tid i etterslep og total behandlingstid øker over tid. Forespørslene som legges til under trafikkutbruddet foran i køen har en etterslep som ligner modellforsinkelsen på 30 sekunder. Forespørslene i slutten av køen har høyest tid i etterslep på ca. 3,500 sekunder.

Vi overvåker også hvordan endepunktet skaleres tilbake til 0 etter å ha behandlet hele køen. Innstillingene for endepunktkjøring viser gjeldende antall forekomster på 0.

Følgende tabell oppsummerer videoinferenseksemplet med en serietrafikk på 1,000 videoanrop.

Vi kan optimalisere endepunktkonfigurasjonen for å få den mest kostnadseffektive forekomsten med høy ytelse. I dette eksemplet bruker vi en g4dn.xlarge-instans med en Nvidia T4 GPU. Vi kan gradvis øke samtidighetsnivået opp til gjennomstrømstoppen mens vi justerer andre modellserver- og containerparametere.

For en fullstendig liste over beregninger, se Overvåking av asynkrone endepunkter.

Rydd opp

Etter at vi har fullført alle forespørslene, kan vi slette endepunktet på samme måte som å slette endepunkter som er vert for sanntid. Merk at hvis vi setter minimumskapasiteten til asynkrone endepunkter til 0, vil det ikke påløpe noen forekomstkostnader etter at den skaleres ned til 0.

Hvis du har aktivert automatisk skalering for endepunktet ditt, sørg for at du avregistrerer endepunktet som et skalerbart mål før du sletter endepunktet. For å gjøre dette, kjør følgende:

response = client.deregister_scalable_target( ServiceNamespace='sagemaker', ResourceId='resource_id', ScalableDimension='sagemaker:variant:DesiredInstanceCount' )

Endepunkter bør slettes når de ikke lenger er i bruk, fordi (iht SageMaker prisside) de faktureres etter utplassert tid. For å gjøre dette, kjør følgende:

sm_client.delete_endpoint(EndpointName=endpoint_name)

konklusjonen

I dette innlegget demonstrerte vi hvordan du bruker den nye asynkrone inferensfunksjonen fra SageMaker til å behandle en stor inndatalast av videoer. For slutninger brukte vi et tilpasset slutningsskript for å forhåndsbehandle videoene med en forhåndsdefinert samplingsfrekvens for bilde og utløse en velkjent PyTorch CV-modell for å generere en liste over utdata for hver video. Vi tok tak i utfordringene med burst-trafikk, høye modellbehandlingstider og store nyttelaster med administrerte køer, forhåndsdefinerte samtidighetsgrenser, svarvarsler og nedskalering til null-funksjoner. For å komme i gang med SageMaker asynkron inferens, se Asynkron inferens og henvise til eksempelkode til egne brukssaker.

Om forfatterne

Hasan Poonawala er en Machine Learning Specialist Solutions Architect ved AWS, basert i London, Storbritannia. Hasan hjelper kunder med å designe og distribuere applikasjoner for maskinlæring i produksjon på AWS. Han er lidenskapelig opptatt av bruk av maskinlæring for å løse forretningsproblemer i ulike bransjer. På fritiden elsker Hasan å utforske naturen utendørs og tilbringe tid med venner og familie.

Raghu Ramesha er en programvareutviklingsingeniør (AI/ML) med Amazon SageMaker Services SA-teamet. Han fokuserer på å hjelpe kunder med å migrere ML-produksjonsarbeidsmengder til SageMaker i stor skala. Han spesialiserer seg på maskinlæring, AI og datasynsdomener, og har en mastergrad i informatikk fra UT Dallas. På fritiden liker han å reise og fotografere.

Sean Morgan er AI/ML Solutions Architect hos AWS. Han har erfaring innen halvleder- og akademisk forskningsfelt, og bruker sin erfaring til å hjelpe kundene med å nå sine mål på AWS. På fritiden er Sean en aktiv bidragsyter og vedlikeholder av åpen kildekode, og er spesialinteressegruppeleder for TensorFlow-tillegg.

Kilde: https://aws.amazon.com/blogs/machine-learning/run-computer-vision-inference-on-large-videos-with-amazon-sagemaker-asynchronous-endpoints/