Lors du déploiement de modèles de Deep Learning à grande échelle, il est essentiel d'utiliser efficacement le matériel sous-jacent pour optimiser les performances et les avantages en termes de coûts. Pour les charges de travail de production nécessitant un débit élevé et une faible latence, la sélection du Cloud de calcul élastique Amazon (EC2), la pile de service de modèle et l'architecture de déploiement sont très importantes. Une architecture inefficace peut conduire à une utilisation sous-optimale des accélérateurs et à des coûts de production inutilement élevés.
Dans cet article, nous vous expliquons le processus de déploiement des serveurs de modèles FastAPI sur les appareils AWS Inferentia (disponibles sur Amazon EC2 Inf1 et Amazon CE Inf2 instances). Nous démontrons également l'hébergement d'un exemple de modèle qui est déployé en parallèle sur tous les NeuronCores pour une utilisation maximale du matériel.
Vue d'ensemble de la solution
FastAPI est un framework Web open source pour servir les applications Python qui est beaucoup plus rapide que les frameworks traditionnels comme Flask et Django. Il utilise un Interface de passerelle de serveur asynchrone (ASGI) au lieu du très utilisé Interface de passerelle de serveur Web (WSGI). ASGI traite les demandes entrantes de manière asynchrone, contrairement à WSGI qui traite les demandes de manière séquentielle. Cela fait de FastAPI le choix idéal pour gérer les requêtes sensibles à la latence. Vous pouvez utiliser FastAPI pour déployer un serveur qui héberge un point de terminaison sur une instance Inferentia (Inf1/Inf2) qui écoute les demandes des clients via un port désigné.
Notre objectif est d'atteindre les meilleures performances au moindre coût grâce à une utilisation maximale du matériel. Cela nous permet de gérer plus de requêtes d'inférence avec moins d'accélérateurs. Chaque appareil AWS Inferentia1 contient quatre NeuronCores-v1 et chaque appareil AWS Inferentia2 contient deux NeuronCores-v2. Le Neurone AWS Le SDK nous permet d'utiliser chacun des NeuronCores en parallèle, ce qui nous donne plus de contrôle sur le chargement et la déduction de quatre modèles ou plus en parallèle sans sacrifier le débit.
Avec FastAPI, vous avez le choix du serveur Web Python (Gunicorn, Uvicorne, Hypercorne, Daphné). Ces serveurs Web fournissent une couche d'abstraction au-dessus du modèle d'apprentissage automatique (ML) sous-jacent. Le client demandeur a l'avantage d'être inconscient du modèle hébergé. Un client n'a pas besoin de connaître le nom ou la version du modèle qui a été déployé sous le serveur ; le nom du point de terminaison n'est plus qu'un proxy vers une fonction qui charge et exécute le modèle. En revanche, dans un outil de diffusion spécifique au framework, tel que TensorFlow Serving, le nom et la version du modèle font partie du nom du point de terminaison. Si le modèle change côté serveur, le client doit le savoir et modifier son appel d'API vers le nouveau point de terminaison en conséquence. Par conséquent, si vous faites évoluer en permanence les modèles de version, comme dans le cas des tests A/B, l'utilisation d'un serveur Web Python générique avec FastAPI est un moyen pratique de servir des modèles, car le nom du point de terminaison est statique.
Le rôle d'un serveur ASGI est de générer un nombre spécifié de travailleurs qui écoutent les demandes des clients et exécutent le code d'inférence. Une capacité importante du serveur est de s'assurer que le nombre demandé de travailleurs est disponible et actif. Dans le cas où un worker est tué, le serveur doit lancer un nouveau worker. Dans ce contexte, le serveur et les travailleurs peuvent être identifiés par leur ID de processus Unix (PID). Pour ce poste, nous utilisons un Hypercorne server, qui est un choix populaire pour les serveurs Web Python.
Dans cet article, nous partageons les meilleures pratiques pour déployer des modèles d'apprentissage en profondeur avec FastAPI sur AWS Inferentia NeuronCores. Nous montrons que vous pouvez déployer plusieurs modèles sur des NeuronCores distincts qui peuvent être appelés simultanément. Cette configuration augmente le débit car plusieurs modèles peuvent être déduits simultanément et l'utilisation de NeuronCore est entièrement optimisée. Le code se trouve sur le GitHub repo. La figure suivante montre l'architecture de configuration de la solution sur une instance EC2 Inf2.
La même architecture s'applique à un type d'instance EC2 Inf1, sauf qu'elle comporte quatre cœurs. Cela change donc un peu le schéma de l'architecture.
NeuronCores d'inférence AWS
Approfondissons un peu les outils fournis par AWS Neuron pour interagir avec les NeuronCores. Les tableaux suivants indiquent le nombre de NeuronCores dans chaque type d'instance Inf1 et Inf2. Les vCPU hôtes et la mémoire système sont partagés entre tous les NeuronCores disponibles.
Taille d'instance | # Accélérateurs Inferentia | # NeuronCores-v1 | vCPU | Mémoire (Gio) |
Inf1.xlarge | 1 | 4 | 4 | 8 |
Inf1.2xlarge | 1 | 4 | 8 | 16 |
Inf1.6xlarge | 4 | 16 | 24 | 48 |
Inf1.24xlarge | 16 | 64 | 96 | 192 |
Taille d'instance | # Accélérateurs Inferentia | # NeuronCores-v2 | vCPU | Mémoire (Gio) |
Inf2.xlarge | 1 | 2 | 4 | 32 |
Inf2.8xlarge | 1 | 2 | 32 | 32 |
Inf2.24xlarge | 6 | 12 | 96 | 192 |
Inf2.48xlarge | 12 | 24 | 192 | 384 |
Les instances Inf2 contiennent le nouveau NeuronCores-v2 par rapport au NeuronCore-v1 dans les instances Inf1. Malgré moins de cœurs, ils sont capables d'offrir un débit 4 fois plus élevé et une latence 10 fois plus faible que les instances Inf1. Les instances Inf2 sont idéales pour les charges de travail d'apprentissage en profondeur comme l'IA générative, les grands modèles de langage (LLM) dans la famille OPT/GPT et les transformateurs de vision comme Stable Diffusion.
Le Neuron Runtime est responsable de l'exécution des modèles sur les appareils Neuron. Neuron Runtime détermine quel NeuronCore exécutera quel modèle et comment l'exécuter. La configuration de Neuron Runtime est contrôlée par l'utilisation de Variables d'environnement au niveau du processus. Par défaut, les extensions de framework Neuron prendront en charge la configuration de Neuron Runtime au nom de l'utilisateur ; cependant, des configurations explicites sont également possibles pour obtenir un comportement plus optimisé.
Deux variables d'environnement populaires sont NEURON_RT_NUM_CORES
et de NEURON_RT_VISIBLE_CORES
. Avec ces variables d'environnement, les processus Python peuvent être liés à un NeuronCore. Avec NEURON_RT_NUM_CORES
, un nombre spécifié de cœurs peut être réservé pour un processus, et avec NEURON_RT_VISIBLE_CORES
, une gamme de NeuronCores peut être réservée. Par exemple, NEURON_RT_NUM_CORES=2 myapp.py
réservera deux cœurs et NEURON_RT_VISIBLE_CORES=’0-2’ myapp.py
réservera zéro, un et deux cœurs pour myapp.py
. Vous pouvez également réserver NeuronCores sur plusieurs appareils (puces AWS Inferentia). Donc, NEURON_RT_VISIBLE_CORES=’0-5’ myapp.py
réservera les quatre premiers cœurs sur device1
et un noyau sur device2
dans un type d'instance Ec2 Inf1. De même, sur un type d'instance EC2 Inf2, cette configuration réservera deux cœurs sur device1
et de device2
et un noyau sur device3
. Le tableau suivant résume la configuration de ces variables.
Nom | Description | Type | Valeurs attendues | Valeur par défaut | Version RT |
NEURON_RT_VISIBLE_CORES |
Gamme de NeuronCores spécifiques nécessaires au processus | Plage d'entiers (comme 1-3) | Toute valeur ou plage entre 0 et Max NeuronCore dans le système | Aucun | 2.0+ |
NEURON_RT_NUM_CORES |
Nombre de NeuronCores requis par le processus | Entier | Une valeur de 1 à Max NeuronCore dans le système | 0, qui est interprété comme "tout" | 2.0+ |
Pour une liste de toutes les variables d'environnement, reportez-vous à Configuration de l'environnement d'exécution des neurones.
Par défaut, lors du chargement de modèles, les modèles sont chargés sur NeuronCore 0, puis sur NeuronCore 1, sauf indication explicite par les variables d'environnement précédentes. Comme indiqué précédemment, les NeuronCores partagent les vCPU hôtes disponibles et la mémoire système. Par conséquent, les modèles déployés sur chaque NeuronCore seront en concurrence pour les ressources disponibles. Ce ne sera pas un problème si le modèle utilise les NeuronCores dans une large mesure. Mais si un modèle ne s'exécute qu'en partie sur les NeuronCore et le reste sur les vCPU hôtes, il est important de prendre en compte la disponibilité du CPU par NeuronCore. Cela affecte également le choix de l'instance.
Le tableau suivant indique le nombre de vCPU hôtes et la mémoire système disponible par modèle si un modèle a été déployé sur chaque NeuronCore. En fonction de l'utilisation de NeuronCore, du vCPU et de l'utilisation de la mémoire de votre application, il est recommandé d'exécuter des tests pour déterminer quelle configuration est la plus performante pour votre application. Le Outil Neuron Top peut aider à visualiser l'utilisation du cœur et l'utilisation de la mémoire de l'appareil et de l'hôte. Sur la base de ces mesures, une décision éclairée peut être prise. Nous démontrons l'utilisation de Neuron Top à la fin de ce blog.
Taille d'instance | # Accélérateurs Inferentia | # Des modèles | vCPU/Modèle | Mémoire/Modèle (Gio) |
Inf1.xlarge | 1 | 4 | 1 | 2 |
Inf1.2xlarge | 1 | 4 | 2 | 4 |
Inf1.6xlarge | 4 | 16 | 1.5 | 3 |
Inf1.24xlarge | 16 | 64 | 1.5 | 3 |
Taille d'instance | # Accélérateurs Inferentia | # Des modèles | vCPU/Modèle | Mémoire/Modèle (Gio) |
Inf2.xlarge | 1 | 2 | 2 | 8 |
Inf2.8xlarge | 1 | 2 | 16 | 64 |
Inf2.24xlarge | 6 | 12 | 8 | 32 |
Inf2.48xlarge | 12 | 24 | 8 | 32 |
Pour tester vous-même les fonctionnalités du SDK Neuron, consultez la dernière Capacités neuronales pour PyTorch.
Installation du système
Voici la configuration système utilisée pour cette solution :
Configurer la solution
Il y a quelques choses que nous devons faire pour configurer la solution. Commencez par créer un rôle IAM que votre instance EC2 va assumer et qui lui permettra de pousser et de tirer de Registre des conteneurs élastiques Amazon.
Étape 1 : Configurer le rôle IAM
- Commencez par vous connecter à la console et accédez à IAM > Rôles > Créer un rôle
- Sélectionnez le type d'entité de confiance
AWS Service
- Sélectionnez EC2 comme service dans le cas d'utilisation
- Cliquez Suivant et vous pourrez voir toutes les politiques disponibles
- Dans le cadre de cette solution, nous allons donner à notre instance EC2 un accès complet à ECR. Filtrer pour AmazonEC2ContainerRegistryFullAccess et sélectionnez-le.
- Appuyez sur suivant et nommez le rôle
inf-ecr-access
Remarque : la politique que nous avons attachée donne à l'instance EC2 un accès complet à Amazon ECR. Nous vous recommandons fortement de suivre les principe du moindre privilège pour les charges de travail de production.
Étape 2 : Configuration de l'AWS CLI
Si vous utilisez l'AMI Deep Learning prescrite répertoriée ci-dessus, elle est fournie avec l'AWS CLI installée. Si vous utilisez une autre AMI (Amazon Linux 2023, Base Ubuntu, etc.), installez les outils CLI en suivant .
Une fois les outils CLI installés, configurez la CLI à l'aide de la commande aws configure
. Si vous disposez de clés d'accès, vous pouvez les ajouter ici, mais vous n'en avez pas nécessairement besoin pour interagir avec les services AWS. Nous nous appuyons sur les rôles IAM pour ce faire.
Notes: Nous devons entrer au moins une valeur (région par défaut ou format par défaut) pour créer le profil par défaut. Pour cet exemple, nous allons avec us-east-2
que la région et json
comme sortie par défaut.
Cloner le dépôt Github
La GitHub repo fournit tous les scripts nécessaires pour déployer des modèles à l'aide de FastAPI sur NeuronCores sur des instances AWS Inferentia. Cet exemple utilise des conteneurs Docker pour s'assurer que nous pouvons créer des solutions réutilisables. Inclus dans cet exemple est le suivant config.propriétés fichier permettant aux utilisateurs de fournir des entrées.
Le fichier de configuration nécessite des préfixes de nom définis par l'utilisateur pour l'image Docker et les conteneurs Docker. Le build.sh
script dans le fastapi
et de trace-model
les dossiers l'utilisent pour créer des images Docker.
Compiler un modèle sur AWS Inferentia
Nous allons commencer par tracer le modèle et produire un fichier PyTorch Torchscript .pt. Commencez par accéder trace-model
répertoire et en modifiant le fichier .env. Selon le type d'instance que vous avez choisi, modifiez le CHIP_TYPE
au sein du .env
déposer. A titre d'exemple, nous choisirons Inf2 comme guide. Les mêmes étapes s'appliquent au processus de déploiement pour Inf1.
Définissez ensuite la région par défaut dans le même fichier. Cette région sera utilisée pour créer un référentiel ECR et les images Docker seront poussées vers ce référentiel. Toujours dans ce dossier, nous fournissons tous les scripts nécessaires pour tracer un bert-base-uncased
modèle sur AWS Inferentia. Ce script pourrait être utilisé pour la plupart des modèles disponibles sur Étreindre le visageL’ Dockerfile a toutes les dépendances pour exécuter des modèles avec Neuron et exécute le trace-model.py code comme point d'entrée.
Compilation de neurones expliquée
L'API du SDK Neuron ressemble étroitement à l'API Python PyTorch. Le torch.jit.trace()
de PyTorch prend le modèle et l'échantillon de tenseur d'entrée comme arguments. Les exemples d'entrées sont transmis au modèle et les opérations qui sont invoquées lorsque cette entrée se fraye un chemin à travers les couches du modèle sont enregistrées comme TorchScript. Pour en savoir plus sur JIT Tracing dans PyTorch, reportez-vous à ce qui suit Documentation.
Tout comme torch.jit.trace()
, vous pouvez vérifier si votre modèle peut être compilé sur AWS Inferentia avec le code suivant pour les instances inf1.
Pour inf2, la bibliothèque s'appelle torch_neuronx
. Voici comment tester la compilation de votre modèle par rapport aux instances inf2.
Après avoir créé l'instance de trace, nous pouvons transmettre l'exemple d'entrée de tenseur comme suit :
Et enfin, enregistrez la sortie TorchScript résultante sur le disque local
Comme indiqué dans le code précédent, vous pouvez utiliser compiler_args
et de optimizations
pour optimiser le déploiement. Pour une liste détaillée des arguments en faveur de la torch.neuron.trace
API, reportez-vous à API Python de trace PyTorch-Neuron.
Gardez à l'esprit les points importants suivants :
- Le SDK Neuron ne prend pas en charge les formes de tenseurs dynamiques à ce jour. Par conséquent, un modèle devra être compilé séparément pour différentes formes d'entrée. Pour plus d'informations sur l'exécution de l'inférence sur des formes d'entrée variables avec compartimentage, reportez-vous à Exécution d'une inférence sur des formes d'entrée variables avec compartimentage.
- Si vous rencontrez des problèmes de mémoire insuffisante lors de la compilation d'un modèle, essayez de compiler le modèle sur une instance AWS Inferentia avec plus de vCPU ou de mémoire, ou même une grande instance c6i ou r6i car la compilation n'utilise que des CPU. Une fois compilé, le modèle tracé peut probablement être exécuté sur des tailles d'instance AWS Inferentia plus petites.
Explication du processus de construction
Nous allons maintenant construire ce conteneur en exécutant build.sh. Le fichier de script de génération crée simplement l'image Docker en extrayant une image de conteneur d'apprentissage profond de base et en installant le HuggingFace transformers
emballer. Basé sur CHIP_TYPE
spécifié dans le .env
fichier, le docker.properties
dossier décide le cas échéant BASE_IMAGE
. Ce BASE_IMAGE
pointe vers une image de conteneur d'apprentissage en profondeur pour Neuron Runtime fournie par AWS.
Il est disponible via un référentiel ECR privé. Avant de pouvoir extraire l'image, nous devons nous connecter et obtenir des informations d'identification AWS temporaires.
Notes: nous devons remplacer la région répertoriée dans la commande spécifiée par l'indicateur de région et dans l'URI du référentiel par la région que nous mettons dans le .env fichier.
Afin de faciliter ce processus, nous pouvons utiliser le fetch-credentials.sh
déposer. La région sera extraite automatiquement du fichier .env.
Ensuite, nous allons pousser l'image en utilisant le script push.sh. Le script push crée un référentiel dans Amazon ECR pour vous et envoie l'image du conteneur.
Enfin, lorsque l'image est construite et poussée, nous pouvons l'exécuter en tant que conteneur en exécutant courir.sh et la queue en cours d'exécution des journaux avec journaux.sh. Dans les journaux du compilateur (voir la capture d'écran suivante), vous verrez le pourcentage d'opérateurs arithmétiques compilés sur Neuron et le pourcentage de sous-graphes de modèles compilés avec succès sur Neuron. La capture d'écran montre les journaux du compilateur pour le bert-base-uncased-squad2
modèle. Les journaux montrent que 95.64 % des opérateurs arithmétiques ont été compilés, et ils donnent également une liste des opérateurs qui ont été compilés sur Neuron et ceux qui ne sont pas pris en charge.
Voici une liste de tous les opérateurs pris en charge dans le dernier package PyTorch Neuron. De la même manière, voici la liste de tous les opérateurs pris en charge dans le dernier package PyTorch Neuronx.
Déployer des modèles avec FastAPI
Une fois les modèles compilés, le modèle tracé sera présent dans le trace-model
dossier. Dans cet exemple, nous avons placé le modèle tracé pour une taille de lot de 1. Nous considérons ici une taille de lot de 1 pour tenir compte des cas d'utilisation où une taille de lot plus élevée n'est pas possible ou requise. Pour les cas d'utilisation où des tailles de lot plus élevées sont nécessaires, le torche.neuron.DataParallel (pour Inf1) ou torche.neuronx.DataParallel (pour Inf2) L'API peut également être utile.
La API rapide Le dossier fournit tous les scripts nécessaires pour déployer des modèles avec FastAPI. Pour déployer les modèles sans aucune modification, exécutez simplement le déployer.sh script et il créera une image de conteneur FastAPI, exécutera des conteneurs sur le nombre spécifié de cœurs et déploiera le nombre spécifié de modèles par serveur dans chaque serveur de modèles FastAPI. Ce dossier contient également un .env
fichier, modifiez-le pour refléter le bon CHIP_TYPE
et de AWS_DEFAULT_REGION
.
Notes: Les scripts FastAPI s'appuient sur les mêmes variables d'environnement que celles utilisées pour créer, pousser et exécuter les images en tant que conteneurs. Les scripts de déploiement FastAPI utiliseront les dernières valeurs connues de ces variables. Ainsi, si vous avez tracé le modèle pour le type d'instance Inf1 en dernier, ce modèle sera déployé via ces scripts.
La fastapi-server.py responsable de l'hébergement du serveur et de l'envoi des requêtes au modèle effectue les opérations suivantes :
- Lit le nombre de modèles par serveur et l'emplacement du modèle compilé à partir du fichier de propriétés
- Définit les NeuronCores visibles comme variables d'environnement dans le conteneur Docker et lit les variables d'environnement pour spécifier les NeuronCores à utiliser
- Fournit une API d'inférence pour
bert-base-uncased-squad2
modèle - Avec
jit.load()
, charge le nombre de modèles par serveur comme spécifié dans la configuration et stocke les modèles et les tokenizers requis dans des dictionnaires globaux
Avec cette configuration, il serait relativement facile de configurer des API qui répertorient les modèles et le nombre de modèles stockés dans chaque NeuronCore. De même, des API pourraient être écrites pour supprimer des modèles de NeuronCores spécifiques.
La Dockerfile pour la construction de conteneurs FastAPI est construit sur l'image Docker que nous avons construite pour tracer les modèles. C'est pourquoi le docker.propriétés Le fichier spécifie le chemin ECR vers l'image Docker pour tracer les modèles. Dans notre configuration, les conteneurs Docker de tous les NeuronCores sont similaires, nous pouvons donc créer une image et exécuter plusieurs conteneurs à partir d'une seule image. Pour éviter toute erreur de point d'entrée, nous spécifions ENTRYPOINT ["/usr/bin/env"]
dans le Dockerfile avant d'exécuter le startup.sh
script, qui ressemble à hypercorn fastapi-server:app -b 0.0.0.0:8080
. Ce script de démarrage est le même pour tous les conteneurs. Si vous utilisez la même image de base que pour les modèles de suivi, vous pouvez créer ce conteneur en exécutant simplement le script build.sh. Le push.sh
script reste le même qu'avant pour les modèles de traçage. L'image Docker modifiée et le nom du conteneur sont fournis par le docker.properties
fichier.
La run.sh file
fait ce qui suit:
- Lit l'image Docker et le nom du conteneur à partir du propriétés fichier, qui à son tour lit le
config.properties
fichier, qui a unnum_cores
paramètre d'utilisateur - Démarre une boucle de 0 à
num_cores
et pour chaque noyau :- Définit le numéro de port et le numéro de périphérique
- Définit le
NEURON_RT_VISIBLE_CORES
variable d'environnement - Spécifie le montage du volume
- Exécute un conteneur Docker
Pour plus de clarté, la commande Docker run pour le déploiement dans NeuronCore 0 pour Inf1 ressemblerait au code suivant :
La commande run pour le déploiement dans NeuronCore 5 ressemblerait au code suivant :
Une fois les conteneurs déployés, nous utilisons le run_apis.py script, qui appelle les API dans des threads parallèles. Le code est configuré pour appeler six modèles déployés, un sur chaque NeuronCore, mais peut être facilement modifié pour un paramètre différent. Nous appelons les API du côté client comme suit :
Surveiller NeuronCore
Une fois les serveurs modèles déployés, pour surveiller l'utilisation de NeuronCore, nous pouvons utiliser neuron-top
pour observer en temps réel le pourcentage d'utilisation de chaque NeuronCore. sommet des neurones est un outil CLI dans le SDK Neuron pour fournir des informations telles que NeuronCore, vCPU et l'utilisation de la mémoire. Dans un terminal séparé, saisissez la commande suivante :
Votre sortie doit ressembler à la figure suivante. Dans ce scénario, nous avons spécifié d'utiliser deux NeuronCore et deux modèles par serveur sur une instance Inf2.xlarge. La capture d'écran suivante montre que deux modèles de taille 287.8 Mo chacun sont chargés sur deux NeuronCores. Avec un total de 4 modèles chargés, vous pouvez voir que la mémoire de l'appareil utilisée est de 1.3 Go. Utilisez les touches fléchées pour vous déplacer entre les NeuronCores sur différents appareils
De même, sur un type d'instance Inf1.16xlarge, nous voyons un total de 12 modèles (2 modèles par cœur sur 6 cœurs) chargés. Une mémoire totale de 2.1 Go est consommée et chaque modèle a une taille de 177.2 Mo.
Après avoir exécuté le run_apis.py script, vous pouvez voir le pourcentage d'utilisation de chacun des six NeuronCores (voir la capture d'écran suivante). Vous pouvez également voir l'utilisation du vCPU système et l'utilisation du vCPU d'exécution.
La capture d'écran suivante montre le pourcentage d'utilisation du cœur de l'instance Inf2.
De même, cette capture d'écran montre l'utilisation du cœur dans un type d'instance inf1.6xlarge.
Nettoyer
Pour nettoyer tous les conteneurs Docker que vous avez créés, nous fournissons un nettoyage.sh script qui supprime tous les conteneurs en cours d'exécution et arrêtés. Ce script supprimera tous les conteneurs, ne l'utilisez donc pas si vous souhaitez que certains conteneurs continuent de fonctionner.
Conclusion
Les charges de travail de production ont souvent un débit élevé, une faible latence et des exigences de coût. Les architectures inefficaces qui utilisent les accélérateurs de manière sous-optimale pourraient entraîner des coûts de production inutilement élevés. Dans cet article, nous avons montré comment utiliser de manière optimale NeuronCores avec FastAPI pour maximiser le débit avec une latence minimale. Nous avons publié les instructions sur notre GitHub repo. Avec cette architecture de solution, vous pouvez déployer plusieurs modèles dans chaque NeuronCore et faire fonctionner plusieurs modèles en parallèle sur différents NeuronCore sans perte de performances. Pour plus d'informations sur le déploiement de modèles à grande échelle avec des services tels que Service Amazon Elastic Kubernetes (Amazon EKS), reportez-vous à Servez 3,000 50 modèles d'apprentissage en profondeur sur Amazon EKS avec AWS Inferentia pour moins de XNUMX $ de l'heure.
À propos des auteurs
Ankur Srivastava est un architecte de solutions senior dans l'équipe ML Frameworks. Il se concentre sur l'aide aux clients avec une formation distribuée autogérée et une inférence à grande échelle sur AWS. Son expérience comprend la maintenance prédictive industrielle, les jumeaux numériques, l'optimisation de la conception probabiliste et a terminé ses études doctorales en génie mécanique à l'Université Rice et ses recherches postdoctorales au Massachusetts Institute of Technology.
KC Tung est architecte de solutions senior chez AWS Annapurna Labs. Il est spécialisé dans la formation et le déploiement de grands modèles d'apprentissage en profondeur à grande échelle dans le cloud. Il a un doctorat. en biophysique moléculaire de l'Université du Texas Southwestern Medical Center à Dallas. Il a pris la parole lors d'AWS Summits et d'AWS Reinvent. Aujourd'hui, il aide les clients à former et à déployer de grands modèles PyTorch et TensorFlow dans le cloud AWS. Il est l'auteur de deux livres : Apprendre TensorFlow Enterprise et de Référence de poche TensorFlow 2.
Pronoy Chopra est architecte de solutions senior au sein de l'équipe Startups Generative AI chez AWS. Il est spécialisé dans l'architecture et le développement de solutions IoT et Machine Learning. Il a cofondé deux startups dans le passé et aime participer à des projets dans le domaine de l'IoT, de l'IA/ML et du Serverless.
- Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
- PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
- PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
- PlatonESG. Automobile / VE, Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
- Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
- La source: https://aws.amazon.com/blogs/machine-learning/optimize-aws-inferentia-utilization-with-fastapi-and-pytorch-models-on-amazon-ec2-inf1-inf2-instances/
- :possède
- :est
- :ne pas
- :où
- $UP
- 000
- 1
- 1.3
- 10
- 100
- 12
- 13
- 15%
- 2023
- 7
- 8
- 91
- a
- Capable
- A Propos
- au dessus de
- abstraction
- accélérateurs
- accès
- accès
- en conséquence
- Compte
- atteindre
- à travers
- infection
- ajouter
- à opposer à
- AI
- AI / ML
- Tous
- permettre
- permet
- aussi
- Amazon
- Amazon EC2
- Amazon Web Services
- an
- et de
- tous
- api
- Apis
- appli
- Application
- applications
- Appliquer
- approprié
- architecture
- SONT
- arguments
- AS
- assumer
- At
- auteur
- automatiquement
- disponibilité
- disponibles
- éviter
- AWS
- Inférence AWS
- base
- basé
- BE
- car
- devenez
- était
- before
- nom
- humain
- va
- profiter
- avantages.
- LES MEILLEURS
- les meilleures pratiques
- jusqu'à XNUMX fois
- Biophysique
- Bit
- Blog
- Livres
- construire
- Développement
- construit
- mais
- by
- Appelez-nous
- appelé
- Appels
- CAN
- capacités
- aptitude
- les soins
- maisons
- cas
- Canaux centraux
- Change
- modifié
- Modifications
- vérifier
- chips
- le choix
- Selectionnez
- choisir
- clarté
- client
- étroitement
- le cloud
- code
- vient
- Comparaison
- rivaliser
- Complété
- calcul
- configuration
- Considérer
- considérant
- Console
- consommées
- contiennent
- Contenant
- Conteneurs
- contient
- contexte
- continuellement
- contraste
- des bactéries
- contrôlée
- Pratique
- Core
- correct
- Prix
- Costs
- pourriez
- Couples
- engendrent
- créée
- crée des
- La création
- Lettres de créance
- crucial
- Clients
- Dallas
- décision
- profond
- l'apprentissage en profondeur
- profond
- Réglage par défaut
- démontrer
- Selon
- déployer
- déployé
- déployer
- déploiement
- Conception
- désigné
- Malgré
- détaillé
- détermine
- développement
- dispositif
- Compatibles
- différent
- La diffusion
- DIG
- numérique
- Jumeaux numériques
- distribué
- formation distribuée
- Django
- do
- Docker
- Ne fait pas
- domaine
- Ne pas
- Dynamic
- chacun
- Plus tôt
- plus facilement
- même
- Easy
- EC
- de manière efficace
- fin
- Endpoint
- s'engager
- ENGINEERING
- assurer
- Entrer
- entité
- entrée
- Environment
- Erreurs
- etc
- Pourtant, la
- Chaque
- évolution
- exemple
- Sauf
- d'experience
- extensions
- Visage
- famille
- plus rapide
- réalisable
- Fonctionnalités:
- Fed
- moins
- Figure
- Déposez votre dernière attestation
- une fonction filtre
- finalement
- Trouvez
- Prénom
- se concentre
- Abonnement
- suit
- Pour
- le format
- trouvé
- quatre
- Framework
- cadres
- De
- plein
- d’étiquettes électroniques entièrement
- fonction
- porte
- génératif
- IA générative
- obtenez
- GitHub
- Donner
- donne
- Global
- aller
- guide
- manipuler
- hands-on
- Matériel
- Vous avez
- he
- aider
- aider
- aide
- ici
- Haute
- augmentation
- le plus élevé
- sa
- hôte
- organisé
- hébergement
- hôtes
- Comment
- How To
- Cependant
- HTML
- http
- HTTPS
- Étreindre
- ID
- idéal
- identifié
- if
- image
- satellite
- importer
- important
- in
- inclus
- inclut
- Nouveau
- Augmente
- industriel
- inefficace
- d'information
- Actualités
- contribution
- entrées
- installer
- Installé
- installer
- instance
- plutôt ;
- Institut
- Des instructions
- interagir
- développement
- invoqué
- IOT
- aide
- vous aider à faire face aux problèmes qui vous perturbent
- IT
- SES
- JIT
- jpg
- juste
- XNUMX éléments à
- clés
- Savoir
- connu
- Labs
- langue
- gros
- Nom
- Latence
- Nouveautés
- lancer
- couche
- poules pondeuses
- conduire
- APPRENTISSAGE
- apprentissage
- Niveau
- Bibliothèque
- comme
- linux
- Liste
- Listé
- peu
- un peu plus profond
- LLM
- chargement
- charges
- locales
- emplacement
- enregistrement
- vous connecter
- Style
- ressembler
- LOOKS
- pas à perdre
- Faible
- baisser
- le plus bas
- click
- machine learning
- LES PLANTES
- facile
- a prendre une
- FAIT DU
- Fabrication
- de nombreuses
- Massachusetts
- Massachusetts Institute of Technology
- max
- Maximisez
- maximales
- Mai..
- mécanique
- médical
- Mémoire
- Métrique
- l'esprit
- minimum
- ML
- modèle
- numériques jumeaux (digital twin models)
- modifié
- modifier
- moléculaire
- Surveiller
- PLUS
- (en fait, presque toutes)
- Bougez
- beaucoup
- plusieurs
- must
- prénom
- nécessairement
- nécessaire
- Besoin
- nécessaire
- Besoins
- Nouveauté
- next
- maintenant
- nombre
- objectif
- observer
- of
- code
- souvent
- on
- une fois
- ONE
- uniquement
- sur
- open source
- fonctionner
- Opérations
- opérateurs
- opposé
- à mettre en œuvre pour gérer une entreprise rentable. Ce guide est basé sur trois décennies d'expérience
- Optimiser
- optimisé
- or
- nos
- ande
- sortie
- plus de
- paquet
- Parallèle
- partie
- pass
- passé
- chemin
- /
- pourcentage
- performant
- Platon
- Intelligence des données Platon
- PlatonDonnées
- Point
- des notes bonus
- politiques
- politique
- Populaire
- possible
- Post
- pratiques
- représentent
- Privé
- Probablement
- processus
- les process
- produire
- Vidéo
- Profil
- projets
- propriétés
- fournir
- à condition de
- fournit
- procuration
- publié
- tirant
- but
- Push
- Poussé
- pousse
- mettre
- Python
- pytorch
- gamme
- réal
- en temps réel
- recommander
- recommandé
- enregistré
- refléter
- région
- relativement
- compter
- s'appuyer
- reste
- supprimez
- remplacer
- dépôt
- demandes
- conditions
- Exigences
- un article
- Ressemble
- Réserver
- réservé
- Resources
- réponse
- responsables
- REST
- résultant
- réutilisable
- Riz
- Rôle
- rôle
- Courir
- pour le running
- fonctionne
- sacrifier
- même
- Épargnez
- Escaliers intérieurs
- scénario
- scripts
- Sdk
- sur le lien
- sélection
- envoi
- supérieur
- sensible
- séparé
- Sans serveur
- Serveurs
- service
- Services
- service
- set
- mise
- installation
- formes
- Partager
- commun
- devrait
- montrer
- montré
- montré
- Spectacles
- côté
- similaires
- De même
- simplement
- SIX
- Taille
- tailles
- faibles
- So
- sur mesure
- Solutions
- quelques
- spécialise
- groupe de neurones
- spécifié
- parlé
- stable
- empiler
- Commencer
- Commencez
- Startups
- A déclaré
- Étapes
- arrêté
- stockée
- STORES
- fortement
- études
- Avec succès
- tel
- Sommets
- Support
- Appareils
- sûr
- combustion propre
- table
- Prenez
- tâches
- prend
- équipe
- Technologie
- temporaire
- tensorflow
- terminal
- tester
- Essais
- tests
- Texas
- que
- qui
- La
- leur
- Les
- puis
- donc
- Ces
- l'ont
- des choses
- this
- ceux
- Avec
- débit
- Attaché
- fiable
- à
- aujourd'hui
- outil
- les outils
- top
- torche
- Total
- Tracer
- Traçant
- traditionnel
- Train
- Formation
- transformateurs
- confiance
- Essai
- TOUR
- Jumeaux
- deux
- type
- Ubuntu
- sous
- sous-jacent
- université
- unix
- inutilement
- sur
- us
- Utilisation
- utilisé
- d'utiliser
- Utilisateur
- utilisateurs
- Usages
- en utilisant
- utiliser
- utilise
- Utilisant
- Plus-value
- Valeurs
- version
- très
- visible
- vision
- le volume
- souhaitez
- était
- Façon..
- we
- web
- le serveur web
- services Web
- WELL
- ont été
- quand
- qui
- why
- largement
- sera
- comprenant
- dans les
- sans
- travailleur
- ouvriers
- pourra
- écriture
- code écrit
- Vous n'avez
- Votre
- vous-même
- zéphyrnet
- zéro