L'instance Amazon EC2 DL2q pour une inférence d'IA rentable et hautes performances est désormais généralement disponible | Services Web Amazon

Il s'agit d'un article invité d'AK Roy de Qualcomm AI.

Cloud Amazon Elastic Compute (Amazon EC2) Les instances DL2q, optimisées par les accélérateurs Qualcomm AI 100 Standard, peuvent être utilisées pour déployer de manière rentable des charges de travail de deep learning (DL) dans le cloud. Ils peuvent également être utilisés pour développer et valider les performances et la précision des charges de travail DL qui seront déployées sur les appareils Qualcomm. Les instances DL2q sont les premières à intégrer la technologie d'intelligence artificielle (IA) de Qualcomm dans le cloud.

Avec huit accélérateurs Qualcomm AI 100 Standard et 128 Go de mémoire d'accélérateur totale, les clients peuvent également utiliser les instances DL2q pour exécuter des applications d'IA générative populaires, telles que la génération de contenu, la synthèse de texte et les assistants virtuels, ainsi que des applications d'IA classiques pour le traitement du langage naturel. et la vision par ordinateur. De plus, les accélérateurs Qualcomm AI 100 disposent de la même technologie d'IA que celle utilisée sur les smartphones, la conduite autonome, les ordinateurs personnels et les casques de réalité étendue, de sorte que les instances DL2q peuvent être utilisées pour développer et valider ces charges de travail d'IA avant le déploiement.

Points forts de la nouvelle instance DL2q

Chaque instance DL2q intègre huit accélérateurs Qualcomm Cloud AI100, avec des performances cumulées de plus de 2.8 PetaOps de performances d'inférence Int8 et de 1.4 PetaFlops de performances d'inférence FP16. L'instance dispose d'un total de 112 cœurs d'IA, d'une capacité de mémoire d'accélérateur de 128 Go et d'une bande passante mémoire de 1.1 To par seconde.

Chaque instance DL2q dispose de 96 vCPU, d'une capacité de mémoire système de 768 Go et prend en charge une bande passante réseau de 100 Gbit/s ainsi que Magasin de blocs Amazon Elastic (Amazon EBS) stockage de 19 Gbit/s.

Innovation de l'accélérateur Qualcomm Cloud AI100

Le système sur puce (SoC) accélérateur Cloud AI100 est une architecture multicœur spécialement conçue et évolutive, prenant en charge un large éventail de cas d'utilisation d'apprentissage en profondeur, du centre de données à la périphérie. Le SoC utilise des cœurs de calcul scalaires, vectoriels et tensoriels avec une capacité SRAM sur puce de pointe de 126 Mo. Les cœurs sont interconnectés avec un maillage de réseau sur puce (NoC) à large bande passante et à faible latence.

L'accélérateur AI100 prend en charge une gamme large et complète de modèles et de cas d'utilisation. Le tableau ci-dessous met en évidence la gamme de modèles pris en charge.

* La plupart des réseaux automobiles sont des réseaux composites constitués d'une fusion de réseaux individuels.

La grande SRAM intégrée à l'accélérateur DL2q permet une mise en œuvre efficace de techniques de performances avancées telles que la précision du micro-exposant MX6 pour le stockage des poids et la précision du micro-exposant MX9 pour la communication d'accélérateur à accélérateur. La technologie des micro-exposants est décrite dans l'annonce suivante de l'industrie de l'Open Compute Project (OCP) : AMD, Arm, Intel, Meta, Microsoft, NVIDIA et Qualcomm standardisent les formats de données de précision étroite de nouvelle génération pour l'IA » Open Compute Project.

L'utilisateur de l'instance peut utiliser la stratégie suivante pour maximiser les performances par coût :

• Stockez les poids en utilisant la précision du micro-exposant MX6 dans la mémoire DDR sur accélérateur. L'utilisation de la précision MX6 maximise l'utilisation de la capacité de mémoire disponible et de la bande passante mémoire pour offrir un débit et une latence de premier ordre.
• Calculez dans FP16 pour fournir la précision de cas d'utilisation requise, tout en utilisant la SRAM supérieure sur puce et les TOP de rechange sur la carte, pour implémenter des noyaux MX6 à faible latence hautes performances vers FP16.
• Utilisez une stratégie de traitement par lots optimisée et une taille de lot plus élevée en utilisant la grande SRAM sur puce disponible pour maximiser la réutilisation des poids, tout en conservant les activations sur puce au maximum possible.

Pile IA et chaîne d'outils DL2q

L'instance DL2q est accompagnée de Qualcomm AI Stack qui offre une expérience de développeur cohérente sur Qualcomm AI dans le cloud et d'autres produits Qualcomm. La même pile d'IA Qualcomm et la même technologie d'IA de base s'exécutent sur les instances DL2q et les appareils Qualcomm Edge, offrant aux clients une expérience de développement cohérente, avec une API unifiée dans leurs environnements de développement cloud, automobile, ordinateur personnel, réalité étendue et smartphone.

La chaîne d'outils permet à l'utilisateur de l'instance d'intégrer rapidement un modèle préalablement formé, de compiler et d'optimiser le modèle pour les fonctionnalités de l'instance, puis de déployer les modèles compilés pour les cas d'utilisation d'inférence de production en trois étapes illustrées dans la figure suivante.

Pour en savoir plus sur le réglage des performances d'un modèle, consultez le Paramètres de performances clés de Cloud AI 100 Documentation.

Premiers pas avec les instances DL2q

Dans cet exemple, vous compilez et déployez un Modèle BERT De Étreindre le visage sur une instance EC2 DL2q à l'aide d'une AMI DL2q disponible prédéfinie, en quatre étapes.

Vous pouvez utiliser soit un pré-construit Qualcomm DLAMI sur l'instance ou commencez avec une AMI Amazon Linux2 et créez votre propre AMI DL2q avec le SDK Cloud AI 100 Platform and Apps disponible dans ce Service de stockage simple Amazon (Amazon S3) seau: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

Les étapes qui suivent utilisent l'AMI DL2q prédéfinie, Qualcomm Base AL2 DLAMI.

Utilisez SSH pour accéder à votre instance DL2q avec l'AMI Qualcomm Base AL2 DLAMI et suivez les étapes 1 à 4.

Étape 1. Configurez l'environnement et installez les packages requis

1. Installez Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configurez l'environnement virtuel Python 3.8.

   python3.8 -m venv /home/ec2-user/userA/pyenv

3. Activez l'environnement virtuel Python 3.8.

   source /home/ec2-user/userA/pyenv/bin/activate

4. Installez les packages requis, indiqués dans le document exigences.txt disponible sur le site Github public de Qualcomm.

   pip3 install -r requirements.txt

5. Importez les bibliothèques nécessaires.

   import transformers 
   from transformers import AutoTokenizer, AutoModelForMaskedLM
   import sys
   import qaic
   import os
   import torch
   import onnx
   from onnxsim import simplify
   import argparse
   import numpy as np

Étape 2. Importez le modèle

1. Importez et tokenisez le modèle.

   model_card = 'bert-base-cased'
   model = AutoModelForMaskedLM.from_pretrained(model_card)
   tokenizer = AutoTokenizer.from_pretrained(model_card)

2. Définir un exemple d'entrée et extraire le inputIds ainsi que attentionMask.

   sentence = "The dog [MASK] on the mat."
   encodings = tokenizer(sentence, max_length=128, truncation=True, padding="max_length", return_tensors='pt')
   inputIds = encodings["input_ids"]
   attentionMask = encodings["attention_mask"]

3. Convertissez le modèle en ONNX, qui peut ensuite être transmis au compilateur.

   # Set dynamic dims and axes.
   dynamic_dims = {0: 'batch', 1 : 'sequence'}
   dynamic_axes = {
       "input_ids" : dynamic_dims,
       "attention_mask" : dynamic_dims,
       "logits" : dynamic_dims
   }
   input_names = ["input_ids", "attention_mask"]
   inputList = [inputIds, attentionMask]
   
   torch.onnx.export(
       model,
       args=tuple(inputList),
       f=f"{gen_models_path}/{model_base_name}.onnx",
       verbose=False,
       input_names=input_names,
       output_names=["logits"],
       dynamic_axes=dynamic_axes,
       opset_version=11,
   )

4. Vous exécuterez le modèle avec la précision FP16. Vous devez donc vérifier si le modèle contient des constantes au-delà de la plage FP16. Transmettez le modèle au fix_onnx_fp16 fonction pour générer le nouveau fichier ONNX avec les correctifs requis.

   from onnx import numpy_helper
           
   def fix_onnx_fp16(
       gen_models_path: str,
       model_base_name: str,
   ) -> str:
       finfo = np.finfo(np.float16)
       fp16_max = finfo.max
       fp16_min = finfo.min
       model = onnx.load(f"{gen_models_path}/{model_base_name}.onnx")
       fp16_fix = False
       for tensor in onnx.external_data_helper._get_all_tensors(model):
           nptensor = numpy_helper.to_array(tensor, gen_models_path)
           if nptensor.dtype == np.float32 and (
               np.any(nptensor > fp16_max) or np.any(nptensor < fp16_min)
           ):
               # print(f'tensor value : {nptensor} above {fp16_max} or below {fp16_min}')
               nptensor = np.clip(nptensor, fp16_min, fp16_max)
               new_tensor = numpy_helper.from_array(nptensor, tensor.name)
               tensor.CopyFrom(new_tensor)
               fp16_fix = True
               
       if fp16_fix:
           # Save FP16 model
           print("Found constants out of FP16 range, clipped to FP16 range")
           model_base_name += "_fix_outofrange_fp16"
           onnx.save(model, f=f"{gen_models_path}/{model_base_name}.onnx")
           print(f"Saving modified onnx file at {gen_models_path}/{model_base_name}.onnx")
       return model_base_name
   
   fp16_model_name = fix_onnx_fp16(gen_models_path=gen_models_path, model_base_name=model_base_name)

Étape 3. Compiler le modèle

La qaic-exec L'outil de compilation de l'interface de ligne de commande (CLI) est utilisé pour compiler le modèle. L'entrée de ce compilateur est le fichier ONNX généré à l'étape 2. Le compilateur produit un fichier binaire (appelé QPC, Pour Conteneur de programme Qualcomm) dans le chemin défini par -aic-binary-dir argument.

Dans la commande de compilation ci-dessous, vous utilisez quatre cœurs de calcul IA et une taille de lot d'un pour compiler le modèle.

/opt/qti-aic/exec/qaic-exec 
-m=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16.onnx 
-aic-num-cores=4 
-convert-to-fp16 
-onnx-define-symbol=batch,1 -onnx-define-symbol=sequence,128 
-aic-binary-dir=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc 
-aic-hw -aic-hw-version=2.0 
-compile-only

Le QPC est généré dans le bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc dossier.

Étape 4. Exécutez le modèle

Configurez une session pour exécuter l'inférence sur un accélérateur Cloud AI100 Qualcomm dans l'instance DL2q.

La bibliothèque Qualcomm qaic Python est un ensemble d'API qui prend en charge l'exécution d'inférences sur l'accélérateur Cloud AI100.

1. Utilisez l'appel d'API Session pour créer une instance de session. L'appel API Session est le point d'entrée pour utiliser la bibliothèque qaic Python.

   qpcPath = 'bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc'
   
   bert_sess = qaic.Session(model_path= qpcPath+'/programqpc.bin', num_activations=1)  
   bert_sess.setup() # Loads the network to the device. 
   
   # Here we are reading out all the input and output shapes/types
   input_shape, input_type = bert_sess.model_input_shape_dict['input_ids']
   attn_shape, attn_type = bert_sess.model_input_shape_dict['attention_mask']
   output_shape, output_type = bert_sess.model_output_shape_dict['logits']
   
   #create the input dictionary for given input sentence
   input_dict = {"input_ids": inputIds.numpy().astype(input_type), "attention_mask" : attentionMask.numpy().astype(attn_type)}
   
   #run inference on Cloud AI 100
   output = bert_sess.run(input_dict)

2. Restructurez les données du tampon de sortie avec output_shape ainsi que output_type.

   token_logits = np.frombuffer(output['logits'], dtype=output_type).reshape(output_shape)

3. Décodez le résultat produit.

   mask_token_logits = torch.from_numpy(token_logits[0, mask_token_index, :]).unsqueeze(0)
   top_5_results = torch.topk(mask_token_logits, 5, dim=1)
   print("Model output (top5) from Qualcomm Cloud AI 100:")
   for i in range(5):
       idx = top_5_results.indices[0].tolist()[i]
       val = top_5_results.values[0].tolist()[i]
       word = tokenizer.decode([idx])
       print(f"{i+1} :(word={word}, index={idx}, logit={round(val,2)})")

Voici les résultats de la phrase d'entrée « Le chien [MASQUE] sur le tapis ».

1 :(word=sat, index=2068, logit=11.46)
2 :(word=landed, index=4860, logit=11.11)
3 :(word=spat, index=15732, logit=10.95)
4 :(word=settled, index=3035, logit=10.84)
5 :(word=was, index=1108, logit=10.75)

C'est ça. En quelques étapes seulement, vous avez compilé et exécuté un modèle PyTorch sur une instance Amazon EC2 DL2q. Pour en savoir plus sur l'intégration et la compilation de modèles sur l'instance DL2q, consultez le Documentation du didacticiel Cloud AI100.

Pour en savoir plus sur les architectures de modèles DL adaptées aux instances AWS DL2q et sur la matrice de prise en charge actuelle des modèles, consultez le Documentation Qualcomm Cloud AI100.

Disponible dès maintenant

Vous pouvez lancer des instances DL2q dès aujourd'hui dans les régions AWS USA Ouest (Oregon) et Europe (Francfort) en tant que À la demande, Reservéet une Instances ponctuelles, ou dans le cadre d'un Plan d'épargne. Comme d'habitude avec Amazon EC2, vous ne payez que ce que vous utilisez. Pour plus d'informations, voir Tarification Amazon EC2.

Les instances DL2q peuvent être déployées à l'aide AMI d'apprentissage en profondeur AWS (DLAMI), et les images de conteneurs sont disponibles via des services gérés tels que Amazon Sage Maker, Service Amazon Elastic Kubernetes (Amazon EKS), Amazon Elastic Container Service (Amazon ECS)et une AWS ParallelCluster.

Pour en savoir plus, visitez le Instance Amazon EC2 DL2q page et envoyez vos commentaires à AWS re:Post pour EC2 ou via vos contacts AWS Support habituels.

À propos des auteurs

AK Roy est directeur de la gestion des produits chez Qualcomm, pour les produits et solutions d'IA Cloud et Datacenter. Il a plus de 20 ans d'expérience dans la stratégie et le développement de produits, avec pour objectif actuel les meilleures solutions de bout en bout en termes de performances et de performances/$ pour l'inférence d'IA dans le Cloud, pour un large éventail de cas d'utilisation, y compris GenAI, LLM, Auto et Hybrid AI.

Jianying Lang est architecte de solutions principal chez AWS Worldwide Specialist Organization (WWSO). Elle possède plus de 15 ans d’expérience professionnelle dans le domaine du HPC et de l’IA. Chez AWS, elle s'efforce d'aider les clients à déployer, optimiser et faire évoluer leurs charges de travail IA/ML sur des instances de calcul accélérées. Elle est passionnée par la combinaison des techniques dans les domaines du HPC et de l'IA. Jianying est titulaire d'un doctorat en physique computationnelle de l'Université du Colorado à Boulder.

• 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. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/