Zaženite več modelov globokega učenja na GPE s končnimi točkami več modelov Amazon SageMaker

Ker sprejemanje umetne inteligence v industriji pospešuje, stranke gradijo sofisticirane modele, ki izkoriščajo nove znanstvene dosežke v globokem učenju. Ti modeli naslednje generacije vam omogočajo, da dosežete najsodobnejšo zmogljivost, podobno človeku, na področjih obdelave naravnega jezika (NLP), računalniškega vida, prepoznavanja govora, medicinskih raziskav, kibernetske varnosti, predvidevanja strukture beljakovin in številnih drugih. . Na primer, veliki jezikovni modeli, kot so GPT-3, OPT in BLOOM, lahko prevajajo, povzemajo in pišejo besedilo s človeškimi odtenki. V prostoru računalniškega vida lahko modeli difuzije besedila v sliko, kot sta DALL-E in Imagen, ustvarijo fotorealistične slike iz naravnega jezika z višjo stopnjo vizualnega in jezikovnega razumevanja iz sveta okoli nas. Ti večmodalni modeli zagotavljajo bogatejše funkcije za različne naloge na nižji stopnji in možnost njihovega natančnega prilagajanja za specifične domene, našim strankam pa prinašajo močne poslovne priložnosti.

Ti modeli globokega učenja nenehno rastejo v smislu velikosti in običajno vsebujejo milijarde modelnih parametrov za prilagajanje zmogljivosti modela za najrazličnejše naloge, kot so ustvarjanje slik, povzemanje besedila, prevajanje jezikov in več. Te modele je treba prilagoditi tudi tako, da posameznikom zagotovijo hiperpersonalizirano izkušnjo. Posledično se razvija večje število modelov s finim prilagajanjem teh modelov za različne naloge na nižji stopnji. Da bi dosegli cilje glede zakasnitve in prepustnosti aplikacij AI, imajo primerki GPE prednost pred primerki CPE (glede na računalniško moč, ki jo ponujajo GPE). Vendar so primerki GPE dragi in stroški se lahko povečajo, če uvajate več kot 10 modelov. Čeprav lahko ti modeli potencialno prinesejo vplivne aplikacije umetne inteligence, je morda izziv povečati te modele globokega učenja na stroškovno učinkovite načine zaradi njihove velikosti in števila modelov.

Amazon SageMaker večmodelne končne točke (MME) zagotavljajo razširljiv in stroškovno učinkovit način za uvajanje velikega števila modelov globokega učenja. MME so priljubljena izbira gostovanja za gostovanje na stotine modelov, ki temeljijo na CPE, med strankami, kot so Zendesk, Veeva in AT&T. Prej ste imeli omejene možnosti za uvajanje na stotine modelov globokega učenja, ki so potrebovali pospešeno računanje z grafičnimi procesorji. Danes napovedujemo podporo MME za GPU. Zdaj lahko uvedete na tisoče modelov globokega učenja za eno končno točko SageMaker. MME-ji lahko zdaj poganjajo več modelov v jedru GPU, delijo primerke GPU za končno točko v več modelih ter dinamično nalagajo in razkladajo modele glede na dohodni promet. S tem lahko občutno prihranite stroške in dosežete najboljšo cenovno učinkovitost.

V tej objavi prikazujemo, kako zagnati več modelov globokega učenja na GPU z MME-ji SageMaker.

SageMaker MME

SageMaker MME vam omogočajo uvedbo več modelov za eno končno točko sklepanja, ki lahko vsebuje enega ali več primerkov. Z MME je vsaka instanca upravljana za nalaganje in streženje več modelov. MME vam omogočajo, da prekinete linearno naraščajoče stroške gostovanja več modelov in ponovno uporabite infrastrukturo v vseh modelih.

Naslednji diagram ponazarja arhitekturo SageMaker MME.

SageMaker MME dinamično prenaša modele iz Preprosta storitev shranjevanja Amazon (Amazon S3), ko je priklican, namesto da prenese vse modele, ko je končna točka prvič ustvarjena. Posledično se lahko pri začetnem priklicu modela pojavi višja zakasnitev sklepanja kot pri poznejših sklepih, ki so dokončani z nizko zakasnitvijo. Če je model ob priklicu že naložen v vsebnik, se korak prenosa in nalaganja preskoči in model vrne sklepe z nizko zakasnitvijo. Recimo, da imate model, ki ga uporabljate le nekajkrat na dan. Samodejno se naloži na zahtevo, medtem ko se pogosto dostopni modeli ohranijo v pomnilniku in prikličejo z dosledno nizko zakasnitvijo.

SageMaker MME s podporo za GPU

SageMaker MME z GPE delujejo z uporabo NVIDIA Triton Inference Server. NVIDIA Triton Inference Server je odprtokodna programska oprema za streženje sklepanja, ki poenostavi postopek streženja sklepanja in zagotavlja visoko zmogljivost sklepanja. Triton podpira vsa glavna ogrodja za usposabljanje in sklepanje, kot so TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, C++ po meri in drugo. Ponuja dinamično šaržiranje, sočasne teke, kvantizacijo po usposabljanju in optimalno konfiguracijo modela za doseganje visoko zmogljivega sklepanja. Poleg tega je bil NVIDIA Triton Inference Server razširjen za implementacijo pogodba MME API, za integracijo z MME.

Naslednji diagram prikazuje potek dela MME.

Koraki poteka dela so naslednji:

1. SageMaker MME prejme zahtevo za priklic HTTP za določen model, ki uporablja TargetModel v zahtevi skupaj s tovorom.
2. SageMaker usmerja promet na pravo instanco za končno točko, kjer je naložen ciljni model. SageMaker razume vzorec prometa v vseh modelih za MME in pametno usmerja zahteve.
3. SageMaker skrbi za upravljanje modela za končno točko, dinamično naloži model v pomnilnik vsebnika in razloži model, ki temelji na skupni floti instanc GPU, da zagotovi najboljšo cenovno zmogljivost.
4. SageMaker dinamično prenese modele iz Amazon S3 v prostor za shranjevanje instance. Če priklicani model ni na voljo na nosilcu pomnilnika primerka, se model prenese na nosilec pomnilnika primerka. Če prostor za shranjevanje instance doseže kapaciteto, SageMaker izbriše vse neuporabljene modele iz nosilca za shranjevanje.
5. SageMaker naloži model v pomnilnik vsebnika NVIDIA Triton na GPU pospešeni instanci in postreže zahtevo za sklepanje. Jedro GPU si delijo vsi modeli v primerku. Če je model že naložen v pomnilnik vsebnika, se nadaljnje zahteve postrežejo hitreje, ker ga SageMakerju ni treba znova prenesti in naložiti.
6. SageMaker skrbi za oblikovanje prometa do končne točke MME in vzdržuje optimalne kopije modela na instancah GPE za najboljšo cenovno zmogljivost. Še naprej usmerja promet do primerka, kjer je naložen model. Če viri instance dosežejo zmogljivost zaradi visoke izkoriščenosti, SageMaker razloži najmanj uporabljene modele iz vsebnika, da sprosti vire za nalaganje pogosteje uporabljenih modelov.

MME-ji SageMaker lahko vodoravno prilagajajo z uporabo pravilnika samodejnega prilagajanja in zagotavljajo dodatne instance računanja GPU na podlagi meritev, kot so klici na primerek in uporaba GPU, da služijo kakršnim koli porastom prometa do končnih točk MME.

Pregled rešitev

V tej objavi vam pokažemo, kako uporabljati nove funkcije SageMaker MMEs z GPE s primerom uporabe računalniškega vida. Za namene predstavitve uporabljamo vnaprej usposobljen model konvolucijske nevronske mreže ResNet-50, ki lahko razvrsti slike v 1,000 kategorij. Razpravljamo o tem, kako narediti naslednje:

• Uporabite inferenčni vsebnik NVIDIA Triton na MME-jih SageMaker z uporabo različnih ozadij ogrodja modela Triton, kot sta PyTorch in TensorRT
• Pretvorite modele ResNet-50 v optimiziran format mehanizma TensorRT in ga namestite s SageMaker MME
• Nastavite pravilnike o samodejnem skaliranju za MME
• Pridobite vpogled v meritve primerov in klicev z uporabo amazoncloudwatch

Ustvarite model artefaktov

V tem razdelku so opisani koraki za pripravo predhodno usposobljenega modela ResNet-50 za uvedbo na SageMaker MME z uporabo konfiguracij modela Triton Inference Server. Vse korake lahko ponovite z uporabo zvezka po korakih na GitHub.

Za to objavo prikazujemo uvajanje z dvema modeloma. Vendar pa lahko pripravite in uvedete na stotine modelov. Modeli lahko delijo isti okvir ali pa tudi ne.

Pripravite model PyTorch

Najprej naložimo predhodno usposobljen model ResNet50 s paketom torchvision models. Model shranimo kot datoteko model.pt v optimiziranem in serializiranem formatu TorchScript. TorchScript sestavi napredni prehod modela ResNet50 v načinu navdušenja z vzorčnimi vnosi, tako da posredujemo en primerek slike RGB s tremi barvnimi kanali dimenzij 224 x 224.

Nato moramo pripraviti modele za Triton Inference Server. Naslednja koda prikazuje repozitorij modela za zaledje ogrodja PyTorch. Triton za serviranje napovedi uporablja datoteko model.pt, ki je nameščena v repozitoriju modela.

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

Konfiguracijska datoteka modela config.pbtxt mora navesti ime modela (resnet), lastnosti platforme in zaledja (pytorch_libtorch), max_batch_size (128), ter vhodne in izhodne tenzorje skupaj s podatkovnim tipom (TYPE_FP32) informacije. Poleg tega lahko določite instance_group in dynamic_batching lastnosti za doseganje visoke učinkovitosti sklepanja. Oglejte si naslednjo kodo:

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
}

Pripravite model TensorRT

NVIDIA TensorRT je SDK za visoko zmogljivo sklepanje o globokem učenju in vključuje optimizator sklepanja o globokem učenju ter čas izvajanja, ki zagotavlja nizko zakasnitev in visoko prepustnost za aplikacije sklepanja. Uporabljamo orodje ukazne vrstice trtexec za ustvarjanje serializiranega motorja TensorRT iz ONNX format modela. Izvedite naslednje korake za pretvorbo predhodno usposobljenega modela ResNet-50 v NVIDIA TensorRT:

1. Izvozite vnaprej pripravljen model ResNet-50 v format ONNX z uporabo bakla.onnx.Ta korak enkrat zažene model, da izsledi njegovo izvajanje z vzorčnim vnosom, nato pa izvozi sledeni model v podano datoteko model.onnx.
2. Uporabite trtexec za ustvarjanje načrta motorja TensorRT iz model.onnx mapa. Po želji lahko zmanjšate natančnost izračunov s plavajočo vejico, tako da jih preprosto izvajate v 16-bitni plavajoči vejici ali s kvantizacijo vrednosti s plavajočo vejico, tako da se lahko izračuni izvajajo z uporabo 8-bitnih celih števil.

Naslednja koda prikazuje strukturo repozitorija modela za model TensorRT:

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

Za model TensorRT določimo tensorrt_plan kot platformo in vnesite Tensor specifikacije slike dimenzije 224 x 224, ki ima barvne kanale. Izhodni tenzor s 1,000 dimenzijami je vrste TYPE_FP32, ki ustreza različnim kategorijam predmetov. Oglejte si naslednjo kodo:

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

Shranite artefakte modela v Amazon S3

SageMaker pričakuje artefakte modela .tar.gz format. Prav tako morajo izpolnjevati zahteve posode Triton, kot so ime modela, različica, config.pbtxt datoteke in več. tar mapo, ki vsebuje datoteko modela kot .tar.gz in ga naložite v 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")

Zdaj, ko smo artefakte modela naložili v Amazon S3, lahko ustvarimo SageMaker MME.

Razmestite modele z MME

Zdaj uvajamo model ResNet-50 z dvema različnima zalednima okviroma (PyTorch in TensorRT) v SageMaker MME.

Upoštevajte, da lahko namestite na stotine modelov in modeli lahko uporabljajo isto ogrodje. Uporabljajo lahko tudi različna ogrodja, kot je prikazano v tej objavi.

Mi uporabljamo AWS SDK za Python (Boto3) API-ji create_model, create_endpoint_configin create_endpoint ustvariti MME.

Določite posodo za serviranje

V definiciji vsebnika definirajte model_data_url da določite imenik S3, ki vsebuje vse modele, ki jih SageMaker MME uporablja za nalaganje in serviranje napovedi. Set Mode do MultiModel da pokaže, da SageMaker ustvari končno točko s specifikacijami vsebnika MME. Vsebnik smo nastavili s sliko, ki podpira uvajanje MME z GPE. Oglejte si naslednjo kodo:

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

Ustvarite objekt z več modeli

Uporabite odjemalca SageMaker Boto3, da ustvarite model z uporabo create_model API. Definicijo vsebnika posredujemo API-ju za ustvarjanje modela skupaj z ModelName in ExecutionRoleArn:

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

Določite konfiguracije MME

Ustvarite konfiguracije MME z uporabo create_endpoint_config Boto3 API. Določite pospešeno računalniško instanco GPU v InstanceType (uporabljamo vrsto primerka g4dn.4xlarge). Priporočamo, da svoje končne točke konfigurirate z vsaj dvema primerkoma. To SageMakerju omogoča, da zagotovi zelo razpoložljiv nabor napovedi v več območjih razpoložljivosti za modele.

Na podlagi naših ugotovitev lahko dobite boljšo cenovno zmogljivost na primerkih, optimiziranih za ML, z enim jedrom GPE. Zato je podpora MME za funkcijo GPE omogočena samo za primerke z enim jedrom GPE. Za celoten seznam podprtih primerkov glejte Podprte vrste primerkov GPE.

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

Ustvarite MME

S prejšnjo konfiguracijo končne točke ustvarimo SageMaker MME z uporabo create_endpoint API. SageMaker ustvari MME, zažene računalniški primerek ML g4dn.4xlarge in na njih razmesti modela PyTorch in TensorRT ResNet-50. Oglejte si naslednjo kodo:

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

Prikličite ciljni model na MME

Ko ustvarimo končno točko, lahko MME pošljemo zahtevo za sklepanje z uporabo invoke_enpoint API. Določimo TargetModel v klicnem klicu in posredujte koristni tovor za vsako vrsto modela. Naslednja koda je vzorčni priklic za modela PyTorch in TensorRT:

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
)

Nastavite pravilnike o samodejnem skaliranju za GPU MME

SageMaker MME podpirajo samodejno skaliranje za vaše gostujoče modele. Samodejno skaliranje dinamično prilagodi število primerkov, ki so omogočeni za model, kot odgovor na spremembe vaše delovne obremenitve. Ko se delovna obremenitev poveča, samodejno skaliranje pripelje več primerkov v splet. Ko se delovna obremenitev zmanjša, samodejno skaliranje odstrani nepotrebne primerke, tako da ne plačujete za predvidene primerke, ki jih ne uporabljate.

V naslednjem pravilniku o skaliranju uporabljamo meritev po meri GPUUtilization v TargetTrackingScalingPolicyConfiguration konfiguracijo in nastavite a TargetValue of 60.0 za ciljno vrednost te metrike. Ta pravilnik o samodejnem skaliranju zagotavlja dodatne primerke do MaxCapacity ko je izkoriščenost GPU več kot 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 
    }
)

Priporočamo uporabo GPUUtilization or InvocationsPerInstance za konfiguracijo pravilnikov samodejnega skaliranja za vaš MME. Za več podrobnosti glejte Nastavite pravilnike o samodejnem skaliranju za razmestitve končnih točk z več modeli

Meritve CloudWatch za GPU MME

SageMaker MME zagotavljajo naslednje meritve na ravni instance za spremljanje:

• LoadedModelCount – Število modelov, naloženih v zabojnike
• Uporaba GPU – Odstotek enot GPE, ki jih uporabljajo vsebniki
• GPUMemoryUtilization – Odstotek pomnilnika GPE, ki ga uporabljajo vsebniki
• DiskUtilization – Odstotek prostora na disku, ki ga uporabljajo vsebniki

Te metrike vam omogočajo načrtovanje učinkovite uporabe virov instance GPE. V naslednjem grafu vidimo GPUMemoryUtilization je bil 38.3 %, ko je bilo v zabojnik naloženih več kot 16 modelov ResNet-50. Vsota izkoriščenosti vsakega posameznega jedra CPU (CPUUtilization) je bil 60.9 %, odstotek pomnilnika, ki ga uporabljajo vsebniki (MemoryUtilization) je bil 9.36 %.

MME-ji SageMaker zagotavljajo tudi meritve nalaganja modela za pridobitev vpogledov na ravni priklica modela:

• ModelLoadingWaitTime – Časovni interval za model, ki ga je treba prenesti ali naložiti
• ModelUnloadingTime – Časovni interval za razkladanje modela iz posode
• ModelDownloadingTime – Čas je za prenos modela iz Amazon S3
• ModelCacheHit – Število klicev modela, ki so že naloženi v vsebnik

Na naslednjem grafu lahko opazimo, da je trajalo 8.22 sekunde, da se je model odzval na zahtevo po sklepanju (ModelLatency), 24.1 milisekunde pa je bilo dodanih zakasnitvi od konca do konca zaradi režijskih stroškov SageMaker (OverheadLatency). Vidimo lahko tudi vse meritve napak iz klicev za priklic klica API končne točke, kot je npr Invocation4XXErrors in Invocation5XXErrors.

Za več informacij o meritvah MME CloudWatch glejte Meritve CloudWatch za uvedbe končnih točk z več modeli.

Povzetek

V tej objavi ste izvedeli za novo podporo za več modelov SageMaker za GPE, ki vam omogoča stroškovno učinkovito gostovanje na stotine modelov globokega učenja na strojni opremi za pospešeno računanje. Naučili ste se, kako uporabljati NVIDIA Triton Inference Server, ki ustvari konfiguracijo repozitorija modela za različna ozadja ogrodja, in kako razmestiti MME s samodejnim skaliranjem. Ta funkcija vam bo omogočila spreminjanje na stotine hiperpersonaliziranih modelov, ki so natančno prilagojeni, da poskrbijo za edinstvene izkušnje končnega uporabnika v aplikacijah AI. To funkcijo lahko izkoristite tudi za doseganje potrebne cenovne zmogljivosti za vašo aplikacijo sklepanja z uporabo frakcijskih grafičnih procesorjev.

Če želite začeti s podporo MME za GPE, glejte Podpora za več modelov končne točke za GPE.

O avtorjih

Dhawal Patel je glavni arhitekt strojnega učenja pri AWS. Sodeloval je z organizacijami, od velikih podjetij do srednje velikih zagonskih podjetij, pri problemih, povezanih s porazdeljenim računalništvom in umetno inteligenco. Osredotoča se na globoko učenje, vključno z domenami NLP in računalniškega vida. Strankam pomaga pri doseganju visoko zmogljivega sklepanja o modelih na Amazon SageMaker.

Vikram Elango je višji strokovnjak za rešitve AI/ML pri Amazon Web Services s sedežem v Virginiji v ZDA. Vikram pomaga strankam v globalni finančni in zavarovalniški industriji z načrtovanjem, implementacijo in premišljenim vodstvom pri gradnji in uvajanju aplikacij strojnega učenja v velikem obsegu. Trenutno je osredotočen na obdelavo naravnega jezika, odgovorno umetno inteligenco, optimizacijo sklepanja in skaliranje ML v podjetju. V prostem času uživa v potovanjih, pohodništvu, kuhanju in kampiranju z družino.

Saurabh Trikande je višji produktni vodja za Amazon SageMaker Inference. Navdušen je nad delom s strankami in ga motivira cilj demokratizacije strojnega učenja. Osredotoča se na ključne izzive, povezane z uvajanjem kompleksnih aplikacij ML, modelov ML z več najemniki, optimizacijo stroškov in zagotavljanjem dostopnosti uvajanja modelov globokega učenja. V prostem času Saurabh uživa v pohodništvu, spoznavanju inovativnih tehnologij, spremlja TechCrunch in preživlja čas s svojo družino.

Deepti Ragha je inženir za razvoj programske opreme v ekipi Amazon SageMaker. Njeno trenutno delo se osredotoča na gradnjo funkcij za učinkovito gostovanje modelov strojnega učenja. V prostem času rada potuje, planinari in goji rastline.

Nikhil Kulkarni je razvijalec programske opreme z AWS Machine Learning, ki se osredotoča na to, da naredi delovne obremenitve strojnega učenja bolj zmogljive v oblaku in je soustvarjalec AWS Deep Learning Containers za usposabljanje in sklepanje. Navdušen je nad porazdeljenimi sistemi globokega učenja. Zunaj službe rad bere knjige, igra kitaro in pripravlja pico.

Jiahong Liu je arhitekt rešitve v skupini ponudnikov storitev v oblaku pri NVIDIA. Strankam pomaga pri sprejemanju rešitev strojnega učenja in umetne inteligence, ki izkoriščajo pospešeno računalništvo NVIDIA za reševanje njihovih izzivov pri usposabljanju in sklepanju. V prostem času uživa v origamiju, DIY projektih in igra košarko.

Eliuth Triana je vodja odnosov z razvijalci v ekipi NVIDIA-AWS. Povezuje vodje izdelkov Amazon in AWS, razvijalce in znanstvenike s tehnologi in vodji izdelkov NVIDIA za pospešitev delovnih obremenitev Amazon ML/DL, izdelkov EC2 in storitev AI AWS. Poleg tega je Eliuth strasten gorski kolesar, smučar in igralec pokra.

Maksimiliano Maccanti je glavni inženir pri AWS, trenutno pri DynamoDB, bil sem v skupini za zagon SageMakerja na re:Invent 2017 in sem naslednjih 5 let preživel v platformi za gostovanje in dodajal vse vrste funkcij, s katerimi se soočajo stranke. V prostem času zbiram, popravljam in se igram z starinskimi konzolami za videoigre.