Kör flera djupinlärningsmodeller på GPU med Amazon SageMaker multi-model endpoints

När AI-anpassningen accelererar i branschen bygger kunderna sofistikerade modeller som drar fördel av nya vetenskapliga genombrott inom djupinlärning. Dessa nästa generations modeller låter dig uppnå toppmoderna, mänskliga prestanda inom områdena naturlig språkbehandling (NLP), datorseende, taligenkänning, medicinsk forskning, cybersäkerhet, förutsägelse av proteinstruktur och många andra . Till exempel kan stora språkmodeller som GPT-3, OPT och BLOOM översätta, sammanfatta och skriva text med mänskliga nyanser. I datorvisionsutrymmet kan text-till-bild-diffusionsmodeller som DALL-E och Imagen skapa fotorealistiska bilder från naturligt språk med en högre nivå av visuell och språkförståelse från omvärlden. Dessa multimodala modeller ger rikare funktioner för olika nedströmsuppgifter och möjligheten att finjustera dem för specifika domäner, och de ger kraftfulla affärsmöjligheter till våra kunder.

Dessa djupinlärningsmodeller fortsätter att växa i storlek och innehåller vanligtvis miljarder modellparametrar för att skala modellprestanda för en mängd olika uppgifter, som bildgenerering, textsammanfattning, språköversättning och mer. Det finns också ett behov av att anpassa dessa modeller för att leverera en hyperpersonlig upplevelse till individer. Som ett resultat utvecklas ett större antal modeller genom att finjustera dessa modeller för olika nedströmsuppgifter. För att möta latens- och genomströmningsmålen för AI-applikationer föredras GPU-instanser framför CPU-instanser (med tanke på beräkningskraftens GPU:er erbjuder). GPU-instanser är dock dyra och kostnaderna kan öka om du distribuerar fler än 10 modeller. Även om dessa modeller potentiellt kan ge effektfulla AI-tillämpningar, kan det vara utmanande att skala dessa djupinlärningsmodeller på kostnadseffektiva sätt på grund av deras storlek och antal modeller.

Amazon SageMaker multi-model endpoints (MME) ger ett skalbart och kostnadseffektivt sätt att implementera ett stort antal modeller för djupinlärning. MME är ett populärt värdval för att vara värd för hundratals CPU-baserade modeller bland kunder som Zendesk, Veeva och AT&T. Tidigare hade du begränsade möjligheter att distribuera hundratals modeller för djupinlärning som behövde accelererad beräkning med GPU:er. Idag tillkännager vi MME-stöd för GPU. Nu kan du distribuera tusentals modeller för djupinlärning bakom en enda SageMaker-slutpunkt. MME:er kan nu köra flera modeller på en GPU-kärna, dela GPU-instanser bakom en slutpunkt över flera modeller och dynamiskt ladda och ladda ner modeller baserat på den inkommande trafiken. Med detta kan du avsevärt spara kostnader och uppnå bästa prisprestanda.

I det här inlägget visar vi hur man kör flera modeller för djupinlärning på GPU med SageMaker MME.

SageMaker MME

SageMaker MME:er gör att du kan distribuera flera modeller bakom en enda slutpunkt som kan innehålla en eller flera instanser. Med MME:er hanteras varje instans för att ladda och betjäna flera modeller. MME:er gör att du kan bryta de linjärt ökande kostnaderna för att vara värd för flera modeller och återanvända infrastruktur för alla modeller.

Följande diagram illustrerar arkitekturen för en SageMaker MME.

SageMaker MME laddar dynamiskt ner modeller från Amazon enkel lagringstjänst (Amazon S3) när den anropas, istället för att ladda ner alla modeller när slutpunkten först skapas. Som ett resultat kan ett initialt anrop till en modell se högre slutledningslatens än de efterföljande slutsatserna, som avslutas med låg latens. Om modellen redan är laddad på behållaren när den anropas, hoppas nedladdnings- och laddningssteget över och modellen returnerar slutledningarna med låg latens. Anta till exempel att du har en modell som bara används ett fåtal gånger om dagen. Den laddas automatiskt på begäran, medan ofta åtkomliga modeller behålls i minnet och anropas med konsekvent låg latens.

SageMaker MME med GPU-stöd

SageMaker MME med GPU fungerar med NVIDIA Triton Inference Server. NVIDIA Triton Inference Server är en öppen källkod för slutledningsservering som förenklar inferensserveringsprocessen och ger hög slutledningsprestanda. Triton stöder alla större utbildnings- och slutledningsramverk, såsom TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, custom C++ och mer. Den erbjuder dynamisk batchning, samtidiga körningar, kvantisering efter träning och optimal modellkonfiguration för att uppnå högpresterande slutledning. Dessutom har NVIDIA Triton Inference Server utökats för att implementeras MME API-kontrakt, för att integrera med MME.

Följande diagram illustrerar ett MME-arbetsflöde.

Arbetsflödesstegen är följande:

1. SageMaker MME tar emot en HTTP-anropsbegäran för en viss modell som använder TargetModel i begäran tillsammans med nyttolasten.
2. SageMaker dirigerar trafik till rätt instans bakom slutpunkten där målmodellen laddas. SageMaker förstår trafikmönstret över alla modeller bakom MME och dirigerar förfrågningar smart.
3. SageMaker tar hand om modellhanteringen bakom slutpunkten, laddar modellen dynamiskt till containerns minne och laddar ur modellen baserad från den delade flottan av GPU-instanser för att ge bästa prisprestanda.
4. SageMaker laddar dynamiskt ner modeller från Amazon S3 till instansens lagringsvolym. Om den anropade modellen inte är tillgänglig på instanslagringsvolymen, laddas modellen ned till instanslagringsvolymen. Om instanslagringsvolymen når kapacitet tar SageMaker bort alla oanvända modeller från lagringsvolymen.
5. SageMaker laddar modellen till NVIDIA Triton-behållarens minne på en GPU-accelererad instans och betjänar slutledningsbegäran. GPU-kärnan delas av alla modeller i en instans. Om modellen redan är laddad i containerminnet, serveras de efterföljande förfrågningarna snabbare eftersom SageMaker inte behöver ladda ner och ladda den igen.
6. SageMaker tar hand om trafikformningen till MME-slutpunkten och upprätthåller optimala modellkopior på GPU-instanser för bästa prisprestanda. Den fortsätter att dirigera trafik till den instans där modellen laddas. Om instansresurserna når kapacitet på grund av högt utnyttjande, lossar SageMaker de minst använda modellerna från behållaren för att frigöra resurser för att ladda mer frekvent använda modeller.

SageMaker MME:er kan skala horisontellt med hjälp av en automatisk skalningspolicy och tillhandahålla ytterligare GPU-beräkningsinstanser baserat på mätvärden som anrop per instans och GPU-användning för att betjäna eventuella trafikökningar till MME-slutpunkter.

Lösningsöversikt

I det här inlägget visar vi dig hur du använder de nya funktionerna i SageMaker MMEs med GPU med ett datorseende användningsfall. För demonstrationsändamål använder vi en ResNet-50-konvolutionellt neuralt nätverk förtränad modell som kan klassificera bilder i 1,000 XNUMX kategorier. Vi diskuterar hur man gör följande:

• Använd en NVIDIA Triton-inferensbehållare på SageMaker MME:er, med hjälp av olika Triton-modeller som backends såsom PyTorch och TensorRT
• Konvertera ResNet-50-modeller till optimerat TensorRT-motorformat och distribuera det med en SageMaker MME
• Ställ in policyer för automatisk skalning för MME
• Få insikter i instans- och anropsstatistik med hjälp av amazoncloudwatch

Skapa modellartefakter

Det här avsnittet går igenom stegen för att förbereda en ResNet-50 förutbildad modell för att distribueras på en SageMaker MME med hjälp av Triton Inference Server-modellkonfigurationer. Du kan återskapa alla steg med hjälp av steg-för-steg-anteckningsboken på GitHub.

För det här inlägget visar vi implementering med två modeller. Du kan dock förbereda och distribuera hundratals modeller. Modellerna kanske delar samma ramverk eller inte.

Förbered en PyTorch-modell

Först laddar vi en förtränad ResNet50-modell med hjälp av torchvision-modellpaketet. Vi sparar modellen som en model.pt-fil i TorchScript-optimerat och serialiserat format. TorchScript sammanställer en framåtpassning av ResNet50-modellen i ivrigt läge med exempelingångar, så vi skickar en instans av en RGB-bild med tre färgkanaler med dimensionen 224 x 224.

Sedan måste vi förbereda modellerna för Triton Inference Server. Följande kod visar modellförrådet för PyTorch-ramverkets backend. Triton använder filen model.pt placerad i modellförrådet för att tjäna förutsägelser.

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

Modellens konfigurationsfil config.pbtxt måste ange namnet på modellen (resnet), plattformen och backend-egenskaperna (pytorch_libtorch), max_batch_size (128), och ingångs- och utgångstensorerna tillsammans med datatypen (TYPE_FP32) information. Dessutom kan du ange instance_group och dynamic_batching egenskaper för att uppnå högpresterande slutledning. Se följande kod:

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
}

Förbered TensorRT-modellen

NVIDIA TensorRT är en SDK för högpresterande djupinlärningsinferens, och inkluderar en djupinlärningsinferensoptimerare och körtid som ger låg latens och hög genomströmning för inferensapplikationer. Vi använder kommandoradsverktyget trtexec för att generera en TensorRT serialiserad motor från en ONNX modellformat. Slutför följande steg för att konvertera en ResNet-50 förtränad modell till NVIDIA TensorRT:

1. Exportera den förtränade ResNet-50-modellen till ett ONNX-format med hjälp av torch.onnx.Det här steget kör modellen en gång för att spåra dess körning med en provinmatning och exporterar sedan den spårade modellen till den angivna filen model.onnx.
2. Använd trtexec för att skapa en TensorRT-motorplan från model.onnx fil. Du kan valfritt minska precisionen för flyttalsberäkningar, antingen genom att helt enkelt köra dem i 16-bitars flyttal, eller genom att kvantisera flyttalsvärden så att beräkningar kan utföras med 8-bitars heltal.

Följande kod visar modellförvarets struktur för TensorRT-modellen:

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

För TensorRT-modellen specificerar vi tensorrt_plan som plattform och mata in Tensor-specifikationerna för bilden med dimensionen 224 x 224, som har färgkanalerna. Utgången Tensor med 1,000 XNUMX dimensioner är av typ TYPE_FP32, motsvarande de olika objektkategorierna. Se följande kod:

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
        }
    }
}

Lagra modellartefakter i Amazon S3

SageMaker förväntar sig att modellens artefakter kommer in .tar.gz formatera. De bör också uppfylla kraven för Triton-behållare som modellnamn, version, config.pbtxt filer och mer. tar mappen som innehåller modellfilen som .tar.gz och ladda upp den till 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 när vi har laddat upp modellartefakterna till Amazon S3 kan vi skapa en SageMaker MME.

Distribuera modeller med en MME

Vi distribuerar nu en ResNet-50-modell med två olika ramverksbackends (PyTorch och TensorRT) till en SageMaker MME.

Observera att du kan distribuera hundratals modeller, och modellerna kan använda samma ramverk. De kan också använda olika ramverk, som visas i det här inlägget.

Vi använder AWS SDK för Python (Boto3) API: er skapa_modell, create_endpoint_configoch create_endpoint för att skapa en MME.

Definiera serveringsbehållaren

I behållardefinitionen definierar du model_data_url för att ange S3-katalogen som innehåller alla modeller som SageMaker MME använder för att ladda och visa förutsägelser. Uppsättning Mode till MultiModel för att indikera att SageMaker skapar slutpunkten med MME-behållarespecifikationer. Vi ställer in behållaren med en bild som stöder distribution av MME med GPU. Se följande kod:

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

Skapa ett objekt med flera modeller

Använd SageMaker Boto3-klienten för att skapa modellen med hjälp av create_model API. Vi skickar behållardefinitionen till skapa modell API tillsammans med ModelName och ExecutionRoleArn:

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

Definiera MME-konfigurationer

Skapa MME-konfigurationer med hjälp av create_endpoint_config Boto3 API. Ange en accelererad GPU-beräkningsinstans i InstanceType (vi använder instanstypen g4dn.4xlarge). Vi rekommenderar att du konfigurerar dina slutpunkter med minst två instanser. Detta gör att SageMaker kan tillhandahålla en högst tillgänglig uppsättning förutsägelser över flera tillgänglighetszoner för modellerna.

Baserat på våra resultat kan du få bättre prisprestanda på ML-optimerade instanser med en enda GPU-kärna. Därför är MME-stöd för GPU-funktionen endast aktiverat för en-GPU-kärninstanser. För en fullständig lista över instanser som stöds, se GPU-instanstyper som stöds.

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

Skapa en MME

Med den föregående slutpunktskonfigurationen skapar vi en SageMaker MME med hjälp av create_endpoint API. SageMaker skapar MME, lanserar ML-beräkningsinstansen g4dn.4xlarge och distribuerar PyTorch- och TensorRT ResNet-50-modellerna på dem. Se följande kod:

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

Åberopa målmodellen på MME

När vi har skapat slutpunkten kan vi skicka en inferensförfrågan till MME:n med hjälp av invoke_enpoint API. Vi specificerar TargetModel i anropsanropet och skicka in nyttolasten för varje modelltyp. Följande kod är en exempelanrop för PyTorch-modellen och 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
)

Ställ in policyer för automatisk skalning för GPU MME

SageMaker MME:er stöder automatisk skalning för dina värdmodeller. Automatisk skalning justerar dynamiskt antalet instanser som tillhandahålls för en modell som svar på ändringar i din arbetsbelastning. När arbetsbelastningen ökar gör automatisk skalning fler instanser online. När arbetsbelastningen minskar tar automatisk skalning bort onödiga instanser så att du inte betalar för provisionerade instanser som du inte använder.

I följande skalningspolicy använder vi det anpassade måttet GPUUtilization i TargetTrackingScalingPolicyConfiguration konfigurera och ställ in en TargetValue of 60.0 för målvärdet för det måttet. Denna autoskalningspolicy tillhandahåller ytterligare instanser upp till MaxCapacity när GPU-användningen är mer än 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 rekommenderar att du använder GPUUtilization or InvocationsPerInstance för att konfigurera policyer för automatisk skalning för din MME. För mer information, se Ställ in principer för automatisk skalning för slutpunktsdistributioner med flera modeller

CloudWatch-statistik för GPU MME

SageMaker MME:er tillhandahåller följande mätvärden på instansnivå att övervaka:

• LoadedModelCount – Antal modeller lastade i containrarna
• GPUUtilization – Andel av GPU-enheter som används av behållarna
• GPUMemoryUtilization – Andel av GPU-minnet som används av behållarna
• DiskUtilization – Andel diskutrymme som används av behållarna

Dessa mätvärden låter dig planera för ett effektivt utnyttjande av GPU-instansresurser. I följande graf ser vi GPUMemoryUtilization var 38.3 % när mer än 16 ResNet-50-modeller lastades i containern. Summan av varje enskild CPU-kärnas användning (CPUUtilization) var 60.9 %, och andelen minne som användes av behållarna (MemoryUtilization) var 9.36 %.

SageMaker MME:er tillhandahåller också modellladdningsstatistik för att få insikter på modellanropsnivå:

• ModelLoadingWaitTime – Tidsintervall för att modellen ska laddas ner eller laddas
• ModelUnloadingTime – Tidsintervall för att lossa modellen från containern
• Modellnedladdningstid – Dags att ladda ner modellen från Amazon S3
• ModelCacheHit – Antal anrop till modellen som redan är laddade på behållaren

I följande graf kan vi observera att det tog 8.22 sekunder för en modell att svara på en slutsatsförfrågan (ModelLatency), och 24.1 millisekunder lades till från slut till ände fördröjning på grund av SageMaker omkostnader (OverheadLatency). Vi kan också se eventuella felmätningar från anrop för att anropa ett slutpunkts API-anrop, som t.ex Invocation4XXErrors och Invocation5XXErrors.

För mer information om MME CloudWatch-mätvärden, se CloudWatch Metrics for Multi-Model Endpoint Deployment.

Sammanfattning

I det här inlägget lärde du dig om det nya SageMaker-stödet för flera modeller för GPU, som gör att du kostnadseffektivt kan vara värd för hundratals djupinlärningsmodeller på accelererad datorhårdvara. Du lärde dig hur du använder NVIDIA Triton Inference Server, som skapar en modellförrådskonfiguration för olika ramverksbackends, och hur du distribuerar en MME med automatisk skalning. Den här funktionen låter dig skala hundratals hyperpersonifierade modeller som är finjusterade för att tillgodose unika slutanvändarupplevelser i AI-applikationer. Du kan också utnyttja den här funktionen för att uppnå nödvändig prisprestanda för din slutledningsapplikation med hjälp av fraktionerade GPU:er.

För att komma igång med MME-stöd för GPU, se Stöd för flera modeller för GPU.

Om författarna

Dhawal Patel är en huvudarkitekt för maskininlärning på AWS. Han har arbetat med organisationer som sträcker sig från stora företag till medelstora startups med problem relaterade till distribuerad datoranvändning och artificiell intelligens. Han fokuserar på djupinlärning, inklusive NLP och datorseende domäner. Han hjälper kunder att uppnå högpresterande modellslutledning på Amazon SageMaker.

Vikram Elango är Senior AI/ML Specialist Solutions Architect på Amazon Web Services, baserad i Virginia, USA. Vikram hjälper globala finans- och försäkringskunder med design, implementering och tankeledarskap att bygga och distribuera maskininlärningsapplikationer i stor skala. Han är för närvarande fokuserad på naturlig språkbehandling, ansvarsfull AI, slutledningsoptimering och skalning av ML över hela företaget. På fritiden tycker han om att resa, vandra, laga mat och campa med sin familj.

Saurabh Trikande är senior produktchef för Amazon SageMaker Inference. Han brinner för att arbeta med kunder och motiveras av målet att demokratisera maskininlärning. Han fokuserar på kärnutmaningar relaterade till att distribuera komplexa ML-applikationer, multi-tenant ML-modeller, kostnadsoptimeringar och att göra implementeringen av djupinlärningsmodeller mer tillgänglig. På sin fritid gillar Saurabh att vandra, lära sig om innovativ teknik, följa TechCrunch och umgås med sin familj.

Deepti Ragha är en mjukvaruutvecklingsingenjör i Amazon SageMaker-teamet. Hennes nuvarande arbete fokuserar på att bygga funktioner för att effektivt vara värd för maskininlärningsmodeller. På fritiden tycker hon om att resa, vandra och odla växter.

Nikhil Kulkarni är en mjukvaruutvecklare med AWS Machine Learning, med fokus på att göra maskininlärningsarbetsbelastningar mer effektiva i molnet och är en medskapare av AWS Deep Learning Containers för utbildning och slutledning. Han brinner för distribuerade Deep Learning Systems. Utanför jobbet tycker han om att läsa böcker, pilla med gitarren och göra pizza.

Jiahong Liu är en lösningsarkitekt på Cloud Service Provider-teamet på NVIDIA. Han hjälper kunder att ta till sig maskininlärning och AI-lösningar som utnyttjar NVIDIAs accelererade datoranvändning för att hantera deras utbildnings- och slutledningsutmaningar. På sin fritid tycker han om origami, gör-det-själv-projekt och att spela basket.

Eliuth Triana är en Developer Relations Manager i NVIDIA-AWS-teamet. Han kopplar samman Amazon- och AWS-produktledare, utvecklare och forskare med NVIDIA-teknologer och produktledare för att påskynda Amazon ML/DL-arbetsbelastningar, EC2-produkter och AWS AI-tjänster. Dessutom är Eliuth en passionerad mountainbikeåkare, skidåkare och pokerspelare.

Maximiliano Maccanti är huvudingenjör på AWS för närvarande med DynamoDB, jag var med i lanseringsteamet för SageMaker på re:Invent 2017 och tillbringade de följande 5 åren i värdplattformen med att lägga till alla typer av kunder som möter funktioner. På min fritid samlar jag, reparerar och spelar med vintage videospelskonsoler.