Kør flere deep learning-modeller på GPU med Amazon SageMaker multi-model endpoints

Efterhånden som AI-adoptionen accelererer på tværs af industrien, bygger kunderne sofistikerede modeller, der drager fordel af nye videnskabelige gennembrud inden for deep learning. Disse næste generations modeller giver dig mulighed for at opnå state-of-the-art, menneskelignende ydeevne inden for områderne naturlig sprogbehandling (NLP), computersyn, talegenkendelse, medicinsk forskning, cybersikkerhed, forudsigelse af proteinstruktur og mange andre . For eksempel kan store sprogmodeller som GPT-3, OPT og BLOOM oversætte, opsummere og skrive tekst med menneskelignende nuancer. I computervisionsrummet kan tekst-til-billede diffusionsmodeller som DALL-E og Imagen skabe fotorealistiske billeder fra naturligt sprog med et højere niveau af visuel og sproglig forståelse fra verden omkring os. Disse multimodale modeller giver rigere funktioner til forskellige downstream-opgaver og evnen til at finjustere dem til specifikke domæner, og de bringer stærke forretningsmuligheder til vores kunder.

Disse dybe læringsmodeller bliver ved med at vokse med hensyn til størrelse og indeholder typisk milliarder af modelparametre til at skalere modellens ydeevne til en lang række opgaver, såsom billedgenerering, tekstresumé, sprogoversættelse og mere. Der er også behov for at tilpasse disse modeller for at levere en hyper-personlig oplevelse til enkeltpersoner. Som følge heraf udvikles et større antal modeller ved at finjustere disse modeller til forskellige downstream-opgaver. For at opfylde latens- og gennemløbsmålene for AI-applikationer foretrækkes GPU-forekomster frem for CPU-forekomster (i betragtning af GPU'ernes beregningskraft). GPU-instanser er dog dyre, og omkostningerne kan stige, hvis du implementerer mere end 10 modeller. Selvom disse modeller potentielt kan bringe virkningsfulde AI-applikationer, kan det være udfordrende at skalere disse deep learning-modeller på omkostningseffektive måder på grund af deres størrelse og antallet af modeller.

Amazon SageMaker multi-model endpoints (MME'er) giver en skalerbar og omkostningseffektiv måde at implementere et stort antal deep learning-modeller på. MME'er er et populært hostingvalg til at være vært for hundredvis af CPU-baserede modeller blandt kunder som Zendesk, Veeva og AT&T. Tidligere havde du begrænsede muligheder for at implementere hundredvis af deep learning-modeller, der havde brug for accelereret beregning med GPU'er. I dag annoncerer vi MME-understøttelse af GPU. Nu kan du implementere tusindvis af deep learning-modeller bag ét SageMaker-slutpunkt. MME'er kan nu køre flere modeller på en GPU-kerne, dele GPU-instanser bag et slutpunkt på tværs af flere modeller og dynamisk indlæse og aflæse modeller baseret på den indkommende trafik. Med dette kan du spare betydeligt på omkostningerne og opnå den bedste prisydelse.

I dette indlæg viser vi, hvordan man kører flere deep learning-modeller på GPU med SageMaker MME'er.

SageMaker MME'er

SageMaker MME'er giver dig mulighed for at implementere flere modeller bag et enkelt inferensendepunkt, der kan indeholde en eller flere forekomster. Med MME'er administreres hver instans til at indlæse og betjene flere modeller. MME'er giver dig mulighed for at bryde de lineært stigende omkostninger ved at hoste flere modeller og genbruge infrastruktur på tværs af alle modeller.

Følgende diagram illustrerer arkitekturen af ​​en SageMaker MME.

SageMaker MME downloader dynamisk modeller fra Amazon Simple Storage Service (Amazon S3), når den aktiveres, i stedet for at downloade alle modellerne, når slutpunktet først oprettes. Som et resultat heraf kan en indledende invokation til en model se højere slutningsforsinkelse end de efterfølgende slutninger, som afsluttes med lav latens. Hvis modellen allerede er indlæst på containeren, når den startes, springes download- og indlæsningstrinnet over, og modellen returnerer inferenserne med lav latenstid. Antag for eksempel, at du har en model, der kun bliver brugt få gange om dagen. Det indlæses automatisk efter behov, hvorimod hyppigt tilgåede modeller bevares i hukommelsen og aktiveres med konsekvent lav latenstid.

SageMaker MME'er med GPU-understøttelse

SageMaker MME'er med GPU arbejder vha NVIDIA Triton Inference Server. NVIDIA Triton Inference Server er en open source inferensserveringssoftware, der forenkler inferensserveringsprocessen og giver høj inferensydelse. Triton understøtter alle større trænings- og inferensrammer, såsom TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, custom C++ og mere. Det tilbyder dynamisk batching, samtidige kørsler, post-træning kvantisering og optimal modelkonfiguration for at opnå højtydende inferens. Derudover er NVIDIA Triton Inference Server blevet udvidet til at implementere MME API kontrakt, for at integrere med MME.

Følgende diagram illustrerer en MME-arbejdsgang.

Workflow-trinene er som følger:

1. SageMaker MME modtager en HTTP-ankaldelsesanmodning for en bestemt model ved hjælp af TargetModel i anmodningen sammen med nyttelasten.
2. SageMaker dirigerer trafikken til den rigtige instans bag det slutpunkt, hvor målmodellen indlæses. SageMaker forstår trafikmønsteret på tværs af alle modellerne bag MME'en og ruter forespørgsler på en smart måde.
3. SageMaker tager sig af modelstyring bag endpointet, indlæser dynamisk modellen til containerens hukommelse og aflæser modellen baseret fra den delte flåde af GPU-instanser for at give den bedste prisydelse.
4. SageMaker downloader dynamisk modeller fra Amazon S3 til instansens lagervolumen. Hvis den påkaldte model ikke er tilgængelig på instanslagervolumen, downloades modellen til instanslagervolumen. Hvis instansens lagervolumen når kapacitet, sletter SageMaker alle ubrugte modeller fra lagervolumen.
5. SageMaker indlæser modellen til NVIDIA Triton-beholderens hukommelse på en GPU-accelereret instans og betjener inferensanmodningen. GPU-kernen deles af alle modellerne i en instans. Hvis modellen allerede er indlæst i containerhukommelsen, serveres de efterfølgende anmodninger hurtigere, fordi SageMaker ikke behøver at downloade og indlæse den igen.
6. SageMaker sørger for trafikformning til MME-slutpunktet og vedligeholder optimale modelkopier på GPU-instanser for den bedste prisydelse. Den fortsætter med at dirigere trafik til den instans, hvor modellen er indlæst. Hvis instansressourcerne når kapacitet på grund af høj udnyttelse, losser SageMaker de mindst brugte modeller fra containeren for at frigøre ressourcer til at indlæse hyppigere brugte modeller.

SageMaker MME'er kan skalere horisontalt ved hjælp af en automatisk skaleringspolitik og levere yderligere GPU-beregningsforekomster baseret på metrics såsom påkald pr. instans og GPU-udnyttelse for at betjene enhver trafikstigning til MME-endepunkter.

Løsningsoversigt

I dette indlæg viser vi dig, hvordan du bruger de nye funktioner i SageMaker MME'er med GPU med et computersynsbrug. Til demonstrationsformål bruger vi en ResNet-50-konvolutionelt neuralt netværk fortrænet model, der kan klassificere billeder i 1,000 kategorier. Vi diskuterer, hvordan du gør følgende:

• Brug en NVIDIA Triton-inferenscontainer på SageMaker MME'er ved at bruge forskellige Triton-modelramme-backends såsom PyTorch og TensorRT
• Konverter ResNet-50-modeller til optimeret TensorRT-motorformat og implementer det med en SageMaker MME
• Konfigurer politikker for automatisk skalering for MME'en
• Få indsigt i instans- og invokationsmetrics ved hjælp af amazoncloudwatch

Opret modelartefakter

Dette afsnit gennemgår trinene til at forberede en ResNet-50 præ-trænet model til at blive implementeret på en SageMaker MME ved hjælp af Triton Inference Server-modelkonfigurationer. Du kan gengive alle trinene ved at bruge trin-for-trin notesbogen på GitHub.

Til dette indlæg demonstrerer vi implementering med to modeller. Du kan dog forberede og implementere hundredvis af modeller. Modellerne deler måske eller ikke de samme rammer.

Forbered en PyTorch-model

Først indlæser vi en præ-trænet ResNet50-model ved hjælp af torchvision-modeller-pakken. Vi gemmer modellen som en model.pt fil i TorchScript optimeret og serialiseret format. TorchScript kompilerer et fremadgående pass af ResNet50-modellen i ivrig tilstand med eksempelinput, så vi sender en forekomst af et RGB-billede med tre farvekanaler med dimensionen 224 x 224.

Så skal vi forberede modellerne til Triton Inference Server. Følgende kode viser modellageret for PyTorch framework-backend. Triton bruger model.pt-filen placeret i modellageret til at tjene forudsigelser.

resnet
├── 1
│   └── model.pt
└── config.pbtxt

Modellens konfigurationsfil config.pbtxt skal angive navnet på modellen (resnet), platformen og backend-egenskaberne (pytorch_libtorch), max_batch_size (128), og input- og outputtensorerne sammen med datatypen (TYPE_FP32) Information. Derudover kan du angive instance_group , dynamic_batching egenskaber for at opnå højtydende inferens. Se følgende kode:

name: "resnet"
platform: "pytorch_libtorch"
max_batch_size: 128
input {
  name: "INPUT__0"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "OUTPUT__0"
  data_type: TYPE_FP32
  dims: 1000
}

Forbered TensorRT-modellen

NVIDIA TensorRT er en SDK til højtydende deep learning-inferens og inkluderer en deep learning-inferensoptimering og runtime, der leverer lav latenstid og høj gennemstrømning til inferensapplikationer. Vi bruger kommandolinjeværktøjet trtexec at generere en TensorRT-serialiseret motor fra en ONNX model format. Udfør følgende trin for at konvertere en ResNet-50 præ-trænet model til NVIDIA TensorRT:

1. Eksporter den fortrænede ResNet-50-model til et ONNX-format vha torch.onnx. Dette trin kører modellen én gang for at spore dens kørsel med et eksempelinput og eksporterer derefter den sporede model til den angivne fil model.onnx.
2. Brug trtexec til at oprette en TensorRT-motorplan fra model.onnx fil. Du kan valgfrit reducere præcisionen af ​​flydende kommaberegninger, enten ved blot at køre dem i 16-bit flydende komma eller ved at kvantisere flydende kommaværdier, så beregninger kan udføres ved hjælp af 8-bit heltal.

Følgende kode viser modellagerstrukturen for TensorRT-modellen:

resnet
├── 1
│   └── model.plan
└── config.pbtxt

For TensorRT-modellen specificerer vi tensorrt_plan som platformen og indtast Tensor-specifikationerne for billedet med dimension 224 x 224, som har farvekanalerne. Udgangen Tensor med 1,000 dimensioner er af typen TYPE_FP32, svarende til de forskellige objektkategorier. Se følgende kode:

name: "resnet"
platform: "tensorrt_plan"
max_batch_size: 128
input {
  name: "input"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "output"
  data_type: TYPE_FP32
  dims: 1000
}
model_warmup {
    name: "bs128 Warmup"
    batch_size: 128
    inputs: {
        key: "input"
        value: {
            data_type: TYPE_FP32
            dims: 3
            dims: 224
            dims: 224
            zero_data: false
        }
    }
}

Gem modelartefakter i Amazon S3

SageMaker forventer, at modellens artefakter kommer ind .tar.gz format. De skal også opfylde Triton-beholderkrav, såsom modelnavn, version, config.pbtxt filer og mere. tar mappen, der indeholder modelfilen som .tar.gz og upload det til Amazon S3:

!mkdir -p triton-serve-pt/resnet/1/
!mv -f workspace/model.pt triton-serve-pt/resnet/1/
!tar -C triton-serve-pt/ -czf resnet_pt_v0.tar.gz resnet
model_uri_pt = sagemaker_session.upload_data(path="resnet_pt_v0.tar.gz", key_prefix="resnet-mme-gpu")
!mkdir -p triton-serve-trt/resnet/1/
!mv -f workspace/model.plan triton-serve-trt/resnet/1/
!tar -C triton-serve-trt/ -czf resnet_trt_v0.tar.gz resnet
model_uri_trt = sagemaker_session.upload_data(path="resnet_trt_v0.tar.gz", key_prefix="resnet-mme-gpu")

Nu hvor vi har uploadet modelartefakterne til Amazon S3, kan vi oprette en SageMaker MME.

Implementer modeller med en MME

Vi implementerer nu en ResNet-50-model med to forskellige framework-backends (PyTorch og TensorRT) til en SageMaker MME.

Bemærk, at du kan implementere hundredvis af modeller, og modellerne kan bruge den samme ramme. De kan også bruge forskellige rammer, som vist i dette indlæg.

Vi bruger AWS SDK til Python (Boto3) API'er skabe_model, create_endpoint_configog oprette_slutpunkt at oprette en MME.

Definer serveringsbeholderen

I containerdefinitionen skal du definere model_data_url for at angive S3-biblioteket, der indeholder alle de modeller, som SageMaker MME bruger til at indlæse og betjene forudsigelser. Sæt Mode til MultiModel for at angive, at SageMaker opretter slutpunktet med MME-beholderspecifikationer. Vi indstiller beholderen med et billede, der understøtter implementering af MME'er med GPU. Se følgende kode:

container = {
"Image": ,
"ModelDataUrl": ,
"Mode": "MultiModel"
}

Opret et multi-model objekt

Brug SageMaker Boto3-klienten til at oprette modellen ved hjælp af create_model API. Vi videregiver containerdefinitionen til skabe model API sammen med ModelName , ExecutionRoleArn:

create_model_response = sm_client.create_model(
    ModelName=, ExecutionRoleArn=role, PrimaryContainer=container
)

Definer MME-konfigurationer

Opret MME-konfigurationer ved hjælp af create_endpoint_config Boto3 API. Angiv en accelereret GPU-beregningsinstans i InstanceType (vi bruger instanstypen g4dn.4xlarge). Vi anbefaler at konfigurere dine slutpunkter med mindst to forekomster. Dette giver SageMaker mulighed for at levere et meget tilgængeligt sæt forudsigelser på tværs af flere tilgængelighedszoner for modellerne.

Baseret på vores resultater kan du få bedre prisydelse på ML-optimerede instanser med en enkelt GPU-kerne. Derfor er MME-understøttelse af GPU-funktionen kun aktiveret for enkelt-GPU-kerneinstanser. Se en komplet liste over understøttede instanser Understøttede GPU-instanstyper.

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=,
    ProductionVariants=[
        {
            "InstanceType": "ml.g4dn.4xlarge",
            "InitialVariantWeight": 1,
            "InitialInstanceCount": 2,
            "ModelName": ,
            "VariantName": "AllTraffic",
        }
    ],
)

Opret en MME

Med den foregående slutpunktskonfiguration opretter vi en SageMaker MME ved hjælp af oprette_slutpunkt API. SageMaker opretter MME, lancerer ML-beregningsinstansen g4dn.4xlarge og implementerer PyTorch- og TensorRT ResNet-50-modellerne på dem. Se følgende kode:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=, EndpointConfigName=
)

Kald målmodellen på MME'en

Efter at vi har oprettet slutpunktet, kan vi sende en slutningsanmodning til MME ved hjælp af invoke_enpoint API. Vi specificerer TargetModel i invokationskaldet og videregive nyttelasten for hver modeltype. Følgende kode er en prøveankaldelse for PyTorch-modellen og TensorRT-modellen:

runtime_sm_client.invoke_endpoint(
    EndpointName=,
    ContentType="application/octet-stream",
    Body=json.dumps(pt_payload),
    TargetModel='resnet_pt_v0.tar.gz', #PyTorch Model
)
runtime_sm_client.invoke_endpoint(
    EndpointName=, 
    ContentType="application/octet-stream", 
    Body=json.dumps(trt_payload),
    TargetModel='resnet_trt_v0.tar.gz' #TensorRT Model
)

Konfigurer politikker for automatisk skalering for GPU MME

SageMaker MME'er understøtter automatisk skalering for dine hostede modeller. Automatisk skalering justerer dynamisk antallet af forekomster, der er klargjort for en model som svar på ændringer i din arbejdsbyrde. Når arbejdsbyrden øges, bringer automatisk skalering flere forekomster online. Når arbejdsbyrden falder, fjerner automatisk skalering unødvendige forekomster, så du ikke betaler for klargjorte forekomster, som du ikke bruger.

I den følgende skaleringspolitik bruger vi den tilpassede metric GPUUtilization i TargetTrackingScalingPolicyConfiguration konfiguration og indstil en TargetValue of 60.0 for målværdien for denne metric. Denne autoskaleringspolitik sørger for yderligere tilfælde op til MaxCapacity når GPU-udnyttelsen er mere end 60 %.

auto_scaling_client = boto3.client('application-autoscaling')

resource_id='endpoint/' +  + '/variant/' + 'AllTraffic' 
response = auto_scaling_client.register_scalable_target(
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount',
    MinCapacity=1,
    MaxCapacity=5
)

response = auto_scaling_client.put_scaling_policy(
    PolicyName='GPUUtil-ScalingPolicy',
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 60.0, 
        'CustomizedMetricSpecification':
        {
            'MetricName': 'GPUUtilization',
            'Namespace': '/aws/sagemaker/Endpoints',
            'Dimensions': [
                {'Name': 'EndpointName', 'Value':  },
                {'Name': 'VariantName','Value': 'AllTraffic'}
            ],
            'Statistic': 'Average',
            'Unit': 'Percent'
        },
        'ScaleInCooldown': 600,
        'ScaleOutCooldown': 200 
    }
)

Vi anbefaler at bruge GPUUtilization or InvocationsPerInstance for at konfigurere politikker for automatisk skalering for din MME. For flere detaljer, se Indstil autoskaleringspolitikker for multi-model slutpunkt-implementeringer

CloudWatch-målinger for GPU MME'er

SageMaker MME'er leverer følgende metrics på instansniveau til at overvåge:

• LoadedModelCount – Antal modeller læsset i containerne
• GPUUtilisation – Procentdel af GPU-enheder, der bruges af containerne
• GPUMemoryUtilization – Procentdel af GPU-hukommelse, der bruges af containerne
• DiskUtilization – Procentdel af diskplads, der bruges af containerne

Disse målinger giver dig mulighed for at planlægge effektiv udnyttelse af GPU-instansressourcer. I den følgende graf ser vi GPUMemoryUtilization var 38.3 %, da mere end 16 ResNet-50-modeller blev læsset i containeren. Summen af ​​hver enkelt CPU-kernes udnyttelse (CPUUtilization) var 60.9 %, og procentdelen af ​​hukommelsen brugt af containerne (MemoryUtilization) var 9.36 %.

SageMaker MME'er leverer også modelindlæsningsmetrikker for at få indsigt på modelankaldelsesniveau:

• ModelLoadingWaitTime – Tidsinterval for, at modellen skal downloades eller indlæses
• ModelUdlæsningstid – Tidsinterval til at losse modellen fra containeren
• Modeldownloadtid – Tid til at downloade modellen fra Amazon S3
• ModelCacheHit – Antal opkald til modellen, der allerede er indlæst på containeren

I den følgende graf kan vi observere, at det tog 8.22 sekunder for en model at reagere på en slutningsanmodning (ModelLatency), og 24.1 millisekunder blev føjet til ende-til-ende latens på grund af SageMaker-omkostninger (OverheadLatency). Vi kan også se eventuelle fejlmålinger fra opkald til at påkalde et slutpunkt API-kald, som f.eks Invocation4XXErrors , Invocation5XXErrors.

For mere information om MME CloudWatch-målinger, se CloudWatch Metrics for Multi-Model Endpoint Deployment.

Resumé

I dette indlæg lærte du om den nye SageMaker multi-model support til GPU, som giver dig mulighed for omkostningseffektivt at hoste hundredvis af deep learning-modeller på accelereret computerhardware. Du lærte, hvordan du bruger NVIDIA Triton Inference Server, som opretter en modellagerkonfiguration for forskellige framework-backends, og hvordan du implementerer en MME med automatisk skalering. Denne funktion giver dig mulighed for at skalere hundredvis af hyper-personaliserede modeller, der er finjusteret til at tage højde for unikke slutbrugeroplevelser i AI-applikationer. Du kan også udnytte denne funktion til at opnå nødvendig prisydeevne for din slutningsapplikation ved hjælp af fraktioneret GPU'er.

For at komme i gang med MME-understøttelse til GPU, se Multi-model endpoint support til GPU.

Om forfatterne

Dhawal Patel er Principal Machine Learning Architect hos AWS. Han har arbejdet med organisationer lige fra store virksomheder til mellemstore startups om problemer relateret til distribueret databehandling og kunstig intelligens. Han fokuserer på dyb læring, herunder NLP og computer vision domæner. Han hjælper kunder med at opnå højtydende modelslutning på Amazon SageMaker.

Vikram Elango er Senior AI/ML Specialist Solutions Architect hos Amazon Web Services, baseret i Virginia, USA. Vikram hjælper globale finans- og forsikringsindustrikunder med design, implementering og tankelederskab med at bygge og implementere maskinlæringsapplikationer i stor skala. Han er i øjeblikket fokuseret på naturlig sprogbehandling, ansvarlig AI, inferensoptimering og skalering af ML på tværs af virksomheden. I sin fritid nyder han at rejse, vandre, lave mad og campere med sin familie.

Saurabh Trikande er Senior Product Manager for Amazon SageMaker Inference. Han brænder for at arbejde med kunder og er motiveret af målet om at demokratisere machine learning. Han fokuserer på kerneudfordringer relateret til implementering af komplekse ML-applikationer, multi-tenant ML-modeller, omkostningsoptimeringer og at gøre implementering af deep learning-modeller mere tilgængelig. I sin fritid nyder Saurabh at vandre, lære om innovative teknologier, følge TechCrunch og tilbringe tid med sin familie.

Deepti Ragha er softwareudviklingsingeniør i Amazon SageMaker-teamet. Hendes nuværende arbejde fokuserer på at bygge funktioner til effektivt at være vært for maskinlæringsmodeller. I sin fritid nyder hun at rejse, vandre og dyrke planter.

Nikhil Kulkarni er en softwareudvikler med AWS Machine Learning, der fokuserer på at gøre maskinlæringsarbejdsbelastninger mere effektive i skyen og er medskaber af AWS Deep Learning Containers til træning og inferens. Han brænder for distribuerede Deep Learning-systemer. Uden for arbejdet nyder han at læse bøger, pille ved guitaren og lave pizza.

Jiahong Liu er løsningsarkitekt på Cloud Service Provider-teamet hos NVIDIA. Han hjælper kunder med at anvende machine learning og AI-løsninger, der udnytter NVIDIA accelereret computing til at løse deres trænings- og inferensudfordringer. I sin fritid nyder han origami, gør-det-selv-projekter og at spille basketball.

Eliuth Triana er en Developer Relations Manager på NVIDIA-AWS-teamet. Han forbinder Amazon- og AWS-produktledere, udviklere og videnskabsmænd med NVIDIA-teknologer og produktledere for at accelerere Amazon ML/DL-arbejdsbelastninger, EC2-produkter og AWS AI-tjenester. Derudover er Eliuth en passioneret mountainbiker, skiløber og pokerspiller.

Maximiliano Maccanti er Principal Engineer hos AWS i øjeblikket hos DynamoDB, jeg var i lanceringsteamet for SageMaker ved re:Invent 2017 og tilbragte de følgende 5 år i hostingplatformen med at tilføje alle slags kunder, der står over for funktioner. I min fritid samler jeg, reparerer og leger med vintage videospilskonsoller.