Exécutez plusieurs modèles d'apprentissage en profondeur sur GPU avec les points de terminaison multimodèles d'Amazon SageMaker

Alors que l’adoption de l’IA s’accélère dans l’industrie, les clients créent des modèles sophistiqués qui tirent parti des nouvelles avancées scientifiques en matière d’apprentissage profond. Ces modèles de nouvelle génération vous permettent d'atteindre des performances de pointe, proches de celles des humains, dans les domaines du traitement du langage naturel (NLP), de la vision par ordinateur, de la reconnaissance vocale, de la recherche médicale, de la cybersécurité, de la prédiction de la structure des protéines et bien d'autres. . Par exemple, de grands modèles linguistiques tels que GPT-3, OPT et BLOOM peuvent traduire, résumer et écrire du texte avec des nuances semblables à celles des humains. Dans le domaine de la vision par ordinateur, les modèles de diffusion texte-image tels que DALL-E et Imagen peuvent créer des images photoréalistes à partir du langage naturel avec un niveau plus élevé de compréhension visuelle et linguistique du monde qui nous entoure. Ces modèles multimodaux offrent des fonctionnalités plus riches pour diverses tâches en aval et la possibilité de les affiner pour des domaines spécifiques, et ils offrent de puissantes opportunités commerciales à nos clients.

Ces modèles d'apprentissage profond ne cessent de croître en termes de taille et contiennent généralement des milliards de paramètres de modèle pour faire évoluer les performances du modèle pour une grande variété de tâches, telles que la génération d'images, la synthèse de texte, la traduction linguistique, etc. Il existe également un besoin de personnaliser ces modèles pour offrir une expérience hyper-personnalisée aux individus. En conséquence, un plus grand nombre de modèles sont développés en affinant ces modèles pour diverses tâches en aval. Pour atteindre les objectifs de latence et de débit des applications d'IA, les instances GPU sont préférées aux instances CPU (compte tenu de la puissance de calcul offerte par les GPU). Cependant, les instances GPU sont coûteuses et les coûts peuvent s'additionner si vous déployez plus de 10 modèles. Bien que ces modèles puissent potentiellement apporter des applications d’IA percutantes, il peut s’avérer difficile de faire évoluer ces modèles d’apprentissage profond de manière rentable en raison de leur taille et du nombre de modèles.

Amazon Sage Maker Les points de terminaison multimodèles (MME) offrent un moyen évolutif et rentable de déployer un grand nombre de modèles d'apprentissage profond. Les MME sont un choix d'hébergement populaire pour héberger des centaines de modèles basés sur CPU parmi des clients comme Zendesk, Veeva et AT&T. Auparavant, vous disposiez d'options limitées pour déployer des centaines de modèles d'apprentissage profond nécessitant un calcul accéléré avec des GPU. Aujourd'hui, nous annonçons la prise en charge de MME pour le GPU. Vous pouvez désormais déployer des milliers de modèles d'apprentissage profond derrière un seul point de terminaison SageMaker. Les MME peuvent désormais exécuter plusieurs modèles sur un cœur GPU, partager des instances GPU derrière un point de terminaison sur plusieurs modèles et charger et décharger dynamiquement des modèles en fonction du trafic entrant. Grâce à cela, vous pouvez réduire considérablement vos coûts et obtenir le meilleur rapport qualité-prix.

Dans cet article, nous montrons comment exécuter plusieurs modèles d'apprentissage profond sur GPU avec les MME SageMaker.

MME SageMaker

Les MME SageMaker vous permettent de déployer plusieurs modèles derrière un seul point de terminaison d'inférence pouvant contenir une ou plusieurs instances. Avec les MME, chaque instance est gérée pour charger et servir plusieurs modèles. Les MME vous permettent de réduire le coût linéairement croissant de l’hébergement de plusieurs modèles et de réutiliser l’infrastructure sur tous les modèles.

Le diagramme suivant illustre l'architecture d'un SageMaker MME.

Le SageMaker MME télécharge dynamiquement des modèles à partir de Service de stockage simple Amazon (Amazon S3) lorsqu'il est invoqué, au lieu de télécharger tous les modèles lors de la première création du point de terminaison. Par conséquent, un appel initial à un modèle peut entraîner une latence d'inférence plus élevée que les inférences suivantes, qui sont effectuées avec une faible latence. Si le modèle est déjà chargé sur le conteneur lorsqu'il est invoqué, l'étape de téléchargement et de chargement est ignorée et le modèle renvoie les inférences avec une faible latence. Par exemple, supposons que vous disposiez d’un modèle qui n’est utilisé que quelques fois par jour. Il est automatiquement chargé à la demande, tandis que les modèles fréquemment consultés sont conservés en mémoire et invoqués avec une latence constamment faible.

MME SageMaker avec prise en charge GPU

Les MME SageMaker avec GPU fonctionnent avec Serveur d'inférence NVIDIA Triton. NVIDIA Triton Inference Server est un logiciel de service d'inférence open source qui simplifie le processus de service d'inférence et offre des performances d'inférence élevées. Triton prend en charge tous les principaux frameworks de formation et d'inférence, tels que TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, C++ personnalisé, etc. Il offre un traitement par lots dynamique, des exécutions simultanées, une quantification post-formation et une configuration de modèle optimale pour obtenir une inférence hautes performances. De plus, NVIDIA Triton Inference Server a été étendu pour implémenter Contrat API MME, à intégrer avec MME.

Le diagramme suivant illustre un flux de travail MME.

Les étapes du flux de travail sont les suivantes :

1. Le SageMaker MME reçoit une demande d'invocation HTTP pour un modèle particulier à l'aide de TargetModel dans la requête avec la charge utile.
2. SageMaker achemine le trafic vers la bonne instance derrière le point de terminaison où le modèle cible est chargé. SageMaker comprend le modèle de trafic sur tous les modèles derrière le MME et achemine intelligemment les demandes.
3. SageMaker s'occupe de la gestion du modèle derrière le point de terminaison, charge dynamiquement le modèle dans la mémoire du conteneur et décharge le modèle basé sur la flotte partagée d'instances GPU pour offrir les meilleures performances en termes de prix.
4. SageMaker télécharge dynamiquement les modèles d'Amazon S3 vers le volume de stockage de l'instance. Si le modèle appelé n'est pas disponible sur le volume de stockage d'instance, le modèle est téléchargé sur le volume de stockage d'instance. Si le volume de stockage de l'instance atteint sa capacité, SageMaker supprime tous les modèles inutilisés du volume de stockage.
5. SageMaker charge le modèle dans la mémoire du conteneur NVIDIA Triton sur une instance accélérée par GPU et répond à la demande d'inférence. Le cœur GPU est partagé par tous les modèles d’une instance. Si le modèle est déjà chargé dans la mémoire du conteneur, les requêtes suivantes sont traitées plus rapidement car SageMaker n'a pas besoin de le télécharger et de le charger à nouveau.
6. SageMaker s'occupe de la mise en forme du trafic vers le point de terminaison MME et maintient des copies de modèles optimales sur les instances GPU pour des performances tarifaires optimales. Il continue d'acheminer le trafic vers l'instance où le modèle est chargé. Si les ressources de l'instance atteignent leur capacité en raison d'une utilisation élevée, SageMaker décharge les modèles les moins utilisés du conteneur afin de libérer des ressources pour charger les modèles les plus fréquemment utilisés.

Les MME SageMaker peuvent évoluer horizontalement à l'aide d'une politique de mise à l'échelle automatique et fournir des instances de calcul GPU supplémentaires en fonction de métriques telles que les appels par instance et l'utilisation du GPU pour répondre à toute augmentation de trafic vers les points de terminaison MME.

Vue d'ensemble de la solution

Dans cet article, nous vous montrons comment utiliser les nouvelles fonctionnalités des MME SageMaker avec GPU avec un cas d'utilisation de vision par ordinateur. À des fins de démonstration, nous utilisons un modèle pré-entraîné de réseau neuronal convolutif ResNet-50 qui peut classer les images en 1,000 XNUMX catégories. Nous discutons de la façon de procéder comme suit :

• Utilisez un conteneur d'inférence NVIDIA Triton sur les MME SageMaker, en utilisant différents backends de framework de modèle Triton tels que PyTorch et TensorRT
• Convertissez les modèles ResNet-50 au format de moteur TensorRT optimisé et déployez-le avec un SageMaker MME
• Configurer des stratégies de mise à l'échelle automatique pour le MME
• Obtenez des informations sur les métriques d'instance et d'appel à l'aide Amazon Cloud Watch

Créer des artefacts de modèle

Cette section décrit les étapes de préparation d'un modèle pré-entraîné ResNet-50 à déployer sur un SageMaker MME à l'aide des configurations de modèle Triton Inference Server. Vous pouvez reproduire toutes les étapes à l'aide du carnet pas à pas disponible sur GitHub.

Pour cet article, nous démontrons le déploiement avec deux modèles. Cependant, vous pouvez préparer et déployer des centaines de modèles. Les modèles peuvent ou non partager le même cadre.

Préparer un modèle PyTorch

Tout d'abord, nous chargeons un modèle ResNet50 pré-entraîné à l'aide du package de modèles torchvision. Nous enregistrons le modèle en tant que fichier model.pt au format TorchScript optimisé et sérialisé. TorchScript compile une passe avant du modèle ResNet50 en mode impatient avec des exemples d'entrées, nous transmettons donc une instance d'une image RVB avec trois canaux de couleur de dimension 224 x 224.

Ensuite, nous devons préparer les modèles pour Triton Inference Server. Le code suivant montre le référentiel de modèles pour le backend du framework PyTorch. Triton utilise le fichier model.pt placé dans le référentiel de modèles pour servir les prédictions.

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

Le fichier de configuration du modèle config.pbtxt doit préciser le nom du modèle (resnet), les propriétés de la plateforme et du backend (pytorch_libtorch), max_batch_size (128), et les tenseurs d'entrée et de sortie ainsi que le type de données (TYPE_FP32) information. De plus, vous pouvez spécifier instance_group ainsi que le dynamic_batching propriétés pour obtenir une inférence haute performance. Voir le code suivant :

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
}

Préparer le modèle TensorRT

NVIDIA TensorRT est un SDK pour l'inférence d'apprentissage profond hautes performances, et comprend un optimiseur d'inférence d'apprentissage profond et un moteur d'exécution qui offre une faible latence et un débit élevé pour les applications d'inférence. Nous utilisons l'outil de ligne de commande trtexec pour générer un moteur sérialisé TensorRT à partir d'un ONNX format du modèle. Suivez les étapes suivantes pour convertir un modèle pré-entraîné ResNet-50 en NVIDIA TensorRT :

1. Exportez le modèle ResNet-50 pré-entraîné au format ONNX à l'aide de torche.onnx.Cette étape exécute le modèle une fois pour tracer son exécution avec un exemple d'entrée, puis exporte le modèle tracé vers le fichier spécifié. model.onnx.
2. Utilisez trtexec pour créer un plan de moteur TensorRT à partir du model.onnx déposer. Vous pouvez éventuellement réduire la précision des calculs à virgule flottante, soit en les exécutant simplement en virgule flottante 16 bits, soit en quantifiant les valeurs à virgule flottante afin que les calculs puissent être effectués à l'aide d'entiers 8 bits.

Le code suivant montre la structure du référentiel de modèles pour le modèle TensorRT :

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

Pour le modèle TensorRT, nous précisons tensorrt_plan comme plate-forme et saisissez les spécifications Tensor de l'image de dimension 224 x 224, qui possède les canaux de couleur. Le Tensor de sortie à 1,000 XNUMX dimensions est de type TYPE_FP32, correspondant aux différentes catégories d'objets. Voir le code suivant :

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

Stocker les artefacts de modèle dans Amazon S3

SageMaker attend les artefacts du modèle dans .tar.gz format. Ils doivent également satisfaire aux exigences des conteneurs Triton telles que le nom du modèle, la version, config.pbtxt fichiers, et plus encore. tar le dossier contenant le fichier modèle comme .tar.gz et téléchargez-le sur 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")

Maintenant que nous avons téléchargé les artefacts du modèle sur Amazon S3, nous pouvons créer un MME SageMaker.

Déployer des modèles avec un MME

Nous déployons maintenant un modèle ResNet-50 avec deux backends de framework différents (PyTorch et TensorRT) sur une MME SageMaker.

Notez que vous pouvez déployer des centaines de modèles et que les modèles peuvent utiliser le même framework. Ils peuvent également utiliser différents frameworks, comme indiqué dans cet article.

Nous utilisons les AWS SDK pour Python (Boto3) Apis créer_modèle, create_endpoint_configet créer_endpoint pour créer un MME.

Définir le conteneur de service

Dans la définition du conteneur, définissez le model_data_url pour spécifier le répertoire S3 qui contient tous les modèles que SageMaker MME utilise pour charger et servir des prédictions. Ensemble Mode à MultiModel pour indiquer que SageMaker crée le point de terminaison avec les spécifications du conteneur MME. Nous définissons le conteneur avec une image qui prend en charge le déploiement de MME avec GPU. Voir le code suivant :

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

Créer un objet multi-modèle

Utilisez le client SageMaker Boto3 pour créer le modèle à l'aide du create_model API. Nous transmettons la définition du conteneur à l'API de création de modèle avec ModelName ainsi que le ExecutionRoleArn:

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

Définir les configurations MME

Créez des configurations MME à l'aide de create_endpoint_config API Boto3. Spécifiez une instance de calcul GPU accéléré dans InstanceType (nous utilisons le type d'instance g4dn.4xlarge). Nous vous recommandons de configurer vos points de terminaison avec au moins deux instances. Cela permet à SageMaker de fournir un ensemble de prédictions hautement disponibles dans plusieurs zones de disponibilité pour les modèles.

Sur la base de nos conclusions, vous pouvez obtenir de meilleures performances en termes de prix sur les instances optimisées pour le ML avec un seul cœur GPU. Par conséquent, la prise en charge MME de la fonctionnalité GPU n’est activée que pour les instances principales à GPU unique. Pour une liste complète des instances prises en charge, reportez-vous à Types d'instances GPU pris en charge.

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

Créer un MME

Avec la configuration de point de terminaison précédente, nous créons une MME SageMaker à l'aide du créer_endpoint API. SageMaker crée le MME, lance l'instance de calcul ML g4dn.4xlarge et y déploie les modèles PyTorch et TensorRT ResNet-50. Voir le code suivant :

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

Invoquer le modèle cible sur le MME

Après avoir créé le point de terminaison, nous pouvons envoyer une demande d'inférence à la MME à l'aide du invoke_enpoint API. Nous précisons le TargetModel dans l’appel d’invocation et transmettez la charge utile pour chaque type de modèle. Le code suivant est un exemple d'appel pour le modèle PyTorch et le modèle 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
)

Configurer des politiques de mise à l'échelle automatique pour le GPU MME

Les MME SageMaker prennent en charge la mise à l'échelle automatique de vos modèles hébergés. La mise à l'échelle automatique ajuste dynamiquement le nombre d'instances provisionnées pour un modèle en réponse aux modifications de votre charge de travail. Lorsque la charge de travail augmente, la mise à l’échelle automatique met davantage d’instances en ligne. Lorsque la charge de travail diminue, la mise à l'échelle automatique supprime les instances inutiles afin que vous ne payiez pas pour les instances provisionnées que vous n'utilisez pas.

Dans la politique de mise à l'échelle suivante, nous utilisons la métrique personnalisée GPUUtilization dans l' TargetTrackingScalingPolicyConfiguration configuration et définir un TargetValue of 60.0 pour la valeur cible de cette métrique. Cette stratégie d'autoscaling fournit des instances supplémentaires jusqu'à MaxCapacity lorsque l'utilisation du GPU est supérieure à 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 
    }
)

Nous vous recommandons d'utiliser GPUUtilization or InvocationsPerInstance pour configurer les politiques de mise à l'échelle automatique pour votre MME. Pour plus de détails, voir Définir des politiques de mise à l'échelle automatique pour les déploiements de points de terminaison multimodèles

Métriques CloudWatch pour les GPU MME

Les MME SageMaker fournissent les métriques suivantes au niveau de l'instance à surveiller :

• LoadedModelCountLoadedModelCount – Nombre de modèles chargés dans les conteneurs
• Utilisation du GPU – Pourcentage d'unités GPU utilisées par les conteneurs
• Utilisation de la mémoire GPU – Pourcentage de mémoire GPU utilisée par les conteneurs
• Utilisation du disque – Pourcentage d'espace disque utilisé par les conteneurs

Ces métriques vous permettent de planifier une utilisation efficace des ressources de l'instance GPU. Dans le graphique suivant, nous voyons GPUMemoryUtilization était de 38.3 % lorsque plus de 16 modèles ResNet-50 étaient chargés dans le conteneur. La somme de l'utilisation de chaque cœur de processeur individuel (CPUUtilization) était de 60.9 % et le pourcentage de mémoire utilisée par les conteneurs (MemoryUtilization) était de 9.36 %.

Les MME SageMaker fournissent également des métriques de chargement de modèle pour obtenir des informations au niveau de l'appel du modèle :

• ModèleLoadingWaitTime – Intervalle de temps pour le modèle à télécharger ou à charger
• ModèleUnloadingTime – Intervalle de temps pour décharger le modèle du conteneur
• ModèleDownloadingTime – Il est temps de télécharger le modèle depuis Amazon S3
• ModèleCacheHit – Nombre d'appels au modèle déjà chargés sur le conteneur

Dans le graphique suivant, nous pouvons observer qu'il a fallu 8.22 secondes à un modèle pour répondre à une requête d'inférence (ModelLatency), et 24.1 millisecondes ont été ajoutées à la latence de bout en bout en raison des surcharges de SageMaker (OverheadLatency). Nous pouvons également voir les métriques d'erreurs provenant des appels pour appeler un appel d'API de point de terminaison, telles que Invocation4XXErrors ainsi que le Invocation5XXErrors.

Pour plus d'informations sur les métriques MME CloudWatch, reportez-vous à Métriques CloudWatch pour les déploiements de points de terminaison multimodèles.

Résumé

Dans cet article, vous avez découvert la nouvelle prise en charge multimodèle de SageMaker pour GPU, qui vous permet d'héberger de manière rentable des centaines de modèles d'apprentissage profond sur du matériel de calcul accéléré. Vous avez appris à utiliser le serveur d'inférence NVIDIA Triton, qui crée une configuration de référentiel modèle pour différents backends de framework, et à déployer un MME avec mise à l'échelle automatique. Cette fonctionnalité vous permettra de mettre à l'échelle des centaines de modèles hyper-personnalisés, affinés pour répondre aux expériences uniques des utilisateurs finaux dans les applications d'IA. Vous pouvez également tirer parti de cette fonctionnalité pour obtenir les performances tarifaires nécessaires pour votre application d'inférence à l'aide de GPU fractionnaires.

Pour démarrer avec la prise en charge MME pour GPU, consultez Prise en charge des points de terminaison multimodèles pour GPU.

À propos des auteurs

Dhawal Patel est architecte principal en apprentissage machine chez AWS. Il a travaillé avec des organisations allant des grandes entreprises aux startups de taille moyenne sur des problèmes liés à l'informatique distribuée et à l'intelligence artificielle. Il se concentre sur l'apprentissage en profondeur, y compris les domaines de la PNL et de la vision par ordinateur. Il aide les clients à obtenir une inférence de modèle hautes performances sur Amazon SageMaker.

Vikram Elango est un architecte senior de solutions spécialisé en IA/ML chez Amazon Web Services, basé en Virginie, aux États-Unis. Vikram aide les clients mondiaux du secteur financier et de l'assurance en matière de conception, de mise en œuvre et de leadership éclairé pour créer et déployer des applications d'apprentissage automatique à grande échelle. Il se concentre actuellement sur le traitement du langage naturel, l'IA responsable, l'optimisation des inférences et la mise à l'échelle du ML dans l'ensemble de l'entreprise. Dans ses temps libres, il aime voyager, faire de la randonnée, cuisiner et camper avec sa famille.

Saurabh Trikandé est chef de produit senior pour Amazon SageMaker Inference. Il est passionné par le travail avec les clients et est motivé par l'objectif de démocratiser l'apprentissage automatique. Il se concentre sur les principaux défis liés au déploiement d'applications ML complexes, de modèles ML multi-locataires, d'optimisations de coûts et de rendre le déploiement de modèles d'apprentissage en profondeur plus accessible. Dans ses temps libres, Saurabh aime faire de la randonnée, découvrir des technologies innovantes, suivre TechCrunch et passer du temps avec sa famille.

Deepti Ragha est ingénieur en développement logiciel au sein de l'équipe Amazon SageMaker. Son travail actuel se concentre sur la création de fonctionnalités pour héberger efficacement des modèles d'apprentissage automatique. Dans ses temps libres, elle aime voyager, faire de la randonnée et cultiver des plantes.

Nikhil Kulkarni est un développeur de logiciels chez AWS Machine Learning, dont l'objectif est de rendre les charges de travail d'apprentissage automatique plus performantes sur le cloud et est co-créateur d'AWS Deep Learning Containers pour la formation et l'inférence. Il est passionné par les systèmes de Deep Learning distribués. En dehors du travail, il aime lire des livres, jouer de la guitare et préparer des pizzas.

Jia Hong Liu est architecte de solutions au sein de l'équipe Cloud Service Provider de NVIDIA. Il aide les clients à adopter des solutions d'apprentissage automatique et d'IA qui tirent parti de l'informatique accélérée de NVIDIA pour relever leurs défis de formation et d'inférence. Dans ses temps libres, il aime l'origami, les projets de bricolage et jouer au basket.

Eliuth Triana est responsable des relations avec les développeurs au sein de l'équipe NVIDIA-AWS. Il met en relation les chefs de produits, développeurs et scientifiques Amazon et AWS avec les technologues et chefs de produits NVIDIA pour accélérer les charges de travail Amazon ML/DL, les produits EC2 et les services AWS AI. De plus, Eliuth est un passionné de vélo de montagne, de ski et de poker.

Maximiliano Maccanti est ingénieur principal chez AWS actuellement chez DynamoDB, j'étais dans l'équipe de lancement de SageMaker à re:Invent 2017 et j'ai passé les 5 années suivantes dans la plateforme d'hébergement en ajoutant toutes sortes de fonctionnalités destinées aux clients. Pendant mon temps libre, je collectionne, répare et joue avec des consoles de jeux vidéo vintage.