Voer meerdere deep learning-modellen uit op GPU met Amazon SageMaker multi-model endpoints

Terwijl de acceptatie van AI in de hele branche steeds sneller gaat, bouwen klanten geavanceerde modellen die profiteren van nieuwe wetenschappelijke doorbraken in deep learning. Met deze modellen van de volgende generatie kunt u state-of-the-art, mensachtige prestaties bereiken op het gebied van natuurlijke taalverwerking (NLP), computervisie, spraakherkenning, medisch onderzoek, cyberbeveiliging, voorspelling van eiwitstructuur en vele andere . Grote taalmodellen zoals GPT-3, OPT en BLOOM kunnen bijvoorbeeld tekst vertalen, samenvatten en schrijven met menselijke nuances. In de computervisieruimte kunnen tekst-naar-beeld-diffusiemodellen zoals DALL-E en Imagen fotorealistische afbeeldingen maken van natuurlijke taal met een hoger niveau van visueel en taalbegrip van de wereld om ons heen. Deze multimodale modellen bieden uitgebreidere functies voor verschillende downstreamtaken en de mogelijkheid om ze af te stemmen op specifieke domeinen, en ze bieden onze klanten krachtige zakelijke kansen.

Deze deep learning-modellen blijven groeien in omvang en bevatten doorgaans miljarden modelparameters om modelprestaties te schalen voor een breed scala aan taken, zoals het genereren van afbeeldingen, tekstsamenvattingen, taalvertaling en meer. Het is ook nodig om deze modellen aan te passen om een ​​hypergepersonaliseerde ervaring aan individuen te bieden. Als gevolg hiervan wordt een groter aantal modellen ontwikkeld door deze modellen te verfijnen voor verschillende stroomafwaartse taken. Om te voldoen aan de latentie- en doorvoerdoelen van AI-applicaties, hebben GPU-instanties de voorkeur boven CPU-instanties (gezien de rekenkracht die GPU's bieden). GPU-instanties zijn echter duur en de kosten kunnen oplopen als u meer dan 10 modellen implementeert. Hoewel deze modellen potentieel impactvolle AI-toepassingen kunnen opleveren, kan het vanwege hun omvang en aantal modellen een uitdaging zijn om deze deep learning-modellen op kosteneffectieve manieren te schalen.

Amazon Sage Maker multi-model endpoints (MME's) bieden een schaalbare en kosteneffectieve manier om een ​​groot aantal deep learning-modellen te implementeren. MME's zijn een populaire hostingkeuze om honderden CPU-gebaseerde modellen te hosten bij klanten zoals Zendesk, Veeva en AT&T. Voorheen had je beperkte opties om honderden deep learning-modellen te implementeren die versnelde rekenkracht met GPU's nodig hadden. Vandaag kondigen we MME-ondersteuning voor GPU aan. Nu kunt u duizenden deep learning-modellen inzetten achter één SageMaker-endpoint. MME's kunnen nu meerdere modellen op een GPU-kern draaien, GPU-instanties achter een eindpunt delen over meerdere modellen en modellen dynamisch laden en lossen op basis van het inkomende verkeer. Hiermee kunt u aanzienlijk kosten besparen en de beste prijsprestaties behalen.

In dit bericht laten we zien hoe u meerdere deep learning-modellen op GPU kunt uitvoeren met SageMaker MME's.

SageMaker MME's

Met SageMaker MME's kunt u meerdere modellen implementeren achter een enkel inferentie-eindpunt dat een of meer instanties kan bevatten. Met MME's wordt elke instantie beheerd om meerdere modellen te laden en te bedienen. Met MME's kunt u de lineair stijgende kosten van het hosten van meerdere modellen doorbreken en de infrastructuur voor alle modellen hergebruiken.

Het volgende diagram illustreert de architectuur van een SageMaker MME.

De SageMaker MME downloadt dynamisch modellen van Amazon eenvoudige opslagservice (Amazon S3) wanneer aangeroepen, in plaats van alle modellen te downloaden wanneer het eindpunt voor het eerst wordt gemaakt. Als gevolg hiervan kan een eerste aanroep van een model een hogere inferentielatentie zien dan de daaropvolgende inferenties, die worden voltooid met een lage latentie. Als het model al in de container is geladen wanneer het wordt aangeroepen, wordt de stap downloaden en laden overgeslagen en retourneert het model de gevolgtrekkingen met een lage latentie. Stel je hebt bijvoorbeeld een model dat maar een paar keer per dag wordt gebruikt. Het wordt automatisch op aanvraag geladen, terwijl veelgebruikte modellen in het geheugen worden bewaard en worden aangeroepen met een consistent lage latentie.

SageMaker MME's met GPU-ondersteuning

SageMaker MME's met GPU werken met NVIDIA Triton Inference-server. NVIDIA Triton Inference Server is een open-source inference-serving-software die het inference-serving-proces vereenvoudigt en hoge inferentieprestaties biedt. Triton ondersteunt alle belangrijke trainings- en inferentiekaders, zoals TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, aangepaste C++ en meer. Het biedt dynamische batching, gelijktijdige runs, kwantisering na de training en optimale modelconfiguratie om krachtige inferentie te bereiken. Bovendien is NVIDIA Triton Inference Server uitgebreid om te implementeren MME API-contract, om te integreren met MME.

Het volgende diagram illustreert een MME-workflow.

De workflowstappen zijn als volgt:

1. De SageMaker MME ontvangt een HTTP-aanroepverzoek voor een bepaald model met behulp van: TargetModel in het verzoek samen met de payload.
2. SageMaker leidt verkeer naar de juiste instantie achter het eindpunt waar het doelmodel is geladen. SageMaker begrijpt het verkeerspatroon van alle modellen achter de MME en routeert verzoeken slim.
3. SageMaker zorgt voor modelbeheer achter het eindpunt, laadt het model dynamisch in het geheugen van de container en ontlaadt het model op basis van de gedeelde vloot van GPU-instanties om de beste prijsprestaties te leveren.
4. SageMaker downloadt dynamisch modellen van Amazon S3 naar het opslagvolume van de instantie. Als het aangeroepen model niet beschikbaar is op het instantieopslagvolume, wordt het model gedownload naar het instantieopslagvolume. Als het opslagvolume van het exemplaar de capaciteit bereikt, verwijdert SageMaker alle ongebruikte modellen van het opslagvolume.
5. SageMaker laadt het model naar het geheugen van de NVIDIA Triton-container op een GPU-versnelde instantie en dient het inferentieverzoek. De GPU-kern wordt gedeeld door alle modellen in een instantie. Als het model al in het containergeheugen is geladen, worden de volgende verzoeken sneller uitgevoerd omdat SageMaker het niet hoeft te downloaden en opnieuw te laden.
6. SageMaker zorgt voor verkeersvorming naar het MME-eindpunt en onderhoudt optimale modelkopieën op GPU-instanties voor de beste prijsprestaties. Het blijft verkeer routeren naar de instantie waar het model is geladen. Als de instantiebronnen hun capaciteit bereiken vanwege een hoog gebruik, verwijdert SageMaker de minst gebruikte modellen uit de container om bronnen vrij te maken voor het laden van vaker gebruikte modellen.

SageMaker MME's kunnen horizontaal schalen met behulp van een beleid voor automatisch schalen en extra GPU-rekeninstanties inrichten op basis van metrische gegevens zoals aanroepen per instantie en GPU-gebruik om eventuele verkeerspieken naar MME-eindpunten te verwerken.

Overzicht oplossingen

In dit bericht laten we u zien hoe u de nieuwe functies van SageMaker MME's met GPU kunt gebruiken met een gebruiksscenario voor computervisie. Voor demonstratiedoeleinden gebruiken we een voorgetraind model van een ResNet-50 convolutief neuraal netwerk dat afbeeldingen in 1,000 categorieën kan classificeren. We bespreken hoe je het volgende kunt doen:

• Gebruik een NVIDIA Triton-inferentiecontainer op SageMaker MME's, met behulp van verschillende Triton-modelframework-backends zoals PyTorch en TensorRT
• Converteer ResNet-50-modellen naar het geoptimaliseerde TensorRT-engineformaat en implementeer het met een SageMaker MME
• Stel beleid voor automatisch schalen in voor de MME
• Krijg inzicht in instantie- en aanroepstatistieken met behulp van Amazon Cloud Watch

Modelartefacten maken

In dit gedeelte worden de stappen beschreven om een ​​vooraf getraind ResNet-50-model voor te bereiden om te worden geïmplementeerd op een SageMaker MME met behulp van Triton Inference Server-modelconfiguraties. U kunt alle stappen reproduceren met behulp van het stapsgewijze notitieboek op GitHub.

Voor dit bericht demonstreren we implementatie met twee modellen. U kunt echter honderden modellen voorbereiden en implementeren. De modellen kunnen al dan niet hetzelfde raamwerk delen.

Een PyTorch-model voorbereiden

Eerst laden we een vooraf getraind ResNet50-model met behulp van het torchvision-modellenpakket. We slaan het model op als een model.pt-bestand in TorchScript-geoptimaliseerd en geserialiseerd formaat. TorchScript compileert een voorwaartse doorgang van het ResNet50-model in enthousiaste modus met voorbeeldinvoer, dus we passeren één instantie van een RGB-afbeelding met drie kleurkanalen van afmeting 224 x 224.

Daarna moeten we de modellen voorbereiden voor Triton Inference Server. De volgende code toont de modelrepository voor de backend van het PyTorch-framework. Triton gebruikt het model.pt-bestand dat in de modelrepository is geplaatst om voorspellingen te doen.

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

Het modelconfiguratiebestand config.pbtxt moet de naam van het model opgeven (resnet), de platform- en backend-eigenschappen (pytorch_libtorch), max_batch_size (128), en de invoer- en uitvoertensoren samen met het gegevenstype (TYPE_FP32) informatie. Daarnaast kunt u specificeren: instance_group en dynamic_batching eigenschappen om hoge prestatie-inferentie te bereiken. Zie de volgende code:

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
}

Bereid het TensorRT-model voor

NVIDIA TensorRT is een SDK voor krachtige deep learning-inferentie, en bevat een deep learning-inferentie-optimizer en runtime die lage latentie en hoge doorvoer voor inferentietoepassingen levert. We gebruiken de opdrachtregeltool trtexec om een ​​geserialiseerde TensorRT-engine te genereren uit een ONNX model formaat. Voer de volgende stappen uit om een ​​vooraf getraind ResNet-50-model om te zetten naar NVIDIA TensorRT:

1. Exporteer het vooraf getrainde ResNet-50-model naar een ONNX-formaat met behulp van fakkel.onnxDeze stap voert het model één keer uit om de uitvoering ervan te traceren met een voorbeeldinvoer en exporteert vervolgens het getraceerde model naar het opgegeven bestand model.onnx.
2. Gebruik trtexec om een ​​TensorRT-engineplan te maken van de model.onnx het dossier. U kunt desgewenst de precisie van drijvende-kommaberekeningen verminderen, hetzij door ze eenvoudig in 16-bits drijvende-komma uit te voeren, of door drijvende-kommawaarden te kwantiseren zodat berekeningen kunnen worden uitgevoerd met 8-bits gehele getallen.

De volgende code toont de modelrepositorystructuur voor het TensorRT-model:

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

Voor het TensorRT-model specificeren we: tensorrt_plan als het platform en voer de Tensor-specificaties in van het beeld van afmeting 224 x 224, die de kleurkanalen heeft. De output Tensor met 1,000 afmetingen is van het type TYPE_FP32, overeenkomend met de verschillende objectcategorieën. Zie de volgende code:

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

Modelartefacten opslaan in Amazon S3

SageMaker verwacht dat de modelartefacten in .tar.gz formaat. Ze moeten ook voldoen aan de Triton-containervereisten zoals modelnaam, versie, config.pbtxt bestanden en meer. tar de map met het modelbestand als .tar.gz en upload het naar 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 we de modelartefacten naar Amazon S3 hebben geüpload, kunnen we een SageMaker MME maken.

Modellen implementeren met een MME

We implementeren nu een ResNet-50-model met twee verschillende framework-backends (PyTorch en TensorRT) naar een SageMaker MME.

Merk op dat u honderden modellen kunt implementeren en dat de modellen hetzelfde framework kunnen gebruiken. Ze kunnen ook verschillende frameworks gebruiken, zoals te zien is in dit bericht.

We maken gebruik van de AWS SDK voor Python (Boto3) APIs maak_model, create_endpoint_config en maak_eindpunt om een ​​MME te maken.

Definieer de serveercontainer

Definieer in de containerdefinitie de model_data_url om de S3-directory op te geven die alle modellen bevat die de SageMaker MME gebruikt om voorspellingen te laden en uit te voeren. Set Mode naar MultiModel om aan te geven dat SageMaker het eindpunt maakt met MME-containerspecificaties. We hebben de container ingesteld met een afbeelding die het implementeren van MME's met GPU ondersteunt. Zie de volgende code:

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

Een object met meerdere modellen maken

Gebruik de SageMaker Boto3-client om het model te maken met de create_model API. We geven de containerdefinitie door aan de API voor het maken van een model, samen met: ModelName en ExecutionRoleArn:

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

MME-configuraties definiëren

Maak MME-configuraties met behulp van de create_endpoint_config Boto3-API. Specificeer een versnelde GPU-computinginstantie in InstanceType (we gebruiken het g4dn.4xlarge instantietype). We raden u aan uw eindpunten te configureren met ten minste twee instanties. Hierdoor kan SageMaker een zeer beschikbare set voorspellingen bieden over meerdere beschikbaarheidszones voor de modellen.

Op basis van onze bevindingen kunt u betere prijsprestaties krijgen op voor ML geoptimaliseerde instanties met een enkele GPU-kern. Daarom is MME-ondersteuning voor de GPU-functie alleen ingeschakeld voor single-GPU core-instanties. Voor een volledige lijst van ondersteunde instanties, zie: Ondersteunde GPU-instantietypen.

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

Maak een MME

Met de voorgaande eindpuntconfiguratie maken we een SageMaker MME met behulp van de maak_eindpunt API. SageMaker maakt de MME, start de ML-rekeninstantie g4dn.4xlarge en implementeert de PyTorch- en TensorRT ResNet-50-modellen daarop. Zie de volgende code:

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

Roep het doelmodel op op de MME

Nadat we het eindpunt hebben gemaakt, kunnen we een gevolgtrekkingsverzoek naar de MME sturen met behulp van de invoke_enpoint API. We specificeren de TargetModel in de oproep en geef de payload door voor elk modeltype. De volgende code is een voorbeeldaanroep voor het PyTorch-model en TensorRT-model:

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
)

Beleid voor automatisch schalen instellen voor de GPU MME

SageMaker MME's ondersteunen automatisch schalen voor uw gehoste modellen. Automatisch schalen past dynamisch het aantal instanties aan dat voor een model is ingericht als reactie op wijzigingen in uw werkbelasting. Wanneer de werklast toeneemt, brengt automatisch schalen meer instanties online. Wanneer de werklast afneemt, verwijdert automatisch schalen onnodige instanties, zodat u niet betaalt voor ingerichte instanties die u niet gebruikt.

In het volgende schaalbeleid gebruiken we de aangepaste statistiek GPUUtilization in de TargetTrackingScalingPolicyConfiguration configuratie en stel een TargetValue of 60.0 voor de doelwaarde van die metriek. Dit beleid voor automatisch schalen voorziet in extra instanties tot MaxCapacity wanneer het GPU-gebruik meer dan 60% is.

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

Wij raden aan om te gebruiken GPUUtilization or InvocationsPerInstance om beleid voor automatisch schalen voor uw MME te configureren. Voor meer details, zie Beleid voor automatisch schalen instellen voor implementaties van meerdere modellen van eindpunten

CloudWatch-statistieken voor GPU MME's

SageMaker MME's bieden de volgende metrische gegevens op instantieniveau om te controleren:

• GeladenModelCount – Aantal modellen geladen in de containers
• GPUGebruik – Percentage GPU-eenheden dat door de containers wordt gebruikt
• GPUGeheugengebruik – Percentage GPU-geheugen dat door de containers wordt gebruikt
• Schijfgebruik – Percentage schijfruimte dat door de containers wordt gebruikt

Met deze metrische gegevens kunt u plannen voor een effectief gebruik van GPU-instantiebronnen. In de volgende grafiek zien we: GPUMemoryUtilization was 38.3% toen meer dan 16 ResNet-50-modellen in de container werden geladen. De som van het gebruik van elke afzonderlijke CPU-kern (CPUUtilization) was 60.9% en het percentage geheugen dat door de containers (MemoryUtilization) bedroeg 9.36%.

SageMaker MME's bieden ook modellaadstatistieken om inzichten op modelaanroepniveau te krijgen:

• ModelBezig met ladenWachttijd – Tijdsinterval voor het model dat moet worden gedownload of geladen
• ModelOntlaadtijd – Tijdsinterval om het model uit de container te halen
• ModelDownloadenTijd – Tijd om het model te downloaden van Amazon S3
• ModelCacheHit – Aantal aanroepen naar het model dat al in de container is geladen

In de volgende grafiek kunnen we zien dat het 8.22 seconden duurde voordat een model reageerde op een gevolgtrekkingsverzoek (ModelLatency), en 24.1 milliseconden is toegevoegd aan de end-to-end latentie vanwege SageMaker-overheads (OverheadLatency). We kunnen ook eventuele foutstatistieken zien van oproepen om een ​​eindpunt-API-aanroep aan te roepen, zoals: Invocation4XXErrors en Invocation5XXErrors.

Raadpleeg voor meer informatie over MME CloudWatch-statistieken: CloudWatch-statistieken voor implementaties van meerdere modellen van eindpunten.

Samengevat

In dit bericht heb je meer geleerd over de nieuwe SageMaker-ondersteuning voor meerdere modellen voor GPU, waarmee je op kosteneffectieve wijze honderden deep learning-modellen kunt hosten op versnelde computerhardware. Je hebt geleerd hoe je de NVIDIA Triton Inference Server gebruikt, die een modelrepository-configuratie maakt voor verschillende framework-backends, en hoe je een MME implementeert met automatisch schalen. Met deze functie kunt u honderden hypergepersonaliseerde modellen schalen die zijn afgestemd op unieke eindgebruikerservaringen in AI-toepassingen. U kunt deze functie ook gebruiken om de noodzakelijke prijsprestaties voor uw inferentietoepassing te bereiken met behulp van fractionele GPU's.

Om aan de slag te gaan met MME-ondersteuning voor GPU, zie Ondersteuning voor meerdere modellen endpoints voor GPU.

Over de auteurs

Dhawal Patel is Principal Machine Learning Architect bij AWS. Hij heeft met organisaties, variërend van grote ondernemingen tot middelgrote startups, gewerkt aan problemen met betrekking tot gedistribueerde computing en kunstmatige intelligentie. Hij richt zich op deep learning, inclusief NLP en computer vision domeinen. Hij helpt klanten om hoogwaardige modelinferentie te bereiken op Amazon SageMaker.

Vikram Elango is een Senior AI/ML Specialist Solutions Architect bij Amazon Web Services, gevestigd in Virginia, VS. Vikram helpt wereldwijde klanten in de financiële en verzekeringssector met ontwerp, implementatie en thought leadership om machine learning-applicaties op grote schaal te bouwen en te implementeren. Hij is momenteel gefocust op natuurlijke taalverwerking, verantwoorde AI, inferentie-optimalisatie en het schalen van ML in de hele onderneming. In zijn vrije tijd houdt hij van reizen, wandelen, koken en kamperen met zijn gezin.

Saurabh Trikande is Senior Product Manager voor Amazon SageMaker Inference. Hij heeft een passie voor het werken met klanten en wordt gemotiveerd door het doel om machine learning te democratiseren. Hij richt zich op kernuitdagingen met betrekking tot het inzetten van complexe ML-applicaties, multi-tenant ML-modellen, kostenoptimalisaties en het toegankelijker maken van de inzet van deep learning-modellen. In zijn vrije tijd houdt Saurabh van wandelen, leren over innovatieve technologieën, TechCrunch volgen en tijd doorbrengen met zijn gezin.

Diepte Ragha is een Software Development Engineer in het Amazon SageMaker-team. Haar huidige werk is gericht op het bouwen van functies om machine learning-modellen efficiënt te hosten. In haar vrije tijd houdt ze van reizen, wandelen en planten kweken.

Nikhil Kulkarni is een softwareontwikkelaar met AWS Machine Learning, gericht op het performanter maken van machine learning-workloads in de cloud en is mede-maker van AWS Deep Learning Containers voor training en inferentie. Hij is gepassioneerd door gedistribueerde Deep Learning Systems. Naast zijn werk houdt hij van boeken lezen, gitaar spelen en pizza bakken.

Jiahong Liu is Solution Architect in het Cloud Service Provider-team van NVIDIA. Hij helpt klanten bij het adopteren van machine learning en AI-oplossingen die gebruikmaken van NVIDIA Accelerated Computing om hun trainings- en inferentie-uitdagingen aan te pakken. In zijn vrije tijd houdt hij van origami, doe-het-zelfprojecten en basketbal.

Eliuth Triana is een Developer Relations Manager in het NVIDIA-AWS-team. Hij verbindt productleiders, ontwikkelaars en wetenschappers van Amazon en AWS met NVIDIA-technologen en productleiders om Amazon ML/DL-workloads, EC2-producten en AWS AI-services te versnellen. Daarnaast is Eliuth een gepassioneerd mountainbiker, skiër en pokerspeler.

Maximiliano Maccanti is een Principal Engineer bij AWS momenteel bij DynamoDB, ik zat in het lanceringsteam van SageMaker bij re:Invent 2017 en bracht de volgende 5 jaar door op het hostingplatform om allerlei soorten klantgerichte functies toe te voegen. In mijn vrije tijd verzamel, repareer en speel ik met vintage videogameconsoles.