L'istanza Amazon EC2 DL2q per l'inferenza IA economica e ad alte prestazioni è ora disponibile a livello generale | Servizi Web di Amazon

Questo è un guest post di AK Roy di Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) Le istanze DL2q, basate sugli acceleratori Qualcomm AI 100 Standard, possono essere utilizzate per distribuire in modo conveniente carichi di lavoro di deep learning (DL) nel cloud. Possono anche essere utilizzati per sviluppare e convalidare le prestazioni e l'accuratezza dei carichi di lavoro DL che verranno distribuiti sui dispositivi Qualcomm. Le istanze DL2q sono le prime a portare la tecnologia di intelligenza artificiale (AI) di Qualcomm nel cloud.

Con otto acceleratori Qualcomm AI 100 Standard e 128 GiB di memoria totale dell'acceleratore, i clienti possono anche utilizzare le istanze DL2q per eseguire applicazioni di intelligenza artificiale generativa popolari, come generazione di contenuti, riepilogo di testo e assistenti virtuali, nonché classiche applicazioni di intelligenza artificiale per l'elaborazione del linguaggio naturale e visione artificiale. Inoltre, gli acceleratori Qualcomm AI 100 presentano la stessa tecnologia AI utilizzata su smartphone, guida autonoma, personal computer e visori per realtà estesa, quindi le istanze DL2q possono essere utilizzate per sviluppare e convalidare questi carichi di lavoro AI prima della distribuzione.

Punti salienti della nuova istanza DL2q

Ogni istanza DL2q incorpora otto acceleratori Qualcomm Cloud AI100, con prestazioni aggregate di oltre 2.8 PetaOps di prestazioni di inferenza Int8 e 1.4 PetaFlops di prestazioni di inferenza FP16. L'istanza ha un totale di 112 core AI, una capacità di memoria dell'acceleratore di 128 GB e una larghezza di banda della memoria di 1.1 TB al secondo.

Ogni istanza DL2q ha 96 vCPU, una capacità di memoria di sistema di 768 GB e supporta una larghezza di banda di rete di 100 Gbps, nonché Negozio Amazon Elastic Block (Amazon EBS) memoria di 19 Gbps.

Innovazione dell'acceleratore Qualcomm Cloud AI100

Il system-on-chip (SoC) dell'acceleratore Cloud AI100 è un'architettura multi-core scalabile e appositamente progettata, che supporta un'ampia gamma di casi d'uso di deep learning che vanno dal data center all'edge. Il SoC utilizza core di calcolo scalari, vettoriali e tensoriali con una capacità SRAM on-die leader del settore di 126 MB. I core sono interconnessi con una rete network-on-chip (NoC) a larghezza di banda elevata e a bassa latenza.

L'acceleratore AI100 supporta una gamma ampia e completa di modelli e casi d'uso. La tabella seguente evidenzia la gamma del modello di supporto.

* La maggior parte delle reti automobilistiche sono reti composite costituite dalla fusione di reti individuali.

La grande SRAM on-die dell'acceleratore DL2q consente un'implementazione efficiente di tecniche prestazionali avanzate come la precisione del microesponente MX6 per la memorizzazione dei pesi e la precisione del microesponente MX9 per la comunicazione da acceleratore ad acceleratore. La tecnologia micro-esponente è descritta nel seguente annuncio di settore dell'Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA e Qualcomm standardizzano i formati di dati a precisione ridotta di prossima generazione per l'intelligenza artificiale » Progetto Open Compute.

L'utente dell'istanza può utilizzare la seguente strategia per massimizzare il rapporto prestazioni per costo:

• Memorizza i pesi utilizzando la precisione del microesponente MX6 nella memoria DDR sull'acceleratore. L'utilizzo della precisione MX6 massimizza l'utilizzo della capacità di memoria disponibile e della larghezza di banda della memoria per fornire throughput e latenza migliori della categoria.
• Elaborazione in FP16 per fornire la precisione richiesta dal caso d'uso, utilizzando al tempo stesso la SRAM su chip superiore e TOP di riserva sulla scheda, per implementare kernel da MX6 a FP16 ad alte prestazioni e a bassa latenza.
• Utilizzare una strategia di batch ottimizzata e dimensioni batch più elevate utilizzando la grande SRAM su chip disponibile per massimizzare il riutilizzo dei pesi, mantenendo al massimo le attivazioni su chip.

Stack AI e toolchain DL2q

L'istanza DL2q è accompagnata dallo stack AI di Qualcomm che offre un'esperienza di sviluppo coerente attraverso l'intelligenza artificiale di Qualcomm nel cloud e altri prodotti Qualcomm. Lo stesso stack AI di Qualcomm e la stessa tecnologia AI di base vengono eseguiti sulle istanze DL2q e sui dispositivi edge Qualcomm, offrendo ai clienti un'esperienza di sviluppo coerente, con un'API unificata nei loro ambienti di sviluppo cloud, automobilistici, personal computer, realtà estesa e smartphone.

La toolchain consente all'utente dell'istanza di integrare rapidamente un modello precedentemente addestrato, compilare e ottimizzare il modello per le funzionalità dell'istanza e successivamente distribuire i modelli compilati per casi d'uso di inferenza di produzione in tre passaggi mostrati nella figura seguente.

Per ulteriori informazioni sull'ottimizzazione delle prestazioni di un modello, consultare la Parametri chiave delle prestazioni Cloud AI 100 Documentazione.

Inizia con le istanze DL2q

In questo esempio compili e distribuisci un file pre-addestrato modello BERT da Abbracciare il viso su un'istanza EC2 DL2q utilizzando un'AMI DL2q disponibile precostruita, in quattro passaggi.

Puoi utilizzare un file pre-costruito Qualcomm DLAMI sull'istanza o iniziare con un'AMI Amazon Linux2 e creare la propria AMI DL2q con la piattaforma Cloud AI 100 e l'SDK per app disponibile in questo Servizio di archiviazione semplice Amazon (Amazon S3) benna: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

I passaggi che seguono utilizzano l'AMI DL2q predefinita, Qualcomm Base AL2 DLAMI.

Utilizza SSH per accedere alla tua istanza DL2q con l'AMI DLAMI Qualcomm Base AL2 e segui i passaggi da 1 a 4.

Passaggio 1. Configura l'ambiente e installa i pacchetti richiesti

1. Installa Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configura l'ambiente virtuale Python 3.8.

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

3. Attiva l'ambiente virtuale Python 3.8.

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

4. Installare i pacchetti richiesti, mostrati nel file documento requisiti.txt disponibile sul sito Github pubblico di Qualcomm.

   pip3 install -r requirements.txt

5. Importa le librerie necessarie.

   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

Passaggio 2. Importa il modello

1. Importa e tokenizza il modello.

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

2. Definire un input di esempio ed estrarre il file inputIds ed 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. Converti il ​​modello in ONNX, che può quindi essere passato al compilatore.

   # 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. Eseguirai il modello con precisione FP16. Pertanto, è necessario verificare se il modello contiene costanti oltre l'intervallo FP16. Passa il modello a fix_onnx_fp16 funzione per generare il nuovo file ONNX con le correzioni richieste.

   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)

Passaggio 3. Compila il modello

I qaic-exec Lo strumento di compilazione dell'interfaccia a riga di comando (CLI) viene utilizzato per compilare il modello. L'input per questo compilatore è il file ONNX generato nel passaggio 2. Il compilatore produce un file binario (chiamato QPC, Per Contenitore del programma Qualcomm) nel percorso definito da -aic-binary-dir discussione.

Nel comando di compilazione seguente, utilizzi quattro core di calcolo AI e una dimensione batch pari a uno per compilare il modello.

/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

Il QPC viene generato nel file bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc cartella.

Passaggio 4. Eseguire il modello

Configura una sessione per eseguire l'inferenza su un acceleratore Qualcomm Cloud AI100 nell'istanza DL2q.

La libreria Qualcomm qaic Python è un set di API che fornisce supporto per l'esecuzione dell'inferenza sull'acceleratore Cloud AI100.

1. Utilizza la chiamata API Session per creare un'istanza di sessione. La chiamata API Session è il punto di ingresso per utilizzare la libreria 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. Ristrutturare i dati dal buffer di output con output_shape ed output_type.

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

3. Decodificare l'output prodotto.

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

Ecco gli output per la frase di input "Il cane [MASK] sul tappetino".

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)

Questo è tutto. Con pochi passaggi hai compilato ed eseguito un modello PyTorch su un'istanza DL2q di Amazon EC2. Per ulteriori informazioni sull'onboarding e sulla compilazione di modelli sull'istanza DL2q, consulta il file Documentazione sull'esercitazione Cloud AI100.

Per ulteriori informazioni su quali architetture del modello DL sono adatte per le istanze AWS DL2q e l'attuale matrice di supporto del modello, consulta la sezione Documentazione Qualcomm Cloud AI100.

Disponibile ora

Puoi lanciare istanze DL2q oggi stesso nelle regioni AWS Stati Uniti occidentali (Oregon) ed Europa (Francoforte) come Su richiesta, RISERVATOe Istanze Spoto come parte di a Piano di risparmio. Come al solito con Amazon EC2, paghi solo ciò che utilizzi. Per ulteriori informazioni, vedere Prezzi di Amazon EC2.

Le istanze DL2q possono essere distribuite utilizzando AMI di deep learning AWS (DLAMI)e le immagini del contenitore sono disponibili tramite servizi gestiti come Amazon Sage Maker, Servizio Amazon Elastic Kubernetes (Amazon EKS), Servizio Amazon Elastic Container (Amazon ECS)e AWS ParallelCluster.

Per saperne di più, visita il Istanza DL2q di Amazon EC2 pagina e inviare feedback a AWS re:Post per EC2 o tramite i tuoi contatti abituali di AWS Support.

Circa gli autori

AK Roy è Direttore della gestione dei prodotti presso Qualcomm, per prodotti e soluzioni AI cloud e datacenter. Ha oltre 20 anni di esperienza nella strategia e nello sviluppo di prodotti, con l'attuale focus sulle migliori soluzioni end-to-end in termini di prestazioni e prestazioni/$ per l'inferenza dell'intelligenza artificiale nel cloud, per l'ampia gamma di casi d'uso, inclusi GenAI, LLM, Auto e AI ibrida.

Jianying Lang è Principal Solutions Architect presso AWS Worldwide Specialist Organization (WWSO). Ha oltre 15 anni di esperienza lavorativa nel campo HPC e AI. In AWS, si concentra sull'aiutare i clienti a distribuire, ottimizzare e scalare i propri carichi di lavoro AI/ML su istanze di elaborazione accelerate. La sua passione è combinare le tecniche nei campi HPC e AI. Jianying ha conseguito un dottorato di ricerca in fisica computazionale presso l'Università del Colorado a Boulder.

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
• PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
• PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
• Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/